arch/all-pc/acpica/source/tools/acpibin/abcompare.c

   1 /******************************************************************************
   2  *
   3  * Module Name: abcompare - compare AML files
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2013, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include "acpibin.h"
  45
  46
  47 FILE                        *File1;
  48 FILE                        *File2;
  49 ACPI_TABLE_HEADER           Header1;
  50 ACPI_TABLE_HEADER           Header2;
  51
  52 #define BUFFER_SIZE         256
  53 char                        Buffer[BUFFER_SIZE];
  54
  55
  56 /* Local prototypes */
  57
  58 static BOOLEAN
  59 AbValidateHeader (
  60     ACPI_TABLE_HEADER       *Header);
  61
  62 static UINT8
  63 AcpiTbSumTable (
  64     void                    *Buffer,
  65     UINT32                  Length);
  66
  67 static char *
  68 AbGetFile (
  69     char                    *Filename,
  70     UINT32                  *FileSize);
  71
  72 static UINT32
  73 AbGetFileSize (
  74     FILE                    *File);
  75
  76 static void
  77 AbPrintHeaderInfo (
  78     ACPI_TABLE_HEADER       *Header);
  79
  80 static void
  81 AbPrintHeadersInfo (
  82     ACPI_TABLE_HEADER       *Header,
  83     ACPI_TABLE_HEADER       *Header2);
  84
  85 ACPI_PHYSICAL_ADDRESS
  86 AeLocalGetRootPointer (
  87     void);
  88
  89
  90 /*******************************************************************************
  91  *
  92  * FUNCTION:    UtHexCharToValue
  93  *
  94  * PARAMETERS:  HexChar         - Hex character in Ascii
  95  *
  96  * RETURN:      The binary value of the hex character
  97  *
  98  * DESCRIPTION: Perform ascii-to-hex translation
  99  *
 100  ******************************************************************************/
 101
 102 static UINT8
 103 UtHexCharToValue (
 104     int                     HexChar,
 105     UINT8                   *OutBinary)
 106 {
 107
 108     if (HexChar >= 0x30 && HexChar <= 0x39)
 109     {
 110         *OutBinary = (UINT8) (HexChar - 0x30);
 111         return (1);
 112     }
 113
 114     else if (HexChar >= 0x41 && HexChar <= 0x46)
 115     {
 116         *OutBinary = (UINT8) (HexChar - 0x37);
 117         return (1);
 118     }
 119
 120     else if (HexChar >= 0x61 && HexChar <= 0x66)
 121     {
 122         *OutBinary = (UINT8) (HexChar - 0x57);
 123         return (1);
 124     }
 125     return (0);
 126 }
 127
 128 static UINT8
 129 AbHexByteToBinary (
 130     char                    *HexString,
 131     char                    *OutBinary)
 132 {
 133     UINT8                   Local1;
 134     UINT8                   Local2;
 135
 136
 137     if (!UtHexCharToValue (HexString[0], &Local1))
 138     {
 139         return (0);
 140     }
 141     if (!UtHexCharToValue (HexString[1], &Local2))
 142     {
 143         return (0);
 144     }
 145
 146     *OutBinary = (UINT8) ((Local1 << 4) | Local2);
 147     return (2);
 148
 149 }
 150
 151
 152 /******************************************************************************
 153  *
 154  * FUNCTION:    AbValidateHeader
 155  *
 156  * DESCRIPTION: Check for valid ACPI table header
 157  *
 158  ******************************************************************************/
 159
 160 static BOOLEAN
 161 AbValidateHeader (
 162     ACPI_TABLE_HEADER       *Header)
 163 {
 164
 165     if (!AcpiUtValidAcpiName (Header->Signature))
 166     {
 167         printf ("Header signature is invalid\n");
 168         return (FALSE);
 169     }
 170
 171     return (TRUE);
 172 }
 173
 174
 175 /*******************************************************************************
 176  *
 177  * FUNCTION:    AcpiTbSumTable
 178  *
 179  * PARAMETERS:  Buffer              - Buffer to checksum
 180  *              Length              - Size of the buffer
 181  *
 182  * RETURNS      8 bit checksum of buffer
 183  *
 184  * DESCRIPTION: Computes an 8 bit checksum of the buffer(length) and returns it.
 185  *
 186  ******************************************************************************/
 187
 188 static UINT8
 189 AcpiTbSumTable (
 190     void                    *Buffer,
 191     UINT32                  Length)
 192 {
 193     const UINT8             *limit;
 194     const UINT8             *rover;
 195     UINT8                   sum = 0;
 196
 197
 198     if (Buffer && Length)
 199     {
 200         /* Buffer and Length are valid */
 201
 202         limit = (UINT8 *) Buffer + Length;
 203
 204         for (rover = Buffer; rover < limit; rover++)
 205         {
 206             sum = (UINT8) (sum + *rover);
 207         }
 208     }
 209     return (sum);
 210 }
 211
 212
 213 /*******************************************************************************
 214  *
 215  * FUNCTION:    AbPrintHeaderInfo
 216  *
 217  * PARAMETERS:  Header              - An ACPI table header
 218  *
 219  * RETURNS      None.
 220  *
 221  * DESCRIPTION: Format and display header contents.
 222  *
 223  ******************************************************************************/
 224
 225 static void
 226 AbPrintHeaderInfo (
 227     ACPI_TABLE_HEADER       *Header)
 228 {
 229
 230     /* Display header information */
 231
 232     printf ("Signature         : %4.4s\n",    Header->Signature);
 233     printf ("Length            : %8.8X\n",    Header->Length);
 234     printf ("Revision          : %2.2X\n",    Header->Revision);
 235     printf ("Checksum          : %2.2X\n",    Header->Checksum);
 236     printf ("OEM ID            : %6.6s\n",    Header->OemId);
 237     printf ("OEM Table ID      : %8.8s\n",    Header->OemTableId);
 238     printf ("OEM Revision      : %8.8X\n",    Header->OemRevision);
 239     printf ("ASL Compiler ID   : %4.4s\n",    Header->AslCompilerId);
 240     printf ("Compiler Revision : %8.8X\n",    Header->AslCompilerRevision);
 241     printf ("\n");
 242 }
 243
 244 static void
 245 AbPrintHeadersInfo (
 246     ACPI_TABLE_HEADER       *Header,
 247     ACPI_TABLE_HEADER       *Header2)
 248 {
 249
 250     /* Display header information for both headers */
 251
 252     printf ("Signature          %8.4s : %4.4s\n",    Header->Signature, Header2->Signature);
 253     printf ("Length             %8.8X : %8.8X\n",    Header->Length, Header2->Length);
 254     printf ("Revision           %8.2X : %2.2X\n",    Header->Revision, Header2->Revision);
 255     printf ("Checksum           %8.2X : %2.2X\n",    Header->Checksum, Header2->Checksum);
 256     printf ("OEM ID             %8.6s : %6.6s\n",    Header->OemId, Header2->OemId);
 257     printf ("OEM Table ID       %8.8s : %8.8s\n",    Header->OemTableId, Header2->OemTableId);
 258     printf ("OEM Revision       %8.8X : %8.8X\n",    Header->OemRevision, Header2->OemRevision);
 259     printf ("ASL Compiler ID    %8.4s : %4.4s\n",    Header->AslCompilerId, Header2->AslCompilerId);
 260     printf ("Compiler Revision  %8.8X : %8.8X\n",    Header->AslCompilerRevision, Header2->AslCompilerRevision);
 261     printf ("\n");
 262 }
 263
 264
 265 /******************************************************************************
 266  *
 267  * FUNCTION:    AbDisplayHeader
 268  *
 269  * DESCRIPTION: Display an ACPI table header
 270  *
 271  ******************************************************************************/
 272
 273 void
 274 AbDisplayHeader (
 275     char                    *File1Path)
 276 {
 277     UINT32                  Actual;
 278
 279
 280     File1 = fopen (File1Path, "rb");
 281     if (!File1)
 282     {
 283         printf ("Could not open file %s\n", File1Path);
 284         return;
 285     }
 286
 287     Actual = fread (&Header1, 1, sizeof (ACPI_TABLE_HEADER), File1);
 288     if (Actual != sizeof (ACPI_TABLE_HEADER))
 289     {
 290         printf ("File %s does not contain an ACPI table header\n", File1Path);
 291         return;
 292     }
 293
 294     if (!AbValidateHeader (&Header1))
 295     {
 296         return;
 297     }
 298
 299     AbPrintHeaderInfo (&Header1);
 300 }
 301
 302
 303 /******************************************************************************
 304  *
 305  * FUNCTION:    AbComputeChecksum
 306  *
 307  * DESCRIPTION: Compute proper checksum for an ACPI table
 308  *
 309  ******************************************************************************/
 310
 311 void
 312 AbComputeChecksum (
 313     char                    *File1Path)
 314 {
 315     UINT32                  Actual;
 316     ACPI_TABLE_HEADER       *Table;
 317     UINT8                   Checksum;
 318
 319
 320     File1 = fopen (File1Path, "rb");
 321     if (!File1)
 322     {
 323         printf ("Could not open file %s\n", File1Path);
 324         return;
 325     }
 326
 327     Actual = fread (&Header1, 1, sizeof (ACPI_TABLE_HEADER), File1);
 328     if (Actual < sizeof (ACPI_TABLE_HEADER))
 329     {
 330         printf ("File %s does not contain an ACPI table header\n", File1Path);
 331         return;
 332     }
 333
 334     if (!AbValidateHeader (&Header1))
 335     {
 336         return;
 337     }
 338
 339     if (!Gbl_TerseMode)
 340     {
 341         AbPrintHeaderInfo (&Header1);
 342     }
 343
 344     /* Allocate a buffer to hold the entire table */
 345
 346     Table = AcpiOsAllocate (Header1.Length);
 347     if (!Table)
 348     {
 349         printf ("could not allocate\n");
 350         return;
 351     }
 352
 353     /* Read the entire table, including header */
 354
 355     fseek (File1, 0, SEEK_SET);
 356     Actual = fread (Table, 1, Header1.Length, File1);
 357     if (Actual != Header1.Length)
 358     {
 359         printf ("could not read table, length %u\n", Header1.Length);
 360         return;
 361     }
 362
 363     /* Compute the checksum for the table */
 364
 365     Table->Checksum = 0;
 366
 367     Checksum = (UINT8) (0 - AcpiTbSumTable (Table, Table->Length));
 368     printf ("Computed checksum: 0x%X\n\n", Checksum);
 369
 370     if (Header1.Checksum == Checksum)
 371     {
 372         printf ("Checksum ok in AML file, not updating\n");
 373         return;
 374     }
 375
 376     /* Open the target file for writing, to update checksum */
 377
 378     fclose (File1);
 379     File1 = fopen (File1Path, "r+b");
 380     if (!File1)
 381     {
 382         printf ("Could not open file %s for writing\n", File1Path);
 383         return;
 384     }
 385
 386     /* Set the checksum, write the new header */
 387
 388     Header1.Checksum = Checksum;
 389
 390     Actual = fwrite (&Header1, 1, sizeof (ACPI_TABLE_HEADER), File1);
 391     if (Actual != sizeof (ACPI_TABLE_HEADER))
 392     {
 393         printf ("Could not write updated table header\n");
 394         return;
 395     }
 396
 397     printf ("Wrote new checksum\n");
 398     return;
 399 }
 400
 401
 402 /******************************************************************************
 403  *
 404  * FUNCTION:    AbCompareAmlFiles
 405  *
 406  * DESCRIPTION: Compare two AML files
 407  *
 408  ******************************************************************************/
 409
 410 int
 411 AbCompareAmlFiles (
 412     char                    *File1Path,
 413     char                    *File2Path)
 414 {
 415     UINT32                  Actual1;
 416     UINT32                  Actual2;
 417     UINT32                  Offset;
 418     UINT8                   Char1;
 419     UINT8                   Char2;
 420     UINT8                   Mismatches = 0;
 421     BOOLEAN                 HeaderMismatch = FALSE;
 422
 423
 424     File1 = fopen (File1Path, "rb");
 425     if (!File1)
 426     {
 427         printf ("Could not open file %s\n", File1Path);
 428         return (-1);
 429     }
 430
 431     File2 = fopen (File2Path, "rb");
 432     if (!File2)
 433     {
 434         printf ("Could not open file %s\n", File2Path);
 435         return (-1);
 436     }
 437
 438     /* Read the ACPI header from each file */
 439
 440     Actual1 = fread (&Header1, 1, sizeof (ACPI_TABLE_HEADER), File1);
 441     if (Actual1 != sizeof (ACPI_TABLE_HEADER))
 442     {
 443         printf ("File %s does not contain an ACPI table header\n", File1Path);
 444         return (-1);
 445     }
 446
 447     Actual2 = fread (&Header2, 1, sizeof (ACPI_TABLE_HEADER), File2);
 448     if (Actual2 != sizeof (ACPI_TABLE_HEADER))
 449     {
 450         printf ("File %s does not contain an ACPI table header\n", File2Path);
 451         return (-1);
 452     }
 453
 454     if ((!AbValidateHeader (&Header1)) ||
 455         (!AbValidateHeader (&Header2)))
 456     {
 457         return (-1);
 458     }
 459
 460     /* Table signatures must match */
 461
 462     if (*((UINT32 *) Header1.Signature) != *((UINT32 *) Header2.Signature))
 463     {
 464         printf ("Table signatures do not match\n");
 465         return (-1);
 466     }
 467
 468     if (!Gbl_TerseMode)
 469     {
 470         /* Display header information */
 471
 472         AbPrintHeadersInfo (&Header1, &Header2);
 473     }
 474
 475     if (memcmp (&Header1, &Header2, sizeof (ACPI_TABLE_HEADER)))
 476     {
 477         printf ("Headers do not match exactly\n");
 478         HeaderMismatch = TRUE;
 479     }
 480
 481     /* Do the byte-by-byte compare */
 482
 483     Actual1 = fread (&Char1, 1, 1, File1);
 484     Actual2 = fread (&Char2, 1, 1, File2);
 485     Offset = sizeof (ACPI_TABLE_HEADER);
 486
 487     while ((Actual1 == 1) && (Actual2 == 1))
 488     {
 489         if (Char1 != Char2)
 490         {
 491             printf ("Error - Byte mismatch at offset %8.8X: 0x%2.2X 0x%2.2X\n",
 492                 Offset, Char1, Char2);
 493             Mismatches++;
 494             if (Mismatches > 100)
 495             {
 496                 printf ("100 Mismatches: Too many mismatches\n");
 497                 return (-1);
 498             }
 499         }
 500
 501         Offset++;
 502         Actual1 = fread (&Char1, 1, 1, File1);
 503         Actual2 = fread (&Char2, 1, 1, File2);
 504     }
 505
 506     if (Actual1)
 507     {
 508         printf ("Error - file %s is longer than file %s\n", File1Path, File2Path);
 509         Mismatches++;
 510     }
 511     else if (Actual2)
 512     {
 513         printf ("Error - file %s is shorter than file %s\n", File1Path, File2Path);
 514         Mismatches++;
 515     }
 516     else if (!Mismatches)
 517     {
 518         if (HeaderMismatch)
 519         {
 520             printf ("Files compare exactly after header\n");
 521         }
 522         else
 523         {
 524             printf ("Files compare exactly\n");
 525         }
 526     }
 527
 528     printf ("%u Mismatches found\n", Mismatches);
 529     return (0);
 530 }
 531
 532
 533 /******************************************************************************
 534  *
 535  * FUNCTION:    AbGetFileSize
 536  *
 537  * DESCRIPTION: Get the size of an open file
 538  *
 539  ******************************************************************************/
 540
 541 static UINT32
 542 AbGetFileSize (
 543     FILE                    *File)
 544 {
 545     UINT32                  FileSize;
 546     long                    Offset;
 547
 548
 549     Offset = ftell (File);
 550
 551     if (fseek (File, 0, SEEK_END))
 552     {
 553         return (0);
 554     }
 555
 556     FileSize = (UINT32) ftell (File);
 557
 558     /* Restore file pointer */
 559
 560     if (fseek (File, Offset, SEEK_SET))
 561     {
 562         return (0);
 563     }
 564
 565     return (FileSize);
 566 }
 567
 568
 569 /******************************************************************************
 570  *
 571  * FUNCTION:    AbGetFile
 572  *
 573  * DESCRIPTION: Open a file and read it entirely into a new buffer
 574  *
 575  ******************************************************************************/
 576
 577 static char *
 578 AbGetFile (
 579     char                    *Filename,
 580     UINT32                  *FileSize)
 581 {
 582     FILE                    *File;
 583     UINT32                  Size;
 584     char                    *Buffer = NULL;
 585     size_t                  Actual;
 586
 587
 588     /* Binary mode does not alter CR/LF pairs */
 589
 590     File = fopen (Filename, "rb");
 591     if (!File)
 592     {
 593         printf ("Could not open file %s\n", Filename);
 594         return (NULL);
 595     }
 596
 597     /* Need file size to allocate a buffer */
 598
 599     Size = AbGetFileSize (File);
 600     if (!Size)
 601     {
 602         printf ("Could not get file size (seek) for %s\n", Filename);
 603         goto ErrorExit;
 604     }
 605
 606     /* Allocate a buffer for the entire file */
 607
 608     Buffer = calloc (Size, 1);
 609     if (!Buffer)
 610     {
 611         printf ("Could not allocate buffer of size %u\n", Size);
 612         goto ErrorExit;
 613     }
 614
 615     /* Read the entire file */
 616
 617     Actual = fread (Buffer, 1, Size, File);
 618     if (Actual != Size)
 619     {
 620         printf ("Could not read the input file %s\n", Filename);
 621         free (Buffer);
 622         Buffer = NULL;
 623         goto ErrorExit;
 624     }
 625
 626     *FileSize = Size;
 627
 628 ErrorExit:
 629     fclose (File);
 630     return (Buffer);
 631 }
 632
 633
 634 /******************************************************************************
 635  *
 636  * FUNCTION:    AbDumpAmlFile
 637  *
 638  * DESCRIPTION: Dump a binary AML file to a text file
 639  *
 640  ******************************************************************************/
 641
 642 int
 643 AbDumpAmlFile (
 644     char                    *File1Path,
 645     char                    *File2Path)
 646 {
 647     char                    *FileBuffer;
 648     FILE                    *FileOutHandle;
 649     UINT32                  FileSize = 0;
 650
 651
 652     /* Get the entire AML file, validate header */
 653
 654     FileBuffer = AbGetFile (File1Path, &FileSize);
 655     if (!FileBuffer)
 656     {
 657         return (-1);
 658     }
 659
 660     printf ("Input file:  %s contains %u (0x%X) bytes\n",
 661         File1Path, FileSize, FileSize);
 662
 663     FileOutHandle = fopen (File2Path, "wb");
 664     if (!FileOutHandle)
 665     {
 666         printf ("Could not open file %s\n", File2Path);
 667         return (-1);
 668     }
 669
 670     if (!AbValidateHeader ((ACPI_TABLE_HEADER *) FileBuffer))
 671     {
 672         return (-1);
 673     }
 674
 675     /* Convert binary AML to text, using common dump buffer routine */
 676
 677     AcpiGbl_DebugFile = FileOutHandle;
 678     AcpiGbl_DbOutputFlags = ACPI_DB_REDIRECTABLE_OUTPUT;
 679
 680     AcpiOsPrintf ("%4.4s @ 0x%8.8X\n",
 681         ((ACPI_TABLE_HEADER *) FileBuffer)->Signature, 0);
 682
 683     AcpiUtDumpBuffer ((UINT8 *) FileBuffer, FileSize, DB_BYTE_DISPLAY, 0);
 684
 685     /* Summary for the output file */
 686
 687     FileSize = AbGetFileSize (FileOutHandle);
 688     printf ("Output file: %s contains %u (0x%X) bytes\n\n",
 689         File2Path, FileSize, FileSize);
 690
 691     return (0);
 692 }
 693
 694
 695 /******************************************************************************
 696  *
 697  * FUNCTION:    AbExtractAmlFile
 698  *
 699  * DESCRIPTION: Extract a binary AML file from a text file (as produced by the
 700  *              DumpAmlFile procedure or the "acpidump" table utility.
 701  *
 702  ******************************************************************************/
 703
 704 int
 705 AbExtractAmlFile (
 706     char                    *TableSig,
 707     char                    *File1Path,
 708     char                    *File2Path)
 709 {
 710     char                    *Table;
 711     char                    Value;
 712     UINT32                  i;
 713     FILE                    *FileHandle;
 714     FILE                    *FileOutHandle;
 715     UINT32                  Count = 0;
 716     int                     Scanned;
 717
 718
 719     /* Open in/out files. input is in text mode, output is in binary mode */
 720
 721     FileHandle = fopen (File1Path, "rt");
 722     if (!FileHandle)
 723     {
 724         printf ("Could not open file %s\n", File1Path);
 725         return (-1);
 726     }
 727
 728     FileOutHandle = fopen (File2Path, "w+b");
 729     if (!FileOutHandle)
 730     {
 731         printf ("Could not open file %s\n", File2Path);
 732         return (-1);
 733     }
 734
 735     /* Force input table sig to uppercase */
 736
 737     AcpiUtStrupr (TableSig);
 738
 739
 740     /* TBD: examine input for ASCII */
 741
 742
 743     /* We have an ascii file, grab one line at a time */
 744
 745     while (fgets (Buffer, BUFFER_SIZE, FileHandle))
 746     {
 747         /* The 4-char ACPI signature appears at the beginning of a line */
 748
 749         if (ACPI_COMPARE_NAME (Buffer, TableSig))
 750         {
 751             printf ("Found table [%4.4s]\n", TableSig);
 752
 753             /*
 754              * Eat all lines in the table, of the form:
 755              *   <offset>: <16 bytes of hex data, separated by spaces> <ASCII representation> <newline>
 756              *
 757              * Example:
 758              *
 759              *   02C0: 5F 53 42 5F 4C 4E 4B 44 00 12 13 04 0C FF FF 08  _SB_LNKD........
 760              *
 761              */
 762             while (fgets (Buffer, BUFFER_SIZE, FileHandle))
 763             {
 764                 /* Get past the offset, terminated by a colon */
 765
 766                 Table = strchr (Buffer, ':');
 767                 if (!Table)
 768                 {
 769                     /* No colon, all done */
 770                     goto Exit;
 771                 }
 772
 773                 Table += 2; /* Eat the colon + space */
 774
 775                 for (i = 0; i < 16; i++)
 776                 {
 777                     Scanned = AbHexByteToBinary (Table, &Value);
 778                     if (!Scanned)
 779                     {
 780                         goto Exit;
 781                     }
 782
 783                     Table += 3; /* Go past this hex byte and space */
 784
 785                     /* Write the converted (binary) byte */
 786
 787                     if (fwrite (&Value, 1, 1, FileOutHandle) != 1)
 788                     {
 789                         printf ("Error writing byte %u to output file: %s\n",
 790                             Count, File2Path);
 791                         goto Exit;
 792                     }
 793                     Count++;
 794                 }
 795             }
 796
 797             /* No more lines, EOF, all done */
 798
 799             goto Exit;
 800         }
 801     }
 802
 803     /* Searched entire file, no match to table signature */
 804
 805     printf ("Could not match table signature\n");
 806     fclose (FileHandle);
 807     return (-1);
 808
 809 Exit:
 810     printf ("%u (0x%X) bytes written to %s\n", Count, Count, File2Path);
 811     fclose (FileHandle);
 812     fclose (FileOutHandle);
 813     return (0);
 814 }
 815
 816
 817 /******************************************************************************
 818  *
 819  * FUNCTION:    Stubs
 820  *
 821  * DESCRIPTION: For linkage
 822  *
 823  ******************************************************************************/
 824
 825 ACPI_PHYSICAL_ADDRESS
 826 AeLocalGetRootPointer (
 827     void)
 828 {
 829     return (AE_OK);
 830 }
 831
 832 ACPI_THREAD_ID
 833 AcpiOsGetThreadId (
 834     void)
 835 {
 836     return (0xFFFF);
 837 }
 838
 839 ACPI_STATUS
 840 AcpiOsExecute (
 841     ACPI_EXECUTE_TYPE       Type,
 842     ACPI_OSD_EXEC_CALLBACK  Function,
 843     void                    *Context)
 844 {
 845     return (AE_SUPPORT);
 846 }