1 /******************************************************************************
2 *
3 * Module Name: aslsupport.l - Flex/lex scanner C support routines.
4 * NOTE: Included into aslcompile.l, not compiled by itself.
5 *
6 *****************************************************************************/
7
8 /*
9 * Copyright (C) 2000 - 2013, Intel Corp.
10 * All rights reserved.
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions, and the following disclaimer,
17 * without modification.
18 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
19 * substantially similar to the "NO WARRANTY" disclaimer below
20 * ("Disclaimer") and any redistribution must be conditioned upon
21 * including a substantially similar Disclaimer requirement for further
22 * binary redistribution.
23 * 3. Neither the names of the above-listed copyright holders nor the names
24 * of any contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * Alternatively, this software may be distributed under the terms of the
28 * GNU General Public License ("GPL") version 2 as published by the Free
29 * Software Foundation.
30 *
31 * NO WARRANTY
32 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
35 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
36 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
41 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
42 * POSSIBILITY OF SUCH DAMAGES.
43 */
44
45
46 /* Configuration */
47
48 #define ASL_SPACES_PER_TAB 4
49
50 #define ASL_NORMAL_CHAR 0
51 #define ASL_ESCAPE_SEQUENCE 1
52 #define ASL_OCTAL_CONSTANT 2
53 #define ASL_HEX_CONSTANT 3
54
55
56 /* File node - used for "Include" operator file stack */
57
58 typedef struct asl_file_node
59 {
60 FILE *File;
61 UINT32 CurrentLineNumber;
62 YY_BUFFER_STATE State;
63 char *Filename;
64 struct asl_file_node *Next;
65
66 } ASL_FILE_NODE;
67
68 /* File stack for the "Include" operator (NOT #include operator) */
69
70 ASL_FILE_NODE *Gbl_IncludeFileStack = NULL;
71
72
73 /*******************************************************************************
74 *
75 * FUNCTION: AslDoLineDirective
76 *
77 * PARAMETERS: None. Uses input() to access current source code line
78 *
79 * RETURN: Updates global line number and filename
80 *
81 * DESCRIPTION: Handle #line directives emitted by the preprocessor.
82 *
83 * The #line directive is emitted by the preprocesser, and is used to
84 * pass through line numbers from the original source code file to the
85 * preprocessor output file (.i). This allows any compiler-generated
86 * error messages to be displayed with the correct line number.
87 *
88 ******************************************************************************/
89
90 static void
91 AslDoLineDirective (
92 void)
93 {
94 int c;
95 char *Token;
96 UINT32 LineNumber;
97 char *Filename;
98 UINT32 i;
99
100
101 /* Eat the entire line that contains the #line directive */
102
103 Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
104
105 while ((c = input()) != '\n' && c != EOF)
106 {
107 *Gbl_LineBufPtr = c;
108 Gbl_LineBufPtr++;
109 }
110 *Gbl_LineBufPtr = 0;
111
112 /* First argument is the actual line number */
113
114 Token = strtok (Gbl_CurrentLineBuffer, " ");
115 if (!Token)
116 {
117 goto ResetAndExit;
118 }
119
120 /* First argument is the line number */
121
122 LineNumber = (UINT32) UtDoConstant (Token);
123
124 /* Emit the appropriate number of newlines */
125
126 Gbl_CurrentColumn = 0;
127 if (LineNumber > Gbl_CurrentLineNumber)
128 {
129 for (i = 0; i < (LineNumber - Gbl_CurrentLineNumber); i++)
130 {
131 FlWriteFile (ASL_FILE_SOURCE_OUTPUT, "\n", 1);
132 Gbl_CurrentColumn++;
133 }
134 }
135
136 FlSetLineNumber (LineNumber);
137
138 /* Second argument is the optional filename (in double quotes) */
139
140 Token = strtok (NULL, " \"");
141 if (Token)
142 {
143 Filename = ACPI_ALLOCATE_ZEROED (strlen (Token) + 1);
144 strcpy (Filename, Token);
145 FlSetFilename (Filename);
146 }
147
148 /* Third argument is not supported at this time */
149
150 ResetAndExit:
151
152 /* Reset globals for a new line */
153
154 Gbl_CurrentLineOffset += Gbl_CurrentColumn;
155 Gbl_CurrentColumn = 0;
156 Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
157 }
158
159
160 /*******************************************************************************
161 *
162 * FUNCTION: AslPopInputFileStack
163 *
164 * PARAMETERS: None
165 *
166 * RETURN: 0 if a node was popped, -1 otherwise
167 *
168 * DESCRIPTION: Pop the top of the input file stack and point the parser to
169 * the saved parse buffer contained in the fnode. Also, set the
170 * global line counters to the saved values. This function is
171 * called when an include file reaches EOF.
172 *
173 ******************************************************************************/
174
175 int
176 AslPopInputFileStack (
177 void)
178 {
179 ASL_FILE_NODE *Fnode;
180
181
182 Fnode = Gbl_IncludeFileStack;
183 DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
184
185 if (!Fnode)
186 {
187 return (-1);
188 }
189
190 /* Close the current include file */
191
192 fclose (yyin);
193
194 /* Update the top-of-stack */
195
196 Gbl_IncludeFileStack = Fnode->Next;
197
198 /* Reset global line counter and filename */
199
200 Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
201 Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
202
203 /* Point the parser to the popped file */
204
205 yy_delete_buffer (YY_CURRENT_BUFFER);
206 yy_switch_to_buffer (Fnode->State);
207
208 /* All done with this node */
209
210 ACPI_FREE (Fnode);
211 return (0);
212 }
213
214
215 /*******************************************************************************
216 *
217 * FUNCTION: AslPushInputFileStack
218 *
219 * PARAMETERS: InputFile - Open file pointer
220 * Filename - Name of the file
221 *
222 * RETURN: None
223 *
224 * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
225 * to this file. Called when an include file is successfully
226 * opened.
227 *
228 ******************************************************************************/
229
230 void
231 AslPushInputFileStack (
232 FILE *InputFile,
233 char *Filename)
234 {
235 ASL_FILE_NODE *Fnode;
236 YY_BUFFER_STATE State;
237
238
239 /* Save the current state in an Fnode */
240
241 Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
242
243 Fnode->File = yyin;
244 Fnode->Next = Gbl_IncludeFileStack;
245 Fnode->State = YY_CURRENT_BUFFER;
246 Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
247 Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
248
249 /* Push it on the stack */
250
251 Gbl_IncludeFileStack = Fnode;
252
253 /* Point the parser to this file */
254
255 State = yy_create_buffer (InputFile, YY_BUF_SIZE);
256 yy_switch_to_buffer (State);
257
258 DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
259
260 /* Reset the global line count and filename */
261
262 Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
263 Gbl_CurrentLineNumber = 1;
264 yyin = InputFile;
265 }
266
267
268 /*******************************************************************************
269 *
270 * FUNCTION: AslResetCurrentLineBuffer
271 *
272 * PARAMETERS: None
273 *
274 * RETURN: None
275 *
276 * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
277 *
278 ******************************************************************************/
279
280 void
281 AslResetCurrentLineBuffer (
282 void)
283 {
284
285 if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
286 {
287 FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
288 Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
289 }
290
291 Gbl_CurrentLineOffset += Gbl_CurrentColumn;
292 Gbl_CurrentColumn = 0;
293
294 Gbl_CurrentLineNumber++;
295 Gbl_LogicalLineNumber++;
296 Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
297 }
298
299
300 /*******************************************************************************
301 *
302 * FUNCTION: AslInsertLineBuffer
303 *
304 * PARAMETERS: SourceChar - One char from the input ASL source file
305 *
306 * RETURN: None
307 *
308 * DESCRIPTION: Put one character of the source file into the temp line buffer
309 *
310 ******************************************************************************/
311
312 void
313 AslInsertLineBuffer (
314 int SourceChar)
315 {
316 UINT32 i;
317 UINT32 Count = 1;
318
319
320 if (SourceChar == EOF)
321 {
322 return;
323 }
324
325 Gbl_InputByteCount++;
326
327 /* Handle tabs. Convert to spaces */
328
329 if (SourceChar == '\t')
330 {
331 SourceChar = ' ';
332 Count = ASL_SPACES_PER_TAB -
333 (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
334 }
335
336 for (i = 0; i < Count; i++)
337 {
338 Gbl_CurrentColumn++;
339
340 /* Insert the character into the line buffer */
341
342 *Gbl_LineBufPtr = (UINT8) SourceChar;
343 Gbl_LineBufPtr++;
344
345 if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (Gbl_LineBufferSize - 1)))
346 {
347 #if 0
348 /*
349 * Warning if we have split a long source line.
350 * <Probably overkill>
351 */
352 sprintf (MsgBuffer, "Max %u", Gbl_LineBufferSize);
353 AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
354 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
355 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
356 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
357 #endif
358
359 AslResetCurrentLineBuffer ();
360 }
361 else if (SourceChar == '\n')
362 {
363 /* End of line */
364
365 AslResetCurrentLineBuffer ();
366 }
367 }
368 }
369
370
371 /*******************************************************************************
372 *
373 * FUNCTION: count
374 *
375 * PARAMETERS: yytext - Contains the matched keyword.
376 * Type - Keyword/Character type:
377 * 0 = anything except a keyword
378 * 1 = pseudo-keywords
379 * 2 = non-executable ASL keywords
380 * 3 = executable ASL keywords
381 *
382 * RETURN: None
383 *
384 * DESCRIPTION: Count keywords and put them into the line buffer
385 *
386 ******************************************************************************/
387
388 static void
389 count (
390 int Type)
391 {
392 int i;
393
394
395 switch (Type)
396 {
397 case 2:
398
399 TotalKeywords++;
400 TotalNamedObjects++;
401 break;
402
403 case 3:
404
405 TotalKeywords++;
406 TotalExecutableOpcodes++;
407 break;
408
409 default:
410
411 break;
412 }
413
414 for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
415 {
416 AslInsertLineBuffer (yytext[i]);
417 *Gbl_LineBufPtr = 0;
418 }
419 }
420
421
422 /*******************************************************************************
423 *
424 * FUNCTION: AslDoComment
425 *
426 * PARAMETERS: none
427 *
428 * RETURN: none
429 *
430 * DESCRIPTION: Process a standard comment.
431 *
432 ******************************************************************************/
433
434 static char
435 AslDoComment (
436 void)
437 {
438 int c;
439 int c1 = 0;
440
441
442 AslInsertLineBuffer ('/');
443 AslInsertLineBuffer ('*');
444
445 loop:
446
447 /* Eat chars until end-of-comment */
448
449 while ((c = input()) != '*' && c != EOF)
450 {
451 AslInsertLineBuffer (c);
452 c1 = c;
453 }
454
455 if (c == EOF)
456 {
457 goto EarlyEOF;
458 }
459
460 /*
461 * Check for nested comment -- can help catch cases where a previous
462 * comment was accidently left unterminated
463 */
464 if ((c1 == '/') && (c == '*'))
465 {
466 AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
467 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
468 Gbl_InputByteCount, Gbl_CurrentColumn,
469 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
470 }
471
472 /* Comment is closed only if the NEXT character is a slash */
473
474 AslInsertLineBuffer (c);
475
476 if ((c1 = input()) != '/' && c1 != EOF)
477 {
478 unput(c1);
479 goto loop;
480 }
481
482 if (c1 == EOF)
483 {
484 goto EarlyEOF;
485 }
486
487 AslInsertLineBuffer (c1);
488 return (TRUE);
489
490
491 EarlyEOF:
492 /*
493 * Premature End-Of-File
494 */
495 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
496 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
497 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
498 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
499 return (FALSE);
500 }
501
502
503 /*******************************************************************************
504 *
505 * FUNCTION: AslDoCommentType2
506 *
507 * PARAMETERS: none
508 *
509 * RETURN: none
510 *
511 * DESCRIPTION: Process a new "//" comment.
512 *
513 ******************************************************************************/
514
515 static char
516 AslDoCommentType2 (
517 void)
518 {
519 int c;
520
521
522 AslInsertLineBuffer ('/');
523 AslInsertLineBuffer ('/');
524
525 while ((c = input()) != '\n' && c != EOF)
526 {
527 AslInsertLineBuffer (c);
528 }
529
530 if (c == EOF)
531 {
532 /* End of file is OK, change to newline. Let parser detect EOF later */
533
534 c = '\n';
535 }
536
537 AslInsertLineBuffer (c);
538 return (TRUE);
539 }
540
541
542 /*******************************************************************************
543 *
544 * FUNCTION: AslDoStringLiteral
545 *
546 * PARAMETERS: none
547 *
548 * RETURN: none
549 *
550 * DESCRIPTION: Process a string literal (surrounded by quotes)
551 *
552 ******************************************************************************/
553
554 static char
555 AslDoStringLiteral (
556 void)
557 {
558 char *StringBuffer = MsgBuffer;
559 char *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
560 char *CleanString;
561 int StringChar;
562 UINT32 State = ASL_NORMAL_CHAR;
563 UINT32 i = 0;
564 UINT8 Digit;
565 char ConvertBuffer[4];
566
567
568 /*
569 * Eat chars until end-of-literal.
570 * NOTE: Put back the original surrounding quotes into the
571 * source line buffer.
572 */
573 AslInsertLineBuffer ('\"');
574 while ((StringChar = input()) != EOF)
575 {
576 AslInsertLineBuffer (StringChar);
577
578 DoCharacter:
579 switch (State)
580 {
581 case ASL_NORMAL_CHAR:
582
583 switch (StringChar)
584 {
585 case '\\':
586 /*
587 * Special handling for backslash-escape sequence. We will
588 * toss the backslash and translate the escape char(s).
589 */
590 State = ASL_ESCAPE_SEQUENCE;
591 continue;
592
593 case '\"':
594
595 /* String terminator */
596
597 goto CompletedString;
598
599 default:
600
601 break;
602 }
603 break;
604
605
606 case ASL_ESCAPE_SEQUENCE:
607
608 State = ASL_NORMAL_CHAR;
609 switch (StringChar)
610 {
611 case 'a':
612
613 StringChar = 0x07; /* BELL */
614 break;
615
616 case 'b':
617
618 StringChar = 0x08; /* BACKSPACE */
619 break;
620
621 case 'f':
622
623 StringChar = 0x0C; /* FORMFEED */
624 break;
625
626 case 'n':
627
628 StringChar = 0x0A; /* LINEFEED */
629 break;
630
631 case 'r':
632
633 StringChar = 0x0D; /* CARRIAGE RETURN*/
634 break;
635
636 case 't':
637
638 StringChar = 0x09; /* HORIZONTAL TAB */
639 break;
640
641 case 'v':
642
643 StringChar = 0x0B; /* VERTICAL TAB */
644 break;
645
646 case 'x':
647
648 State = ASL_HEX_CONSTANT;
649 i = 0;
650 continue;
651
652 case '\'': /* Single Quote */
653 case '\"': /* Double Quote */
654 case '\\': /* Backslash */
655
656 break;
657
658 default:
659
660 /* Check for an octal digit (0-7) */
661
662 if (ACPI_IS_OCTAL_DIGIT (StringChar))
663 {
664 State = ASL_OCTAL_CONSTANT;
665 ConvertBuffer[0] = StringChar;
666 i = 1;
667 continue;
668 }
669
670 /* Unknown escape sequence issue warning, but use the character */
671
672 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
673 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
674 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
675 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
676 break;
677 }
678 break;
679
680
681 case ASL_OCTAL_CONSTANT:
682
683 /* Up to three octal digits allowed */
684
685 if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
686 (i > 2))
687 {
688 /*
689 * Reached end of the constant. Convert the assembled ASCII
690 * string and resume processing of the next character
691 */
692 ConvertBuffer[i] = 0;
693 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
694
695 /* Check for NULL or non-ascii character (ignore if so) */
696
697 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
698 {
699 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
700 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
701 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
702 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
703 }
704 else
705 {
706 *StringBuffer = (char) Digit;
707 StringBuffer++;
708 if (StringBuffer >= EndBuffer)
709 {
710 goto BufferOverflow;
711 }
712 }
713
714 State = ASL_NORMAL_CHAR;
715 goto DoCharacter;
716 break;
717 }
718
719 /* Append another digit of the constant */
720
721 ConvertBuffer[i] = StringChar;
722 i++;
723 continue;
724
725 case ASL_HEX_CONSTANT:
726
727 /* Up to two hex digits allowed */
728
729 if (!ACPI_IS_XDIGIT (StringChar) ||
730 (i > 1))
731 {
732 /*
733 * Reached end of the constant. Convert the assembled ASCII
734 * string and resume processing of the next character
735 */
736 ConvertBuffer[i] = 0;
737 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
738
739 /* Check for NULL or non-ascii character (ignore if so) */
740
741 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
742 {
743 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
744 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
745 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
746 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
747 }
748 else
749 {
750 *StringBuffer = (char) Digit;
751 StringBuffer++;
752 if (StringBuffer >= EndBuffer)
753 {
754 goto BufferOverflow;
755 }
756 }
757
758 State = ASL_NORMAL_CHAR;
759 goto DoCharacter;
760 break;
761 }
762
763 /* Append another digit of the constant */
764
765 ConvertBuffer[i] = StringChar;
766 i++;
767 continue;
768
769 default:
770
771 break;
772 }
773
774 /* Save the finished character */
775
776 *StringBuffer = StringChar;
777 StringBuffer++;
778 if (StringBuffer >= EndBuffer)
779 {
780 goto BufferOverflow;
781 }
782 }
783
784 /*
785 * Premature End-Of-File
786 */
787 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
788 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
789 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
790 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
791 return (FALSE);
792
793
794 CompletedString:
795 /*
796 * Null terminate the input string and copy string to a new buffer
797 */
798 *StringBuffer = 0;
799
800 CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
801 if (!CleanString)
802 {
803 AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
804 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
805 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
806 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
807 return (FALSE);
808 }
809
810 ACPI_STRCPY (CleanString, MsgBuffer);
811 AslCompilerlval.s = CleanString;
812 return (TRUE);
813
814
815 BufferOverflow:
816
817 /* Literal was too long */
818
819 AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
820 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
821 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
822 Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");
823 return (FALSE);
824 }