1 /****************************************************************************** 2 * 3 * Module Name: dtio.c - File I/O support for data table compiler 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 #define __DTIO_C__ 45 46 #include "aslcompiler.h" 47 #include "dtcompiler.h" 48 #include "acapps.h" 49 50 #define _COMPONENT DT_COMPILER 51 ACPI_MODULE_NAME ("dtio") 52 53 54 /* Local prototypes */ 55 56 static char * 57 DtTrim ( 58 char *String); 59 60 static void 61 DtLinkField ( 62 DT_FIELD *Field); 63 64 static ACPI_STATUS 65 DtParseLine ( 66 char *LineBuffer, 67 UINT32 Line, 68 UINT32 Offset); 69 70 static void 71 DtWriteBinary ( 72 DT_SUBTABLE *Subtable, 73 void *Context, 74 void *ReturnValue); 75 76 static void 77 DtDumpBuffer ( 78 UINT32 FileId, 79 UINT8 *Buffer, 80 UINT32 Offset, 81 UINT32 Length); 82 83 static void 84 DtDumpSubtableInfo ( 85 DT_SUBTABLE *Subtable, 86 void *Context, 87 void *ReturnValue); 88 89 static void 90 DtDumpSubtableTree ( 91 DT_SUBTABLE *Subtable, 92 void *Context, 93 void *ReturnValue); 94 95 96 /* States for DtGetNextLine */ 97 98 #define DT_NORMAL_TEXT 0 99 #define DT_START_QUOTED_STRING 1 100 #define DT_START_COMMENT 2 101 #define DT_SLASH_ASTERISK_COMMENT 3 102 #define DT_SLASH_SLASH_COMMENT 4 103 #define DT_END_COMMENT 5 104 #define DT_MERGE_LINES 6 105 #define DT_ESCAPE_SEQUENCE 7 106 107 static UINT32 Gbl_NextLineOffset; 108 109 110 /****************************************************************************** 111 * 112 * FUNCTION: DtTrim 113 * 114 * PARAMETERS: String - Current source code line to trim 115 * 116 * RETURN: Trimmed line. Must be freed by caller. 117 * 118 * DESCRIPTION: Trim left and right spaces 119 * 120 *****************************************************************************/ 121 122 static char * 123 DtTrim ( 124 char *String) 125 { 126 char *Start; 127 char *End; 128 char *ReturnString; 129 ACPI_SIZE Length; 130 131 132 /* Skip lines that start with a space */ 133 134 if (!ACPI_STRCMP (String, " ")) 135 { 136 ReturnString = UtStringCacheCalloc (1); 137 return (ReturnString); 138 } 139 140 /* Setup pointers to start and end of input string */ 141 142 Start = String; 143 End = String + ACPI_STRLEN (String) - 1; 144 145 /* Find first non-whitespace character */ 146 147 while ((Start <= End) && ((*Start == ' ') || (*Start == '\t'))) 148 { 149 Start++; 150 } 151 152 /* Find last non-space character */ 153 154 while (End >= Start) 155 { 156 if (*End == '\r' || *End == '\n') 157 { 158 End--; 159 continue; 160 } 161 162 if (*End != ' ') 163 { 164 break; 165 } 166 167 End--; 168 } 169 170 /* Remove any quotes around the string */ 171 172 if (*Start == '\"') 173 { 174 Start++; 175 } 176 if (*End == '\"') 177 { 178 End--; 179 } 180 181 /* Create the trimmed return string */ 182 183 Length = ACPI_PTR_DIFF (End, Start) + 1; 184 ReturnString = UtStringCacheCalloc (Length + 1); 185 if (ACPI_STRLEN (Start)) 186 { 187 ACPI_STRNCPY (ReturnString, Start, Length); 188 } 189 190 ReturnString[Length] = 0; 191 return (ReturnString); 192 } 193 194 195 /****************************************************************************** 196 * 197 * FUNCTION: DtLinkField 198 * 199 * PARAMETERS: Field - New field object to link 200 * 201 * RETURN: None 202 * 203 * DESCRIPTION: Link one field name and value to the list 204 * 205 *****************************************************************************/ 206 207 static void 208 DtLinkField ( 209 DT_FIELD *Field) 210 { 211 DT_FIELD *Prev; 212 DT_FIELD *Next; 213 214 215 Prev = Next = Gbl_FieldList; 216 217 while (Next) 218 { 219 Prev = Next; 220 Next = Next->Next; 221 } 222 223 if (Prev) 224 { 225 Prev->Next = Field; 226 } 227 else 228 { 229 Gbl_FieldList = Field; 230 } 231 } 232 233 234 /****************************************************************************** 235 * 236 * FUNCTION: DtParseLine 237 * 238 * PARAMETERS: LineBuffer - Current source code line 239 * Line - Current line number in the source 240 * Offset - Current byte offset of the line 241 * 242 * RETURN: Status 243 * 244 * DESCRIPTION: Parse one source line 245 * 246 *****************************************************************************/ 247 248 static ACPI_STATUS 249 DtParseLine ( 250 char *LineBuffer, 251 UINT32 Line, 252 UINT32 Offset) 253 { 254 char *Start; 255 char *End; 256 char *TmpName; 257 char *TmpValue; 258 char *Name; 259 char *Value; 260 char *Colon; 261 UINT32 Length; 262 DT_FIELD *Field; 263 UINT32 Column; 264 UINT32 NameColumn; 265 BOOLEAN IsNullString = FALSE; 266 267 268 if (!LineBuffer) 269 { 270 return (AE_OK); 271 } 272 273 /* All lines after "Raw Table Data" are ingored */ 274 275 if (strstr (LineBuffer, ACPI_RAW_TABLE_DATA_HEADER)) 276 { 277 return (AE_NOT_FOUND); 278 } 279 280 Colon = strchr (LineBuffer, ':'); 281 if (!Colon) 282 { 283 return (AE_OK); 284 } 285 286 Start = LineBuffer; 287 End = Colon; 288 289 while (Start < Colon) 290 { 291 if (*Start == '[') 292 { 293 /* Found left bracket, go to the right bracket */ 294 295 while (Start < Colon && *Start != ']') 296 { 297 Start++; 298 } 299 } 300 else if (*Start != ' ') 301 { 302 break; 303 } 304 305 Start++; 306 } 307 308 /* 309 * There are two column values. One for the field name, 310 * and one for the field value. 311 */ 312 Column = ACPI_PTR_DIFF (Colon, LineBuffer) + 3; 313 NameColumn = ACPI_PTR_DIFF (Start, LineBuffer) + 1; 314 315 Length = ACPI_PTR_DIFF (End, Start); 316 317 TmpName = UtLocalCalloc (Length + 1); 318 ACPI_STRNCPY (TmpName, Start, Length); 319 Name = DtTrim (TmpName); 320 ACPI_FREE (TmpName); 321 322 Start = End = (Colon + 1); 323 while (*End) 324 { 325 /* Found left quotation, go to the right quotation and break */ 326 327 if (*End == '"') 328 { 329 End++; 330 331 /* Check for an explicit null string */ 332 333 if (*End == '"') 334 { 335 IsNullString = TRUE; 336 } 337 while (*End && (*End != '"')) 338 { 339 End++; 340 } 341 342 End++; 343 break; 344 } 345 346 /* 347 * Special "comment" fields at line end, ignore them. 348 * Note: normal slash-slash and slash-asterisk comments are 349 * stripped already by the DtGetNextLine parser. 350 * 351 * TBD: Perhaps DtGetNextLine should parse the following type 352 * of comments also. 353 */ 354 if (*End == '[') 355 { 356 End--; 357 break; 358 } 359 End++; 360 } 361 362 Length = ACPI_PTR_DIFF (End, Start); 363 TmpValue = UtLocalCalloc (Length + 1); 364 365 ACPI_STRNCPY (TmpValue, Start, Length); 366 Value = DtTrim (TmpValue); 367 ACPI_FREE (TmpValue); 368 369 /* Create a new field object only if we have a valid value field */ 370 371 if ((Value && *Value) || IsNullString) 372 { 373 Field = UtFieldCacheCalloc (); 374 Field->Name = Name; 375 Field->Value = Value; 376 Field->Line = Line; 377 Field->ByteOffset = Offset; 378 Field->NameColumn = NameColumn; 379 Field->Column = Column; 380 381 DtLinkField (Field); 382 } 383 /* Else -- Ignore this field, it has no valid data */ 384 385 return (AE_OK); 386 } 387 388 389 /****************************************************************************** 390 * 391 * FUNCTION: DtGetNextLine 392 * 393 * PARAMETERS: Handle - Open file handle for the source file 394 * 395 * RETURN: Filled line buffer and offset of start-of-line (ASL_EOF on EOF) 396 * 397 * DESCRIPTION: Get the next valid source line. Removes all comments. 398 * Ignores empty lines. 399 * 400 * Handles both slash-asterisk and slash-slash comments. 401 * Also, quoted strings, but no escapes within. 402 * 403 * Line is returned in Gbl_CurrentLineBuffer. 404 * Line number in original file is returned in Gbl_CurrentLineNumber. 405 * 406 *****************************************************************************/ 407 408 UINT32 409 DtGetNextLine ( 410 FILE *Handle) 411 { 412 BOOLEAN LineNotAllBlanks = FALSE; 413 UINT32 State = DT_NORMAL_TEXT; 414 UINT32 CurrentLineOffset; 415 UINT32 i; 416 int c; 417 418 419 for (i = 0; ;) 420 { 421 /* 422 * If line is too long, expand the line buffers. Also increases 423 * Gbl_LineBufferSize. 424 */ 425 if (i >= Gbl_LineBufferSize) 426 { 427 UtExpandLineBuffers (); 428 } 429 430 c = getc (Handle); 431 if (c == EOF) 432 { 433 switch (State) 434 { 435 case DT_START_QUOTED_STRING: 436 case DT_SLASH_ASTERISK_COMMENT: 437 438 AcpiOsPrintf ("**** EOF within comment/string %u\n", State); 439 break; 440 441 default: 442 443 break; 444 } 445 446 /* Standalone EOF is OK */ 447 448 if (i == 0) 449 { 450 return (ASL_EOF); 451 } 452 453 /* 454 * Received an EOF in the middle of a line. Terminate the 455 * line with a newline. The next call to this function will 456 * return a standalone EOF. Thus, the upper parsing software 457 * never has to deal with an EOF within a valid line (or 458 * the last line does not get tossed on the floor.) 459 */ 460 c = '\n'; 461 State = DT_NORMAL_TEXT; 462 } 463 464 switch (State) 465 { 466 case DT_NORMAL_TEXT: 467 468 /* Normal text, insert char into line buffer */ 469 470 Gbl_CurrentLineBuffer[i] = (char) c; 471 switch (c) 472 { 473 case '/': 474 475 State = DT_START_COMMENT; 476 break; 477 478 case '"': 479 480 State = DT_START_QUOTED_STRING; 481 LineNotAllBlanks = TRUE; 482 i++; 483 break; 484 485 case '\\': 486 /* 487 * The continuation char MUST be last char on this line. 488 * Otherwise, it will be assumed to be a valid ASL char. 489 */ 490 State = DT_MERGE_LINES; 491 break; 492 493 case '\n': 494 495 CurrentLineOffset = Gbl_NextLineOffset; 496 Gbl_NextLineOffset = (UINT32) ftell (Handle); 497 Gbl_CurrentLineNumber++; 498 499 /* 500 * Exit if line is complete. Ignore empty lines (only \n) 501 * or lines that contain nothing but blanks. 502 */ 503 if ((i != 0) && LineNotAllBlanks) 504 { 505 if ((i + 1) >= Gbl_LineBufferSize) 506 { 507 UtExpandLineBuffers (); 508 } 509 510 Gbl_CurrentLineBuffer[i+1] = 0; /* Terminate string */ 511 return (CurrentLineOffset); 512 } 513 514 /* Toss this line and start a new one */ 515 516 i = 0; 517 LineNotAllBlanks = FALSE; 518 break; 519 520 default: 521 522 if (c != ' ') 523 { 524 LineNotAllBlanks = TRUE; 525 } 526 527 i++; 528 break; 529 } 530 break; 531 532 case DT_START_QUOTED_STRING: 533 534 /* Insert raw chars until end of quoted string */ 535 536 Gbl_CurrentLineBuffer[i] = (char) c; 537 i++; 538 539 switch (c) 540 { 541 case '"': 542 543 State = DT_NORMAL_TEXT; 544 break; 545 546 case '\\': 547 548 State = DT_ESCAPE_SEQUENCE; 549 break; 550 551 case '\n': 552 553 AcpiOsPrintf ("ERROR at line %u: Unterminated quoted string\n", 554 Gbl_CurrentLineNumber++); 555 State = DT_NORMAL_TEXT; 556 break; 557 558 default: /* Get next character */ 559 560 break; 561 } 562 break; 563 564 case DT_ESCAPE_SEQUENCE: 565 566 /* Just copy the escaped character. TBD: sufficient for table compiler? */ 567 568 Gbl_CurrentLineBuffer[i] = (char) c; 569 i++; 570 State = DT_START_QUOTED_STRING; 571 break; 572 573 case DT_START_COMMENT: 574 575 /* Open comment if this character is an asterisk or slash */ 576 577 switch (c) 578 { 579 case '*': 580 581 State = DT_SLASH_ASTERISK_COMMENT; 582 break; 583 584 case '/': 585 586 State = DT_SLASH_SLASH_COMMENT; 587 break; 588 589 default: /* Not a comment */ 590 591 i++; /* Save the preceding slash */ 592 if (i >= Gbl_LineBufferSize) 593 { 594 UtExpandLineBuffers (); 595 } 596 597 Gbl_CurrentLineBuffer[i] = (char) c; 598 i++; 599 State = DT_NORMAL_TEXT; 600 break; 601 } 602 break; 603 604 case DT_SLASH_ASTERISK_COMMENT: 605 606 /* Ignore chars until an asterisk-slash is found */ 607 608 switch (c) 609 { 610 case '\n': 611 612 Gbl_NextLineOffset = (UINT32) ftell (Handle); 613 Gbl_CurrentLineNumber++; 614 break; 615 616 case '*': 617 618 State = DT_END_COMMENT; 619 break; 620 621 default: 622 623 break; 624 } 625 break; 626 627 case DT_SLASH_SLASH_COMMENT: 628 629 /* Ignore chars until end-of-line */ 630 631 if (c == '\n') 632 { 633 /* We will exit via the NORMAL_TEXT path */ 634 635 ungetc (c, Handle); 636 State = DT_NORMAL_TEXT; 637 } 638 break; 639 640 case DT_END_COMMENT: 641 642 /* End comment if this char is a slash */ 643 644 switch (c) 645 { 646 case '/': 647 648 State = DT_NORMAL_TEXT; 649 break; 650 651 case '\n': 652 653 CurrentLineOffset = Gbl_NextLineOffset; 654 Gbl_NextLineOffset = (UINT32) ftell (Handle); 655 Gbl_CurrentLineNumber++; 656 break; 657 658 case '*': 659 660 /* Consume all adjacent asterisks */ 661 break; 662 663 default: 664 665 State = DT_SLASH_ASTERISK_COMMENT; 666 break; 667 } 668 break; 669 670 case DT_MERGE_LINES: 671 672 if (c != '\n') 673 { 674 /* 675 * This is not a continuation backslash, it is a normal 676 * normal ASL backslash - for example: Scope(\_SB_) 677 */ 678 i++; /* Keep the backslash that is already in the buffer */ 679 680 ungetc (c, Handle); 681 State = DT_NORMAL_TEXT; 682 } 683 else 684 { 685 /* 686 * This is a continuation line -- a backlash followed 687 * immediately by a newline. Insert a space between the 688 * lines (overwrite the backslash) 689 */ 690 Gbl_CurrentLineBuffer[i] = ' '; 691 i++; 692 693 /* Ignore newline, this will merge the lines */ 694 695 CurrentLineOffset = Gbl_NextLineOffset; 696 Gbl_NextLineOffset = (UINT32) ftell (Handle); 697 Gbl_CurrentLineNumber++; 698 State = DT_NORMAL_TEXT; 699 } 700 break; 701 702 default: 703 704 DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, "Unknown input state"); 705 return (ASL_EOF); 706 } 707 } 708 } 709 710 711 /****************************************************************************** 712 * 713 * FUNCTION: DtScanFile 714 * 715 * PARAMETERS: Handle - Open file handle for the source file 716 * 717 * RETURN: Pointer to start of the constructed parse tree. 718 * 719 * DESCRIPTION: Scan source file, link all field names and values 720 * to the global parse tree: Gbl_FieldList 721 * 722 *****************************************************************************/ 723 724 DT_FIELD * 725 DtScanFile ( 726 FILE *Handle) 727 { 728 ACPI_STATUS Status; 729 UINT32 Offset; 730 731 732 ACPI_FUNCTION_NAME (DtScanFile); 733 734 735 /* Get the file size */ 736 737 Gbl_InputByteCount = CmGetFileSize (Handle); 738 if (Gbl_InputByteCount == ACPI_UINT32_MAX) 739 { 740 AslAbort (); 741 } 742 743 Gbl_CurrentLineNumber = 0; 744 Gbl_CurrentLineOffset = 0; 745 Gbl_NextLineOffset = 0; 746 747 /* Scan line-by-line */ 748 749 while ((Offset = DtGetNextLine (Handle)) != ASL_EOF) 750 { 751 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Line %2.2u/%4.4X - %s", 752 Gbl_CurrentLineNumber, Offset, Gbl_CurrentLineBuffer)); 753 754 Status = DtParseLine (Gbl_CurrentLineBuffer, Gbl_CurrentLineNumber, Offset); 755 if (Status == AE_NOT_FOUND) 756 { 757 break; 758 } 759 } 760 761 /* Dump the parse tree if debug enabled */ 762 763 DtDumpFieldList (Gbl_FieldList); 764 return (Gbl_FieldList); 765 } 766 767 768 /* 769 * Output functions 770 */ 771 772 /****************************************************************************** 773 * 774 * FUNCTION: DtWriteBinary 775 * 776 * PARAMETERS: DT_WALK_CALLBACK 777 * 778 * RETURN: Status 779 * 780 * DESCRIPTION: Write one subtable of a binary ACPI table 781 * 782 *****************************************************************************/ 783 784 static void 785 DtWriteBinary ( 786 DT_SUBTABLE *Subtable, 787 void *Context, 788 void *ReturnValue) 789 { 790 791 FlWriteFile (ASL_FILE_AML_OUTPUT, Subtable->Buffer, Subtable->Length); 792 } 793 794 795 /****************************************************************************** 796 * 797 * FUNCTION: DtOutputBinary 798 * 799 * PARAMETERS: 800 * 801 * RETURN: Status 802 * 803 * DESCRIPTION: Write entire binary ACPI table (result of compilation) 804 * 805 *****************************************************************************/ 806 807 void 808 DtOutputBinary ( 809 DT_SUBTABLE *RootTable) 810 { 811 812 if (!RootTable) 813 { 814 return; 815 } 816 817 /* Walk the entire parse tree, emitting the binary data */ 818 819 DtWalkTableTree (RootTable, DtWriteBinary, NULL, NULL); 820 821 Gbl_TableLength = CmGetFileSize (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle); 822 if (Gbl_TableLength == ACPI_UINT32_MAX) 823 { 824 AslAbort (); 825 } 826 } 827 828 829 /* 830 * Listing support 831 */ 832 833 /****************************************************************************** 834 * 835 * FUNCTION: DtDumpBuffer 836 * 837 * PARAMETERS: FileID - Where to write buffer data 838 * Buffer - Buffer to dump 839 * Offset - Offset in current table 840 * Length - Buffer Length 841 * 842 * RETURN: None 843 * 844 * DESCRIPTION: Another copy of DumpBuffer routine (unfortunately). 845 * 846 * TBD: merge dump buffer routines 847 * 848 *****************************************************************************/ 849 850 static void 851 DtDumpBuffer ( 852 UINT32 FileId, 853 UINT8 *Buffer, 854 UINT32 Offset, 855 UINT32 Length) 856 { 857 UINT32 i; 858 UINT32 j; 859 UINT8 BufChar; 860 861 862 FlPrintFile (FileId, "Output: [%3.3Xh %4.4d %3d] ", 863 Offset, Offset, Length); 864 865 i = 0; 866 while (i < Length) 867 { 868 if (i >= 16) 869 { 870 FlPrintFile (FileId, "%24s", ""); 871 } 872 873 /* Print 16 hex chars */ 874 875 for (j = 0; j < 16;) 876 { 877 if (i + j >= Length) 878 { 879 /* Dump fill spaces */ 880 881 FlPrintFile (FileId, " "); 882 j++; 883 continue; 884 } 885 886 FlPrintFile (FileId, "%02X ", Buffer[i+j]); 887 j++; 888 } 889 890 FlPrintFile (FileId, " "); 891 for (j = 0; j < 16; j++) 892 { 893 if (i + j >= Length) 894 { 895 FlPrintFile (FileId, "\n\n"); 896 return; 897 } 898 899 BufChar = Buffer[(ACPI_SIZE) i + j]; 900 if (ACPI_IS_PRINT (BufChar)) 901 { 902 FlPrintFile (FileId, "%c", BufChar); 903 } 904 else 905 { 906 FlPrintFile (FileId, "."); 907 } 908 } 909 910 /* Done with that line. */ 911 912 FlPrintFile (FileId, "\n"); 913 i += 16; 914 } 915 916 FlPrintFile (FileId, "\n\n"); 917 } 918 919 920 /****************************************************************************** 921 * 922 * FUNCTION: DtDumpFieldList 923 * 924 * PARAMETERS: Field - Root field 925 * 926 * RETURN: None 927 * 928 * DESCRIPTION: Dump the entire field list 929 * 930 *****************************************************************************/ 931 932 void 933 DtDumpFieldList ( 934 DT_FIELD *Field) 935 { 936 937 if (!Gbl_DebugFlag || !Field) 938 { 939 return; 940 } 941 942 DbgPrint (ASL_DEBUG_OUTPUT, "\nField List:\n" 943 "LineNo ByteOff NameCol Column TableOff " 944 "Flags %32s : %s\n\n", "Name", "Value"); 945 while (Field) 946 { 947 DbgPrint (ASL_DEBUG_OUTPUT, 948 "%.08X %.08X %.08X %.08X %.08X %.08X %32s : %s\n", 949 Field->Line, Field->ByteOffset, Field->NameColumn, 950 Field->Column, Field->TableOffset, Field->Flags, 951 Field->Name, Field->Value); 952 953 Field = Field->Next; 954 } 955 956 DbgPrint (ASL_DEBUG_OUTPUT, "\n\n"); 957 } 958 959 960 /****************************************************************************** 961 * 962 * FUNCTION: DtDumpSubtableInfo, DtDumpSubtableTree 963 * 964 * PARAMETERS: DT_WALK_CALLBACK 965 * 966 * RETURN: None 967 * 968 * DESCRIPTION: Info - dump a subtable tree entry with extra information. 969 * Tree - dump a subtable tree formatted by depth indentation. 970 * 971 *****************************************************************************/ 972 973 static void 974 DtDumpSubtableInfo ( 975 DT_SUBTABLE *Subtable, 976 void *Context, 977 void *ReturnValue) 978 { 979 980 DbgPrint (ASL_DEBUG_OUTPUT, 981 "[%.04X] %.08X %.08X %.08X %.08X %.08X %p %p %p\n", 982 Subtable->Depth, Subtable->Length, Subtable->TotalLength, 983 Subtable->SizeOfLengthField, Subtable->Flags, Subtable, 984 Subtable->Parent, Subtable->Child, Subtable->Peer); 985 } 986 987 static void 988 DtDumpSubtableTree ( 989 DT_SUBTABLE *Subtable, 990 void *Context, 991 void *ReturnValue) 992 { 993 994 DbgPrint (ASL_DEBUG_OUTPUT, 995 "[%.04X] %*s%08X (%.02X) - (%.02X)\n", 996 Subtable->Depth, (4 * Subtable->Depth), " ", 997 Subtable, Subtable->Length, Subtable->TotalLength); 998 } 999 1000 1001 /****************************************************************************** 1002 * 1003 * FUNCTION: DtDumpSubtableList 1004 * 1005 * PARAMETERS: None 1006 * 1007 * RETURN: None 1008 * 1009 * DESCRIPTION: Dump the raw list of subtables with information, and also 1010 * dump the subtable list in formatted tree format. Assists with 1011 * the development of new table code. 1012 * 1013 *****************************************************************************/ 1014 1015 void 1016 DtDumpSubtableList ( 1017 void) 1018 { 1019 1020 if (!Gbl_DebugFlag || !Gbl_RootTable) 1021 { 1022 return; 1023 } 1024 1025 DbgPrint (ASL_DEBUG_OUTPUT, 1026 "Subtable Info:\n" 1027 "Depth Length TotalLen LenSize Flags " 1028 "This Parent Child Peer\n\n"); 1029 DtWalkTableTree (Gbl_RootTable, DtDumpSubtableInfo, NULL, NULL); 1030 1031 DbgPrint (ASL_DEBUG_OUTPUT, 1032 "\nSubtable Tree: (Depth, Subtable, Length, TotalLength)\n\n"); 1033 DtWalkTableTree (Gbl_RootTable, DtDumpSubtableTree, NULL, NULL); 1034 1035 DbgPrint (ASL_DEBUG_OUTPUT, "\n"); 1036 } 1037 1038 1039 /****************************************************************************** 1040 * 1041 * FUNCTION: DtWriteFieldToListing 1042 * 1043 * PARAMETERS: Buffer - Contains the compiled data 1044 * Field - Field node for the input line 1045 * Length - Length of the output data 1046 * 1047 * RETURN: None 1048 * 1049 * DESCRIPTION: Write one field to the listing file (if listing is enabled). 1050 * 1051 *****************************************************************************/ 1052 1053 void 1054 DtWriteFieldToListing ( 1055 UINT8 *Buffer, 1056 DT_FIELD *Field, 1057 UINT32 Length) 1058 { 1059 UINT8 FileByte; 1060 1061 1062 if (!Gbl_ListingFlag || !Field) 1063 { 1064 return; 1065 } 1066 1067 /* Dump the original source line */ 1068 1069 FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Input: "); 1070 FlSeekFile (ASL_FILE_INPUT, Field->ByteOffset); 1071 1072 while (FlReadFile (ASL_FILE_INPUT, &FileByte, 1) == AE_OK) 1073 { 1074 FlWriteFile (ASL_FILE_LISTING_OUTPUT, &FileByte, 1); 1075 if (FileByte == '\n') 1076 { 1077 break; 1078 } 1079 } 1080 1081 /* Dump the line as parsed and represented internally */ 1082 1083 FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Parsed: %*s : %.64s", 1084 Field->Column-4, Field->Name, Field->Value); 1085 1086 if (strlen (Field->Value) > 64) 1087 { 1088 FlPrintFile (ASL_FILE_LISTING_OUTPUT, "...Additional data, length 0x%X\n", 1089 strlen (Field->Value)); 1090 } 1091 FlPrintFile (ASL_FILE_LISTING_OUTPUT, "\n"); 1092 1093 /* Dump the hex data that will be output for this field */ 1094 1095 DtDumpBuffer (ASL_FILE_LISTING_OUTPUT, Buffer, Field->TableOffset, Length); 1096 } 1097 1098 1099 /****************************************************************************** 1100 * 1101 * FUNCTION: DtWriteTableToListing 1102 * 1103 * PARAMETERS: None 1104 * 1105 * RETURN: None 1106 * 1107 * DESCRIPTION: Write the entire compiled table to the listing file 1108 * in hex format 1109 * 1110 *****************************************************************************/ 1111 1112 void 1113 DtWriteTableToListing ( 1114 void) 1115 { 1116 UINT8 *Buffer; 1117 1118 1119 if (!Gbl_ListingFlag) 1120 { 1121 return; 1122 } 1123 1124 /* Read the entire table from the output file */ 1125 1126 Buffer = UtLocalCalloc (Gbl_TableLength); 1127 FlSeekFile (ASL_FILE_AML_OUTPUT, 0); 1128 FlReadFile (ASL_FILE_AML_OUTPUT, Buffer, Gbl_TableLength); 1129 1130 /* Dump the raw table data */ 1131 1132 AcpiOsRedirectOutput (Gbl_Files[ASL_FILE_LISTING_OUTPUT].Handle); 1133 1134 AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n", 1135 ACPI_RAW_TABLE_DATA_HEADER, Gbl_TableLength, Gbl_TableLength); 1136 AcpiUtDumpBuffer (Buffer, Gbl_TableLength, DB_BYTE_DISPLAY, 0); 1137 1138 AcpiOsRedirectOutput (stdout); 1139 ACPI_FREE (Buffer); 1140 } 1141