1 /******************************************************************************
2  *
3  * Module Name: asloptions - compiler command line processing
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2017, 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 <contrib/dev/acpica/compiler/aslcompiler.h>
153 #include <contrib/dev/acpica/include/acapps.h>
154 #include <contrib/dev/acpica/include/acdisasm.h>
155 
156 #define _COMPONENT          ACPI_COMPILER
157         ACPI_MODULE_NAME    ("asloption")
158 
159 
160 /* Local prototypes */
161 
162 static int
163 AslDoOptions (
164     int                     argc,
165     char                    **argv,
166     BOOLEAN                 IsResponseFile);
167 
168 static void
169 AslMergeOptionTokens (
170     char                    *InBuffer,
171     char                    *OutBuffer);
172 
173 static int
174 AslDoResponseFile (
175     char                    *Filename);
176 
177 
178 #define ASL_TOKEN_SEPARATORS    " \t\n"
179 #define ASL_SUPPORTED_OPTIONS   "@:a:b|c|d^D:e:f^gh^i|I:l^m:no|p:P^q^r:s|t|T+G^v^w|x:z"
180 
181 
182 /*******************************************************************************
183  *
184  * FUNCTION:    AslCommandLine
185  *
186  * PARAMETERS:  argc/argv
187  *
188  * RETURN:      Last argv index
189  *
190  * DESCRIPTION: Command line processing
191  *
192  ******************************************************************************/
193 
194 int
195 AslCommandLine (
196     int                     argc,
197     char                    **argv)
198 {
199     int                     BadCommandLine = 0;
200     ACPI_STATUS             Status;
201 
202 
203     /* Minimum command line contains at least the command and an input file */
204 
205     if (argc < 2)
206     {
207         Usage ();
208         exit (1);
209     }
210 
211     /* Process all command line options */
212 
213     BadCommandLine = AslDoOptions (argc, argv, FALSE);
214 
215     if (Gbl_DoTemplates)
216     {
217         Status = DtCreateTemplates (argv);
218         if (ACPI_FAILURE (Status))
219         {
220             exit (-1);
221         }
222         exit (1);
223     }
224 
225     /* Next parameter must be the input filename */
226 
227     if (!argv[AcpiGbl_Optind] &&
228         !AcpiGbl_DisasmFlag)
229     {
230         printf ("Missing input filename\n");
231         BadCommandLine = TRUE;
232     }
233 
234     if (Gbl_DoSignon)
235     {
236         printf (ACPI_COMMON_SIGNON (ASL_COMPILER_NAME));
237         if (Gbl_IgnoreErrors)
238         {
239             printf ("Ignoring all errors, forcing AML file generation\n\n");
240         }
241     }
242 
243     if (BadCommandLine)
244     {
245         printf ("Use -h option for help information\n");
246         exit (1);
247     }
248 
249     return (AcpiGbl_Optind);
250 }
251 
252 
253 /*******************************************************************************
254  *
255  * FUNCTION:    AslDoOptions
256  *
257  * PARAMETERS:  argc/argv           - Standard argc/argv
258  *              IsResponseFile      - TRUE if executing a response file.
259  *
260  * RETURN:      Status
261  *
262  * DESCRIPTION: Command line option processing
263  *
264  ******************************************************************************/
265 
266 static int
267 AslDoOptions (
268     int                     argc,
269     char                    **argv,
270     BOOLEAN                 IsResponseFile)
271 {
272     ACPI_STATUS             Status;
273     UINT32                  j;
274 
275 
276     /* Get the command line options */
277 
278     while ((j = AcpiGetopt (argc, argv, ASL_SUPPORTED_OPTIONS)) != ACPI_OPT_END) switch (j)
279     {
280     case '@':   /* Begin a response file */
281 
282         if (IsResponseFile)
283         {
284             printf ("Nested command files are not supported\n");
285             return (-1);
286         }
287 
288         if (AslDoResponseFile (AcpiGbl_Optarg))
289         {
290             return (-1);
291         }
292         break;
293 
294     case 'a':   /* Debug options */
295 
296         switch (AcpiGbl_Optarg[0])
297         {
298         case 'r':
299 
300             Gbl_EnableReferenceTypechecking = TRUE;
301             break;
302 
303         default:
304 
305             printf ("Unknown option: -a%s\n", AcpiGbl_Optarg);
306             return (-1);
307         }
308 
309         break;
310 
311 
312     case 'b':   /* Debug options */
313 
314         switch (AcpiGbl_Optarg[0])
315         {
316 
317         case 'c':
318 
319             printf ("Debug ASL to ASL+ conversion\n");
320 
321             Gbl_DoAslConversion = TRUE;
322             Gbl_FoldConstants = FALSE;
323             Gbl_IntegerOptimizationFlag = FALSE;
324             Gbl_ReferenceOptimizationFlag = FALSE;
325             Gbl_OptimizeTrivialParseNodes = FALSE;
326             Gbl_CaptureComments = TRUE;
327             AcpiGbl_DoDisassemblerOptimizations = FALSE;
328             AcpiGbl_DebugAslConversion = TRUE;
329             AcpiGbl_DmEmitExternalOpcodes = TRUE;
330             Gbl_DoExternalsInPlace = TRUE;
331 
332             return (0);
333 
334         case 'f':
335 
336             AslCompilerdebug = 1; /* same as yydebug */
337             DtParserdebug = 1;
338             PrParserdebug = 1;
339             Gbl_DebugFlag = TRUE;
340             Gbl_KeepPreprocessorTempFile = TRUE;
341             break;
342 
343         case 'p':   /* Prune ASL parse tree */
344 
345             /* Get the required argument */
346 
347             if (AcpiGetoptArgument (argc, argv))
348             {
349                 return (-1);
350             }
351 
352             Gbl_PruneParseTree = TRUE;
353             Gbl_PruneDepth = (UINT8) strtoul (AcpiGbl_Optarg, NULL, 0);
354             break;
355 
356         case 's':
357 
358             Gbl_DebugFlag = TRUE;
359             break;
360 
361         case 't':
362 
363             /* Get the required argument */
364 
365             if (AcpiGetoptArgument (argc, argv))
366             {
367                 return (-1);
368             }
369 
370             Gbl_PruneType = (UINT8) strtoul (AcpiGbl_Optarg, NULL, 0);
371             break;
372 
373         default:
374 
375             printf ("Unknown option: -b%s\n", AcpiGbl_Optarg);
376             return (-1);
377         }
378 
379         break;
380 
381     case 'c':
382 
383         switch (AcpiGbl_Optarg[0])
384         {
385 
386         case 'a':
387 
388             printf ("Convert ASL to ASL+ with comments\n");
389             Gbl_DoAslConversion = TRUE;
390             Gbl_FoldConstants = FALSE;
391             Gbl_IntegerOptimizationFlag = FALSE;
392             Gbl_ReferenceOptimizationFlag = FALSE;
393             Gbl_OptimizeTrivialParseNodes = FALSE;
394             Gbl_CaptureComments = TRUE;
395             AcpiGbl_DoDisassemblerOptimizations = FALSE;
396             AcpiGbl_DmEmitExternalOpcodes = TRUE;
397             Gbl_DoExternalsInPlace = TRUE;
398 
399             return (0);
400 
401         case 'r':
402 
403             Gbl_NoResourceChecking = TRUE;
404             break;
405 
406         default:
407 
408             printf ("Unknown option: -c%s\n", AcpiGbl_Optarg);
409             return (-1);
410         }
411         break;
412 
413     case 'd':   /* Disassembler */
414 
415         switch (AcpiGbl_Optarg[0])
416         {
417         case '^':
418 
419             /* Get the required argument */
420 
421             if (AcpiGetoptArgument (argc, argv))
422             {
423                 return (-1);
424             }
425 
426             Gbl_DoCompile = FALSE;
427             break;
428 
429         case 'a':
430 
431             /* Get the required argument */
432 
433             if (AcpiGetoptArgument (argc, argv))
434             {
435                 return (-1);
436             }
437 
438             Gbl_DoCompile = FALSE;
439             Gbl_DisassembleAll = TRUE;
440             break;
441 
442         case 'b':   /* Do not convert buffers to resource descriptors */
443 
444             AcpiGbl_NoResourceDisassembly = TRUE;
445             break;
446 
447         case 'c':
448 
449             break;
450 
451         case 'f':
452 
453             AcpiGbl_ForceAmlDisassembly = TRUE;
454             break;
455 
456         case 'l':   /* Use legacy ASL code (not ASL+) for disassembly */
457 
458             Gbl_DoCompile = FALSE;
459             AcpiGbl_CstyleDisassembly = FALSE;
460             break;
461 
462         default:
463 
464             printf ("Unknown option: -d%s\n", AcpiGbl_Optarg);
465             return (-1);
466         }
467 
468         AcpiGbl_DisasmFlag = TRUE;
469         break;
470 
471     case 'D':   /* Define a symbol */
472 
473         PrAddDefine (AcpiGbl_Optarg, NULL, TRUE);
474         break;
475 
476     case 'e':   /* External files for disassembler */
477 
478         /* Get entire list of external files */
479 
480         AcpiGbl_Optind--;
481         argv[AcpiGbl_Optind] = AcpiGbl_Optarg;
482 
483         while (argv[AcpiGbl_Optind] &&
484               (argv[AcpiGbl_Optind][0] != '-'))
485         {
486             Status = AcpiDmAddToExternalFileList (argv[AcpiGbl_Optind]);
487             if (ACPI_FAILURE (Status))
488             {
489                 printf ("Could not add %s to external list\n",
490                     argv[AcpiGbl_Optind]);
491                 return (-1);
492             }
493 
494             AcpiGbl_Optind++;
495         }
496         break;
497 
498     case 'f':
499 
500         switch (AcpiGbl_Optarg[0])
501         {
502         case '^':   /* Ignore errors and force creation of aml file */
503 
504             Gbl_IgnoreErrors = TRUE;
505             break;
506 
507         case 'e':   /* Disassembler: Get external declaration file */
508 
509             if (AcpiGetoptArgument (argc, argv))
510             {
511                 return (-1);
512             }
513 
514             Gbl_ExternalRefFilename = AcpiGbl_Optarg;
515             break;
516 
517         default:
518 
519             printf ("Unknown option: -f%s\n", AcpiGbl_Optarg);
520             return (-1);
521         }
522         break;
523 
524     case 'G':
525 
526         Gbl_CompileGeneric = TRUE;
527         break;
528 
529     case 'g':   /* Get all ACPI tables */
530 
531         printf ("-g option is deprecated, use acpidump utility instead\n");
532         exit (1);
533 
534     case 'h':
535 
536         switch (AcpiGbl_Optarg[0])
537         {
538         case '^':
539 
540             Usage ();
541             exit (0);
542 
543         case 'c':
544 
545             UtDisplayConstantOpcodes ();
546             exit (0);
547 
548         case 'd':
549 
550             AslDisassemblyHelp ();
551             exit (0);
552 
553         case 'f':
554 
555             AslFilenameHelp ();
556             exit (0);
557 
558         case 'r':
559 
560             /* reserved names */
561 
562             ApDisplayReservedNames ();
563             exit (0);
564 
565         case 't':
566 
567             UtDisplaySupportedTables ();
568             exit (0);
569 
570         default:
571 
572             printf ("Unknown option: -h%s\n", AcpiGbl_Optarg);
573             return (-1);
574         }
575 
576     case 'I':   /* Add an include file search directory */
577 
578         FlAddIncludeDirectory (AcpiGbl_Optarg);
579         break;
580 
581     case 'i':   /* Output AML as an include file */
582 
583         switch (AcpiGbl_Optarg[0])
584         {
585         case 'a':
586 
587             /* Produce assembly code include file */
588 
589             Gbl_AsmIncludeOutputFlag = TRUE;
590             break;
591 
592         case 'c':
593 
594             /* Produce C include file */
595 
596             Gbl_C_IncludeOutputFlag = TRUE;
597             break;
598 
599         case 'n':
600 
601             /* Compiler/Disassembler: Ignore the NOOP operator */
602 
603             AcpiGbl_IgnoreNoopOperator = TRUE;
604             break;
605 
606         default:
607 
608             printf ("Unknown option: -i%s\n", AcpiGbl_Optarg);
609             return (-1);
610         }
611         break;
612 
613     case 'l':   /* Listing files */
614 
615         switch (AcpiGbl_Optarg[0])
616         {
617         case '^':
618 
619             /* Produce listing file (Mixed source/aml) */
620 
621             Gbl_ListingFlag = TRUE;
622             AcpiGbl_DmOpt_Listing = TRUE;
623             break;
624 
625         case 'i':
626 
627             /* Produce preprocessor output file */
628 
629             Gbl_PreprocessorOutputFlag = TRUE;
630             break;
631 
632         case 'm':
633 
634             /* Produce hardware map summary file */
635 
636             Gbl_MapfileFlag = TRUE;
637             break;
638 
639         case 'n':
640 
641             /* Produce namespace file */
642 
643             Gbl_NsOutputFlag = TRUE;
644             break;
645 
646         case 's':
647 
648             /* Produce combined source file */
649 
650             Gbl_SourceOutputFlag = TRUE;
651             break;
652 
653         case 'x':
654 
655             /* Produce cross-reference file */
656 
657             Gbl_CrossReferenceOutput = TRUE;
658             break;
659 
660         default:
661 
662             printf ("Unknown option: -l%s\n", AcpiGbl_Optarg);
663             return (-1);
664         }
665         break;
666 
667     case 'm':   /* Set line buffer size */
668 
669         Gbl_LineBufferSize = (UINT32) strtoul (AcpiGbl_Optarg, NULL, 0) * 1024;
670         if (Gbl_LineBufferSize < ASL_DEFAULT_LINE_BUFFER_SIZE)
671         {
672             Gbl_LineBufferSize = ASL_DEFAULT_LINE_BUFFER_SIZE;
673         }
674         printf ("Line Buffer Size: %u\n", Gbl_LineBufferSize);
675         break;
676 
677     case 'n':   /* Parse only */
678 
679         Gbl_ParseOnlyFlag = TRUE;
680         break;
681 
682     case 'o':   /* Control compiler AML optimizations */
683 
684         switch (AcpiGbl_Optarg[0])
685         {
686         case 'a':
687 
688             /* Disable all optimizations */
689 
690             Gbl_FoldConstants = FALSE;
691             Gbl_IntegerOptimizationFlag = FALSE;
692             Gbl_ReferenceOptimizationFlag = FALSE;
693             Gbl_OptimizeTrivialParseNodes = FALSE;
694 
695             break;
696 
697         case 'c':
698 
699             /* Display compile time(s) */
700 
701             Gbl_CompileTimesFlag = TRUE;
702             break;
703 
704         case 'd':
705 
706             /* Disable disassembler code optimizations */
707 
708             AcpiGbl_DoDisassemblerOptimizations = FALSE;
709             break;
710 
711         case 'e':
712 
713             /* Disassembler: Emit embedded external operators */
714 
715             AcpiGbl_DmEmitExternalOpcodes = TRUE;
716             break;
717 
718         case 'E':
719 
720             /*
721              * iASL: keep External opcodes in place.
722              * No affect if Gbl_DoExternals is false.
723              */
724 
725             Gbl_DoExternalsInPlace = TRUE;
726             break;
727 
728         case 'f':
729 
730             /* Disable folding on "normal" expressions */
731 
732             Gbl_FoldConstants = FALSE;
733             break;
734 
735         case 'i':
736 
737             /* Disable integer optimization to constants */
738 
739             Gbl_IntegerOptimizationFlag = FALSE;
740             break;
741 
742         case 'n':
743 
744             /* Disable named reference optimization */
745 
746             Gbl_ReferenceOptimizationFlag = FALSE;
747             break;
748 
749         case 't':
750 
751             /* Disable heavy typechecking */
752 
753             Gbl_DoTypechecking = FALSE;
754             break;
755 
756         default:
757 
758             printf ("Unknown option: -c%s\n", AcpiGbl_Optarg);
759             return (-1);
760         }
761         break;
762 
763     case 'P':   /* Preprocessor options */
764 
765         switch (AcpiGbl_Optarg[0])
766         {
767         case '^':   /* Proprocess only, emit (.i) file */
768 
769             Gbl_PreprocessOnly = TRUE;
770             Gbl_PreprocessorOutputFlag = TRUE;
771             break;
772 
773         case 'n':   /* Disable preprocessor */
774 
775             Gbl_PreprocessFlag = FALSE;
776             break;
777 
778         default:
779 
780             printf ("Unknown option: -P%s\n", AcpiGbl_Optarg);
781             return (-1);
782         }
783         break;
784 
785     case 'p':   /* Override default AML output filename */
786 
787         Gbl_OutputFilenamePrefix = AcpiGbl_Optarg;
788         UtConvertBackslashes (Gbl_OutputFilenamePrefix);
789         Gbl_UseDefaultAmlFilename = FALSE;
790         break;
791 
792     case 'q':   /* ASL/ASl+ converter: compile only and leave badaml. */
793 
794         printf ("Convert ASL to ASL+ with comments\n");
795         Gbl_FoldConstants = FALSE;
796         Gbl_IntegerOptimizationFlag = FALSE;
797         Gbl_ReferenceOptimizationFlag = FALSE;
798         Gbl_OptimizeTrivialParseNodes = FALSE;
799         Gbl_CaptureComments = TRUE;
800         Gbl_DoExternalsInPlace = TRUE;
801         return (0);
802 
803     case 'r':   /* Override revision found in table header */
804 
805         Gbl_RevisionOverride = (UINT8) strtoul (AcpiGbl_Optarg, NULL, 0);
806         break;
807 
808     case 's':   /* Create AML in a source code file */
809 
810         switch (AcpiGbl_Optarg[0])
811         {
812         case 'a':
813 
814             /* Produce assembly code output file */
815 
816             Gbl_AsmOutputFlag = TRUE;
817             break;
818 
819         case 'c':
820 
821             /* Produce C hex output file */
822 
823             Gbl_C_OutputFlag = TRUE;
824             break;
825 
826         case 'o':
827 
828             /* Produce AML offset table in C */
829 
830             Gbl_C_OffsetTableFlag = TRUE;
831             break;
832 
833         default:
834 
835             printf ("Unknown option: -s%s\n", AcpiGbl_Optarg);
836             return (-1);
837         }
838         break;
839 
840     case 't':   /* Produce hex table output file */
841 
842         switch (AcpiGbl_Optarg[0])
843         {
844         case 'a':
845 
846             Gbl_HexOutputFlag = HEX_OUTPUT_ASM;
847             break;
848 
849         case 'c':
850 
851             Gbl_HexOutputFlag = HEX_OUTPUT_C;
852             break;
853 
854         case 's':
855 
856             Gbl_HexOutputFlag = HEX_OUTPUT_ASL;
857             break;
858 
859         default:
860 
861             printf ("Unknown option: -t%s\n", AcpiGbl_Optarg);
862             return (-1);
863         }
864         break;
865 
866     case 'T':   /* Create a ACPI table template file */
867 
868         Gbl_DoTemplates = TRUE;
869         break;
870 
871     case 'v':   /* Version and verbosity settings */
872 
873         switch (AcpiGbl_Optarg[0])
874         {
875         case '^':
876 
877             printf (ACPI_COMMON_SIGNON (ASL_COMPILER_NAME));
878             exit (0);
879 
880         case 'a':
881 
882             /* Disable all error/warning/remark messages */
883 
884             Gbl_NoErrors = TRUE;
885             break;
886 
887         case 'e':
888 
889             /* Disable all warning/remark messages (errors only) */
890 
891             Gbl_DisplayRemarks = FALSE;
892             Gbl_DisplayWarnings = FALSE;
893             break;
894 
895         case 'i':
896             /*
897              * Support for integrated development environment(s).
898              *
899              * 1) No compiler signon
900              * 2) Send stderr messages to stdout
901              * 3) Less verbose error messages (single line only for each)
902              * 4) Error/warning messages are formatted appropriately to
903              *    be recognized by MS Visual Studio
904              */
905             Gbl_VerboseErrors = FALSE;
906             Gbl_DoSignon = FALSE;
907             Gbl_Files[ASL_FILE_STDERR].Handle = stdout;
908             break;
909 
910         case 'o':
911 
912             Gbl_DisplayOptimizations = TRUE;
913             break;
914 
915         case 'r':
916 
917             Gbl_DisplayRemarks = FALSE;
918             break;
919 
920         case 's':
921 
922             Gbl_DoSignon = FALSE;
923             break;
924 
925         case 't':
926 
927             Gbl_VerboseTemplates = TRUE;
928             break;
929 
930         case 'w':
931 
932             /* Get the required argument */
933 
934             if (AcpiGetoptArgument (argc, argv))
935             {
936                 return (-1);
937             }
938 
939             Status = AslDisableException (AcpiGbl_Optarg);
940             if (ACPI_FAILURE (Status))
941             {
942                 return (-1);
943             }
944             break;
945 
946         case 'x':
947 
948             /* Get the required argument */
949 
950             if (AcpiGetoptArgument (argc, argv))
951             {
952                 return (-1);
953             }
954 
955             Status = AslExpectException (AcpiGbl_Optarg);
956             if (ACPI_FAILURE (Status))
957             {
958                 return (-1);
959             }
960             break;
961 
962         default:
963 
964             printf ("Unknown option: -v%s\n", AcpiGbl_Optarg);
965             return (-1);
966         }
967         break;
968 
969     case 'w': /* Set warning levels */
970 
971         switch (AcpiGbl_Optarg[0])
972         {
973         case '1':
974 
975             Gbl_WarningLevel = ASL_WARNING;
976             break;
977 
978         case '2':
979 
980             Gbl_WarningLevel = ASL_WARNING2;
981             break;
982 
983         case '3':
984 
985             Gbl_WarningLevel = ASL_WARNING3;
986             break;
987 
988         case 'e':
989 
990             Gbl_WarningsAsErrors = TRUE;
991             break;
992 
993         default:
994 
995             printf ("Unknown option: -w%s\n", AcpiGbl_Optarg);
996             return (-1);
997         }
998         break;
999 
1000     case 'x':   /* Set debug print output level */
1001 
1002         AcpiDbgLevel = strtoul (AcpiGbl_Optarg, NULL, 16);
1003         break;
1004 
1005     case 'z':
1006 
1007         Gbl_UseOriginalCompilerId = TRUE;
1008         break;
1009 
1010     default:
1011 
1012         return (-1);
1013     }
1014 
1015     return (0);
1016 }
1017 
1018 
1019 /*******************************************************************************
1020  *
1021  * FUNCTION:    AslMergeOptionTokens
1022  *
1023  * PARAMETERS:  InBuffer            - Input containing an option string
1024  *              OutBuffer           - Merged output buffer
1025  *
1026  * RETURN:      None
1027  *
1028  * DESCRIPTION: Remove all whitespace from an option string.
1029  *
1030  ******************************************************************************/
1031 
1032 static void
1033 AslMergeOptionTokens (
1034     char                    *InBuffer,
1035     char                    *OutBuffer)
1036 {
1037     char                    *Token;
1038 
1039 
1040     *OutBuffer = 0;
1041 
1042     Token = strtok (InBuffer, ASL_TOKEN_SEPARATORS);
1043     while (Token)
1044     {
1045         strcat (OutBuffer, Token);
1046         Token = strtok (NULL, ASL_TOKEN_SEPARATORS);
1047     }
1048 }
1049 
1050 
1051 /*******************************************************************************
1052  *
1053  * FUNCTION:    AslDoResponseFile
1054  *
1055  * PARAMETERS:  Filename        - Name of the response file
1056  *
1057  * RETURN:      Status
1058  *
1059  * DESCRIPTION: Open a response file and process all options within.
1060  *
1061  ******************************************************************************/
1062 
1063 static int
1064 AslDoResponseFile (
1065     char                    *Filename)
1066 {
1067     char                    *argv = StringBuffer2;
1068     FILE                    *ResponseFile;
1069     int                     OptStatus = 0;
1070     int                     Opterr;
1071     int                     Optind;
1072 
1073 
1074     ResponseFile = fopen (Filename, "r");
1075     if (!ResponseFile)
1076     {
1077         printf ("Could not open command file %s, %s\n",
1078             Filename, strerror (errno));
1079         return (-1);
1080     }
1081 
1082     /* Must save the current GetOpt globals */
1083 
1084     Opterr = AcpiGbl_Opterr;
1085     Optind = AcpiGbl_Optind;
1086 
1087     /*
1088      * Process all lines in the response file. There must be one complete
1089      * option per line
1090      */
1091     while (fgets (StringBuffer, ASL_MSG_BUFFER_SIZE, ResponseFile))
1092     {
1093         /* Compress all tokens, allowing us to use a single argv entry */
1094 
1095         AslMergeOptionTokens (StringBuffer, StringBuffer2);
1096 
1097         /* Process the option */
1098 
1099         AcpiGbl_Opterr = 0;
1100         AcpiGbl_Optind = 0;
1101 
1102         OptStatus = AslDoOptions (1, &argv, TRUE);
1103         if (OptStatus)
1104         {
1105             printf ("Invalid option in command file %s: %s\n",
1106                 Filename, StringBuffer);
1107             break;
1108         }
1109     }
1110 
1111     /* Restore the GetOpt globals */
1112 
1113     AcpiGbl_Opterr = Opterr;
1114     AcpiGbl_Optind = Optind;
1115 
1116     fclose (ResponseFile);
1117     return (OptStatus);
1118 }
1119