1 /******************************************************************************
2 *
3 * Module Name: dtio.c - File I/O support for data table compiler
4 *
5 *****************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include "aslcompiler.h"
153 #include "acapps.h"
154
155 #define _COMPONENT DT_COMPILER
156 ACPI_MODULE_NAME ("dtio")
157
158
159 /* Local prototypes */
160
161 static char *
162 DtTrim (
163 char *String);
164
165 static void
166 DtLinkField (
167 DT_FIELD *Field);
168
169 static ACPI_STATUS
170 DtParseLine (
171 char *LineBuffer,
172 UINT32 Line,
173 UINT32 Offset);
174
175 static void
176 DtWriteBinary (
177 DT_SUBTABLE *Subtable,
178 void *Context,
179 void *ReturnValue);
180
181 static void
182 DtDumpBuffer (
183 UINT32 FileId,
184 UINT8 *Buffer,
185 UINT32 Offset,
186 UINT32 Length);
187
188 static void
189 DtDumpSubtableInfo (
190 DT_SUBTABLE *Subtable,
191 void *Context,
192 void *ReturnValue);
193
194 static void
195 DtDumpSubtableTree (
196 DT_SUBTABLE *Subtable,
197 void *Context,
198 void *ReturnValue);
199
200
201 /* States for DtGetNextLine */
202
203 #define DT_NORMAL_TEXT 0
204 #define DT_START_QUOTED_STRING 1
205 #define DT_START_COMMENT 2
206 #define DT_SLASH_ASTERISK_COMMENT 3
207 #define DT_SLASH_SLASH_COMMENT 4
208 #define DT_END_COMMENT 5
209 #define DT_MERGE_LINES 6
210 #define DT_ESCAPE_SEQUENCE 7
211
212 static UINT32 Gbl_NextLineOffset;
213
214
215 /******************************************************************************
216 *
217 * FUNCTION: DtTrim
218 *
219 * PARAMETERS: String - Current source code line to trim
220 *
221 * RETURN: Trimmed line. Must be freed by caller.
222 *
223 * DESCRIPTION: Trim left and right spaces
224 *
225 *****************************************************************************/
226
227 static char *
DtTrim(char * String)228 DtTrim (
229 char *String)
230 {
231 char *Start;
232 char *End;
233 char *ReturnString;
234 ACPI_SIZE Length;
235
236
237 /* Skip lines that start with a space */
238
239 if (!strcmp (String, " "))
240 {
241 ReturnString = UtLocalCacheCalloc (1);
242 return (ReturnString);
243 }
244
245 /* Setup pointers to start and end of input string */
246
247 Start = String;
248 End = String + strlen (String) - 1;
249
250 /* Find first non-whitespace character */
251
252 while ((Start <= End) && ((*Start == ' ') || (*Start == '\t')))
253 {
254 Start++;
255 }
256
257 /* Find last non-space character */
258
259 while (End >= Start)
260 {
261 if (*End == '\r' || *End == '\n')
262 {
263 End--;
264 continue;
265 }
266
267 if (*End != ' ')
268 {
269 break;
270 }
271
272 End--;
273 }
274
275 /* Remove any quotes around the string */
276
277 if (*Start == '\"')
278 {
279 Start++;
280 }
281 if (*End == '\"')
282 {
283 End--;
284 }
285
286 /* Create the trimmed return string */
287
288 Length = ACPI_PTR_DIFF (End, Start) + 1;
289 ReturnString = UtLocalCacheCalloc (Length + 1);
290 if (strlen (Start))
291 {
292 strncpy (ReturnString, Start, Length);
293 }
294
295 ReturnString[Length] = 0;
296 return (ReturnString);
297 }
298
299
300 /******************************************************************************
301 *
302 * FUNCTION: DtLinkField
303 *
304 * PARAMETERS: Field - New field object to link
305 *
306 * RETURN: None
307 *
308 * DESCRIPTION: Link one field name and value to the list
309 *
310 *****************************************************************************/
311
312 static void
DtLinkField(DT_FIELD * Field)313 DtLinkField (
314 DT_FIELD *Field)
315 {
316 DT_FIELD *Prev;
317 DT_FIELD *Next;
318
319
320 Prev = Next = Gbl_FieldList;
321
322 while (Next)
323 {
324 Prev = Next;
325 Next = Next->Next;
326 }
327
328 if (Prev)
329 {
330 Prev->Next = Field;
331 }
332 else
333 {
334 Gbl_FieldList = Field;
335 }
336 }
337
338
339 /******************************************************************************
340 *
341 * FUNCTION: DtParseLine
342 *
343 * PARAMETERS: LineBuffer - Current source code line
344 * Line - Current line number in the source
345 * Offset - Current byte offset of the line
346 *
347 * RETURN: Status
348 *
349 * DESCRIPTION: Parse one source line
350 *
351 *****************************************************************************/
352
353 static ACPI_STATUS
DtParseLine(char * LineBuffer,UINT32 Line,UINT32 Offset)354 DtParseLine (
355 char *LineBuffer,
356 UINT32 Line,
357 UINT32 Offset)
358 {
359 char *Start;
360 char *End;
361 char *TmpName;
362 char *TmpValue;
363 char *Name;
364 char *Value;
365 char *Colon;
366 UINT32 Length;
367 DT_FIELD *Field;
368 UINT32 Column;
369 UINT32 NameColumn;
370 BOOLEAN IsNullString = FALSE;
371
372
373 if (!LineBuffer)
374 {
375 return (AE_OK);
376 }
377
378 /* All lines after "Raw Table Data" are ingored */
379
380 if (strstr (LineBuffer, ACPI_RAW_TABLE_DATA_HEADER))
381 {
382 return (AE_NOT_FOUND);
383 }
384
385 Colon = strchr (LineBuffer, ':');
386 if (!Colon)
387 {
388 return (AE_OK);
389 }
390
391 Start = LineBuffer;
392 End = Colon;
393
394 while (Start < Colon)
395 {
396 if (*Start == '[')
397 {
398 /* Found left bracket, go to the right bracket */
399
400 while (Start < Colon && *Start != ']')
401 {
402 Start++;
403 }
404 }
405 else if (*Start != ' ')
406 {
407 break;
408 }
409
410 Start++;
411 }
412
413 /*
414 * There are two column values. One for the field name,
415 * and one for the field value.
416 */
417 Column = ACPI_PTR_DIFF (Colon, LineBuffer) + 3;
418 NameColumn = ACPI_PTR_DIFF (Start, LineBuffer) + 1;
419
420 Length = ACPI_PTR_DIFF (End, Start);
421
422 TmpName = UtLocalCalloc (Length + 1);
423 strncpy (TmpName, Start, Length);
424 Name = DtTrim (TmpName);
425 ACPI_FREE (TmpName);
426
427 Start = End = (Colon + 1);
428 while (*End)
429 {
430 /* Found left quotation, go to the right quotation and break */
431
432 if (*End == '"')
433 {
434 End++;
435
436 /* Check for an explicit null string */
437
438 if (*End == '"')
439 {
440 IsNullString = TRUE;
441 }
442 while (*End && (*End != '"'))
443 {
444 End++;
445 }
446
447 End++;
448 break;
449 }
450
451 /*
452 * Special "comment" fields at line end, ignore them.
453 * Note: normal slash-slash and slash-asterisk comments are
454 * stripped already by the DtGetNextLine parser.
455 *
456 * TBD: Perhaps DtGetNextLine should parse the following type
457 * of comments also.
458 */
459 if (*End == '[')
460 {
461 End--;
462 break;
463 }
464
465 End++;
466 }
467
468 Length = ACPI_PTR_DIFF (End, Start);
469 TmpValue = UtLocalCalloc (Length + 1);
470
471 strncpy (TmpValue, Start, Length);
472 Value = DtTrim (TmpValue);
473 ACPI_FREE (TmpValue);
474
475 /* Create a new field object only if we have a valid value field */
476
477 if ((Value && *Value) || IsNullString)
478 {
479 Field = UtFieldCacheCalloc ();
480 Field->Name = Name;
481 Field->Value = Value;
482 Field->Line = Line;
483 Field->ByteOffset = Offset;
484 Field->NameColumn = NameColumn;
485 Field->Column = Column;
486 Field->StringLength = Length;
487
488 DtLinkField (Field);
489 }
490 /* Else -- Ignore this field, it has no valid data */
491
492 return (AE_OK);
493 }
494
495
496 /******************************************************************************
497 *
498 * FUNCTION: DtGetNextLine
499 *
500 * PARAMETERS: Handle - Open file handle for the source file
501 *
502 * RETURN: Filled line buffer and offset of start-of-line (ASL_EOF on EOF)
503 *
504 * DESCRIPTION: Get the next valid source line. Removes all comments.
505 * Ignores empty lines.
506 *
507 * Handles both slash-asterisk and slash-slash comments.
508 * Also, quoted strings, but no escapes within.
509 *
510 * Line is returned in Gbl_CurrentLineBuffer.
511 * Line number in original file is returned in Gbl_CurrentLineNumber.
512 *
513 *****************************************************************************/
514
515 UINT32
DtGetNextLine(FILE * Handle,UINT32 Flags)516 DtGetNextLine (
517 FILE *Handle,
518 UINT32 Flags)
519 {
520 BOOLEAN LineNotAllBlanks = FALSE;
521 UINT32 State = DT_NORMAL_TEXT;
522 UINT32 CurrentLineOffset;
523 UINT32 i;
524 int c;
525
526
527 memset (Gbl_CurrentLineBuffer, 0, Gbl_LineBufferSize);
528 for (i = 0; ;)
529 {
530 /*
531 * If line is too long, expand the line buffers. Also increases
532 * Gbl_LineBufferSize.
533 */
534 if (i >= Gbl_LineBufferSize)
535 {
536 UtExpandLineBuffers ();
537 }
538
539 c = getc (Handle);
540 if (c == EOF)
541 {
542 switch (State)
543 {
544 case DT_START_QUOTED_STRING:
545 case DT_SLASH_ASTERISK_COMMENT:
546
547 AcpiOsPrintf ("**** EOF within comment/string %u\n", State);
548 break;
549
550 default:
551
552 break;
553 }
554
555 /* Standalone EOF is OK */
556
557 if (i == 0)
558 {
559 return (ASL_EOF);
560 }
561
562 /*
563 * Received an EOF in the middle of a line. Terminate the
564 * line with a newline. The next call to this function will
565 * return a standalone EOF. Thus, the upper parsing software
566 * never has to deal with an EOF within a valid line (or
567 * the last line does not get tossed on the floor.)
568 */
569 c = '\n';
570 State = DT_NORMAL_TEXT;
571 }
572
573 switch (State)
574 {
575 case DT_NORMAL_TEXT:
576
577 /* Normal text, insert char into line buffer */
578
579 Gbl_CurrentLineBuffer[i] = (char) c;
580 switch (c)
581 {
582 case '/':
583
584 State = DT_START_COMMENT;
585 break;
586
587 case '"':
588
589 State = DT_START_QUOTED_STRING;
590 LineNotAllBlanks = TRUE;
591 i++;
592 break;
593
594 case '\\':
595 /*
596 * The continuation char MUST be last char on this line.
597 * Otherwise, it will be assumed to be a valid ASL char.
598 */
599 State = DT_MERGE_LINES;
600 break;
601
602 case '\n':
603
604 CurrentLineOffset = Gbl_NextLineOffset;
605 Gbl_NextLineOffset = (UINT32) ftell (Handle);
606 Gbl_CurrentLineNumber++;
607
608 /*
609 * Exit if line is complete. Ignore empty lines (only \n)
610 * or lines that contain nothing but blanks.
611 */
612 if ((i != 0) && LineNotAllBlanks)
613 {
614 if ((i + 1) >= Gbl_LineBufferSize)
615 {
616 UtExpandLineBuffers ();
617 }
618
619 Gbl_CurrentLineBuffer[i+1] = 0; /* Terminate string */
620 return (CurrentLineOffset);
621 }
622
623 /* Toss this line and start a new one */
624
625 i = 0;
626 LineNotAllBlanks = FALSE;
627 break;
628
629 default:
630
631 if (c != ' ')
632 {
633 LineNotAllBlanks = TRUE;
634 }
635
636 i++;
637 break;
638 }
639 break;
640
641 case DT_START_QUOTED_STRING:
642
643 /* Insert raw chars until end of quoted string */
644
645 Gbl_CurrentLineBuffer[i] = (char) c;
646 i++;
647
648 switch (c)
649 {
650 case '"':
651
652 State = DT_NORMAL_TEXT;
653 break;
654
655 case '\\':
656
657 State = DT_ESCAPE_SEQUENCE;
658 break;
659
660 case '\n':
661
662 if (!(Flags & DT_ALLOW_MULTILINE_QUOTES))
663 {
664 AcpiOsPrintf (
665 "ERROR at line %u: Unterminated quoted string\n",
666 Gbl_CurrentLineNumber++);
667 State = DT_NORMAL_TEXT;
668 }
669 break;
670
671 default: /* Get next character */
672
673 break;
674 }
675 break;
676
677 case DT_ESCAPE_SEQUENCE:
678
679 /* Just copy the escaped character. TBD: sufficient for table compiler? */
680
681 Gbl_CurrentLineBuffer[i] = (char) c;
682 i++;
683 State = DT_START_QUOTED_STRING;
684 break;
685
686 case DT_START_COMMENT:
687
688 /* Open comment if this character is an asterisk or slash */
689
690 switch (c)
691 {
692 case '*':
693
694 State = DT_SLASH_ASTERISK_COMMENT;
695 break;
696
697 case '/':
698
699 State = DT_SLASH_SLASH_COMMENT;
700 break;
701
702 default: /* Not a comment */
703
704 i++; /* Save the preceding slash */
705 if (i >= Gbl_LineBufferSize)
706 {
707 UtExpandLineBuffers ();
708 }
709
710 Gbl_CurrentLineBuffer[i] = (char) c;
711 i++;
712 State = DT_NORMAL_TEXT;
713 break;
714 }
715 break;
716
717 case DT_SLASH_ASTERISK_COMMENT:
718
719 /* Ignore chars until an asterisk-slash is found */
720
721 switch (c)
722 {
723 case '\n':
724
725 Gbl_NextLineOffset = (UINT32) ftell (Handle);
726 Gbl_CurrentLineNumber++;
727 break;
728
729 case '*':
730
731 State = DT_END_COMMENT;
732 break;
733
734 default:
735
736 break;
737 }
738 break;
739
740 case DT_SLASH_SLASH_COMMENT:
741
742 /* Ignore chars until end-of-line */
743
744 if (c == '\n')
745 {
746 /* We will exit via the NORMAL_TEXT path */
747
748 ungetc (c, Handle);
749 State = DT_NORMAL_TEXT;
750 }
751 break;
752
753 case DT_END_COMMENT:
754
755 /* End comment if this char is a slash */
756
757 switch (c)
758 {
759 case '/':
760
761 State = DT_NORMAL_TEXT;
762 break;
763
764 case '\n':
765
766 CurrentLineOffset = Gbl_NextLineOffset;
767 Gbl_NextLineOffset = (UINT32) ftell (Handle);
768 Gbl_CurrentLineNumber++;
769 break;
770
771 case '*':
772
773 /* Consume all adjacent asterisks */
774 break;
775
776 default:
777
778 State = DT_SLASH_ASTERISK_COMMENT;
779 break;
780 }
781 break;
782
783 case DT_MERGE_LINES:
784
785 if (c != '\n')
786 {
787 /*
788 * This is not a continuation backslash, it is a normal
789 * normal ASL backslash - for example: Scope(\_SB_)
790 */
791 i++; /* Keep the backslash that is already in the buffer */
792
793 ungetc (c, Handle);
794 State = DT_NORMAL_TEXT;
795 }
796 else
797 {
798 /*
799 * This is a continuation line -- a backlash followed
800 * immediately by a newline. Insert a space between the
801 * lines (overwrite the backslash)
802 */
803 Gbl_CurrentLineBuffer[i] = ' ';
804 i++;
805
806 /* Ignore newline, this will merge the lines */
807
808 CurrentLineOffset = Gbl_NextLineOffset;
809 Gbl_NextLineOffset = (UINT32) ftell (Handle);
810 Gbl_CurrentLineNumber++;
811 State = DT_NORMAL_TEXT;
812 }
813 break;
814
815 default:
816
817 DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, "Unknown input state");
818 return (ASL_EOF);
819 }
820 }
821 }
822
823
824 /******************************************************************************
825 *
826 * FUNCTION: DtScanFile
827 *
828 * PARAMETERS: Handle - Open file handle for the source file
829 *
830 * RETURN: Pointer to start of the constructed parse tree.
831 *
832 * DESCRIPTION: Scan source file, link all field names and values
833 * to the global parse tree: Gbl_FieldList
834 *
835 *****************************************************************************/
836
837 DT_FIELD *
DtScanFile(FILE * Handle)838 DtScanFile (
839 FILE *Handle)
840 {
841 ACPI_STATUS Status;
842 UINT32 Offset;
843
844
845 ACPI_FUNCTION_NAME (DtScanFile);
846
847
848 /* Get the file size */
849
850 Gbl_InputByteCount = CmGetFileSize (Handle);
851 if (Gbl_InputByteCount == ACPI_UINT32_MAX)
852 {
853 AslAbort ();
854 }
855
856 Gbl_CurrentLineNumber = 0;
857 Gbl_CurrentLineOffset = 0;
858 Gbl_NextLineOffset = 0;
859
860 /* Scan line-by-line */
861
862 while ((Offset = DtGetNextLine (Handle, 0)) != ASL_EOF)
863 {
864 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Line %2.2u/%4.4X - %s",
865 Gbl_CurrentLineNumber, Offset, Gbl_CurrentLineBuffer));
866
867 Status = DtParseLine (Gbl_CurrentLineBuffer,
868 Gbl_CurrentLineNumber, Offset);
869 if (Status == AE_NOT_FOUND)
870 {
871 break;
872 }
873 }
874
875 /* Dump the parse tree if debug enabled */
876
877 DtDumpFieldList (Gbl_FieldList);
878 return (Gbl_FieldList);
879 }
880
881
882 /*
883 * Output functions
884 */
885
886 /******************************************************************************
887 *
888 * FUNCTION: DtWriteBinary
889 *
890 * PARAMETERS: DT_WALK_CALLBACK
891 *
892 * RETURN: Status
893 *
894 * DESCRIPTION: Write one subtable of a binary ACPI table
895 *
896 *****************************************************************************/
897
898 static void
DtWriteBinary(DT_SUBTABLE * Subtable,void * Context,void * ReturnValue)899 DtWriteBinary (
900 DT_SUBTABLE *Subtable,
901 void *Context,
902 void *ReturnValue)
903 {
904
905 FlWriteFile (ASL_FILE_AML_OUTPUT, Subtable->Buffer, Subtable->Length);
906 }
907
908
909 /******************************************************************************
910 *
911 * FUNCTION: DtOutputBinary
912 *
913 * PARAMETERS:
914 *
915 * RETURN: Status
916 *
917 * DESCRIPTION: Write entire binary ACPI table (result of compilation)
918 *
919 *****************************************************************************/
920
921 void
DtOutputBinary(DT_SUBTABLE * RootTable)922 DtOutputBinary (
923 DT_SUBTABLE *RootTable)
924 {
925
926 if (!RootTable)
927 {
928 return;
929 }
930
931 /* Walk the entire parse tree, emitting the binary data */
932
933 DtWalkTableTree (RootTable, DtWriteBinary, NULL, NULL);
934
935 Gbl_TableLength = CmGetFileSize (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
936 if (Gbl_TableLength == ACPI_UINT32_MAX)
937 {
938 AslAbort ();
939 }
940 }
941
942
943 /*
944 * Listing support
945 */
946
947 /******************************************************************************
948 *
949 * FUNCTION: DtDumpBuffer
950 *
951 * PARAMETERS: FileID - Where to write buffer data
952 * Buffer - Buffer to dump
953 * Offset - Offset in current table
954 * Length - Buffer Length
955 *
956 * RETURN: None
957 *
958 * DESCRIPTION: Another copy of DumpBuffer routine (unfortunately).
959 *
960 * TBD: merge dump buffer routines
961 *
962 *****************************************************************************/
963
964 static void
DtDumpBuffer(UINT32 FileId,UINT8 * Buffer,UINT32 Offset,UINT32 Length)965 DtDumpBuffer (
966 UINT32 FileId,
967 UINT8 *Buffer,
968 UINT32 Offset,
969 UINT32 Length)
970 {
971 UINT32 i;
972 UINT32 j;
973 UINT8 BufChar;
974
975
976 FlPrintFile (FileId, "Output: [%3.3Xh %4.4d %3d] ",
977 Offset, Offset, Length);
978
979 i = 0;
980 while (i < Length)
981 {
982 if (i >= 16)
983 {
984 FlPrintFile (FileId, "%24s", "");
985 }
986
987 /* Print 16 hex chars */
988
989 for (j = 0; j < 16;)
990 {
991 if (i + j >= Length)
992 {
993 /* Dump fill spaces */
994
995 FlPrintFile (FileId, " ");
996 j++;
997 continue;
998 }
999
1000 FlPrintFile (FileId, "%02X ", Buffer[i+j]);
1001 j++;
1002 }
1003
1004 FlPrintFile (FileId, " ");
1005 for (j = 0; j < 16; j++)
1006 {
1007 if (i + j >= Length)
1008 {
1009 FlPrintFile (FileId, "\n\n");
1010 return;
1011 }
1012
1013 BufChar = Buffer[(ACPI_SIZE) i + j];
1014 if (isprint (BufChar))
1015 {
1016 FlPrintFile (FileId, "%c", BufChar);
1017 }
1018 else
1019 {
1020 FlPrintFile (FileId, ".");
1021 }
1022 }
1023
1024 /* Done with that line. */
1025
1026 FlPrintFile (FileId, "\n");
1027 i += 16;
1028 }
1029
1030 FlPrintFile (FileId, "\n\n");
1031 }
1032
1033
1034 /******************************************************************************
1035 *
1036 * FUNCTION: DtDumpFieldList
1037 *
1038 * PARAMETERS: Field - Root field
1039 *
1040 * RETURN: None
1041 *
1042 * DESCRIPTION: Dump the entire field list
1043 *
1044 *****************************************************************************/
1045
1046 void
DtDumpFieldList(DT_FIELD * Field)1047 DtDumpFieldList (
1048 DT_FIELD *Field)
1049 {
1050
1051 if (!Gbl_DebugFlag || !Field)
1052 {
1053 return;
1054 }
1055
1056 DbgPrint (ASL_DEBUG_OUTPUT, "\nField List:\n"
1057 "LineNo ByteOff NameCol Column TableOff "
1058 "Flags %32s : %s\n\n", "Name", "Value");
1059
1060 while (Field)
1061 {
1062 DbgPrint (ASL_DEBUG_OUTPUT,
1063 "%.08X %.08X %.08X %.08X %.08X %2.2X %32s : %s\n",
1064 Field->Line, Field->ByteOffset, Field->NameColumn,
1065 Field->Column, Field->TableOffset, Field->Flags,
1066 Field->Name, Field->Value);
1067
1068 Field = Field->Next;
1069 }
1070
1071 DbgPrint (ASL_DEBUG_OUTPUT, "\n\n");
1072 }
1073
1074
1075 /******************************************************************************
1076 *
1077 * FUNCTION: DtDumpSubtableInfo, DtDumpSubtableTree
1078 *
1079 * PARAMETERS: DT_WALK_CALLBACK
1080 *
1081 * RETURN: None
1082 *
1083 * DESCRIPTION: Info - dump a subtable tree entry with extra information.
1084 * Tree - dump a subtable tree formatted by depth indentation.
1085 *
1086 *****************************************************************************/
1087
1088 static void
DtDumpSubtableInfo(DT_SUBTABLE * Subtable,void * Context,void * ReturnValue)1089 DtDumpSubtableInfo (
1090 DT_SUBTABLE *Subtable,
1091 void *Context,
1092 void *ReturnValue)
1093 {
1094
1095 DbgPrint (ASL_DEBUG_OUTPUT,
1096 "[%.04X] %24s %.08X %.08X %.08X %.08X %.08X %p %p %p\n",
1097 Subtable->Depth, Subtable->Name, Subtable->Length, Subtable->TotalLength,
1098 Subtable->SizeOfLengthField, Subtable->Flags, Subtable,
1099 Subtable->Parent, Subtable->Child, Subtable->Peer);
1100 }
1101
1102 static void
DtDumpSubtableTree(DT_SUBTABLE * Subtable,void * Context,void * ReturnValue)1103 DtDumpSubtableTree (
1104 DT_SUBTABLE *Subtable,
1105 void *Context,
1106 void *ReturnValue)
1107 {
1108
1109 DbgPrint (ASL_DEBUG_OUTPUT,
1110 "[%.04X] %24s %*s%08X (%.02X) - (%.02X)\n",
1111 Subtable->Depth, Subtable->Name, (4 * Subtable->Depth), " ",
1112 Subtable, Subtable->Length, Subtable->TotalLength);
1113 }
1114
1115
1116 /******************************************************************************
1117 *
1118 * FUNCTION: DtDumpSubtableList
1119 *
1120 * PARAMETERS: None
1121 *
1122 * RETURN: None
1123 *
1124 * DESCRIPTION: Dump the raw list of subtables with information, and also
1125 * dump the subtable list in formatted tree format. Assists with
1126 * the development of new table code.
1127 *
1128 *****************************************************************************/
1129
1130 void
DtDumpSubtableList(void)1131 DtDumpSubtableList (
1132 void)
1133 {
1134
1135 if (!Gbl_DebugFlag || !Gbl_RootTable)
1136 {
1137 return;
1138 }
1139
1140 DbgPrint (ASL_DEBUG_OUTPUT,
1141 "Subtable Info:\n"
1142 "Depth Name Length TotalLen LenSize Flags "
1143 "This Parent Child Peer\n\n");
1144 DtWalkTableTree (Gbl_RootTable, DtDumpSubtableInfo, NULL, NULL);
1145
1146 DbgPrint (ASL_DEBUG_OUTPUT,
1147 "\nSubtable Tree: (Depth, Name, Subtable, Length, TotalLength)\n\n");
1148 DtWalkTableTree (Gbl_RootTable, DtDumpSubtableTree, NULL, NULL);
1149
1150 DbgPrint (ASL_DEBUG_OUTPUT, "\n");
1151 }
1152
1153
1154 /******************************************************************************
1155 *
1156 * FUNCTION: DtWriteFieldToListing
1157 *
1158 * PARAMETERS: Buffer - Contains the compiled data
1159 * Field - Field node for the input line
1160 * Length - Length of the output data
1161 *
1162 * RETURN: None
1163 *
1164 * DESCRIPTION: Write one field to the listing file (if listing is enabled).
1165 *
1166 *****************************************************************************/
1167
1168 void
DtWriteFieldToListing(UINT8 * Buffer,DT_FIELD * Field,UINT32 Length)1169 DtWriteFieldToListing (
1170 UINT8 *Buffer,
1171 DT_FIELD *Field,
1172 UINT32 Length)
1173 {
1174 UINT8 FileByte;
1175
1176
1177 if (!Gbl_ListingFlag || !Field)
1178 {
1179 return;
1180 }
1181
1182 /* Dump the original source line */
1183
1184 FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Input: ");
1185 FlSeekFile (ASL_FILE_INPUT, Field->ByteOffset);
1186
1187 while (FlReadFile (ASL_FILE_INPUT, &FileByte, 1) == AE_OK)
1188 {
1189 FlWriteFile (ASL_FILE_LISTING_OUTPUT, &FileByte, 1);
1190 if (FileByte == '\n')
1191 {
1192 break;
1193 }
1194 }
1195
1196 /* Dump the line as parsed and represented internally */
1197
1198 FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Parsed: %*s : %.64s",
1199 Field->Column-4, Field->Name, Field->Value);
1200
1201 if (strlen (Field->Value) > 64)
1202 {
1203 FlPrintFile (ASL_FILE_LISTING_OUTPUT, "...Additional data, length 0x%X\n",
1204 strlen (Field->Value));
1205 }
1206
1207 FlPrintFile (ASL_FILE_LISTING_OUTPUT, "\n");
1208
1209 /* Dump the hex data that will be output for this field */
1210
1211 DtDumpBuffer (ASL_FILE_LISTING_OUTPUT, Buffer, Field->TableOffset, Length);
1212 }
1213
1214
1215 /******************************************************************************
1216 *
1217 * FUNCTION: DtWriteTableToListing
1218 *
1219 * PARAMETERS: None
1220 *
1221 * RETURN: None
1222 *
1223 * DESCRIPTION: Write the entire compiled table to the listing file
1224 * in hex format
1225 *
1226 *****************************************************************************/
1227
1228 void
DtWriteTableToListing(void)1229 DtWriteTableToListing (
1230 void)
1231 {
1232 UINT8 *Buffer;
1233
1234
1235 if (!Gbl_ListingFlag)
1236 {
1237 return;
1238 }
1239
1240 /* Read the entire table from the output file */
1241
1242 Buffer = UtLocalCalloc (Gbl_TableLength);
1243 FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
1244 FlReadFile (ASL_FILE_AML_OUTPUT, Buffer, Gbl_TableLength);
1245
1246 /* Dump the raw table data */
1247
1248 AcpiOsRedirectOutput (Gbl_Files[ASL_FILE_LISTING_OUTPUT].Handle);
1249
1250 AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n",
1251 ACPI_RAW_TABLE_DATA_HEADER, Gbl_TableLength, Gbl_TableLength);
1252 AcpiUtDumpBuffer (Buffer, Gbl_TableLength, DB_BYTE_DISPLAY, 0);
1253
1254 AcpiOsRedirectOutput (stdout);
1255 ACPI_FREE (Buffer);
1256 }
1257