xref: /illumos-gate/usr/src/cmd/acpi/iasl/asloptions.c (revision 35786f68)
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 - 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 #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
AslCommandLine(int argc,char ** argv)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
AslDoOptions(int argc,char ** argv,BOOLEAN IsResponseFile)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             AcpiGbl_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             AcpiGbl_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             Gbl_DoCompile = FALSE;
420             break;
421 
422         case 'a':
423 
424             Gbl_DoCompile = FALSE;
425             Gbl_DisassembleAll = TRUE;
426             break;
427 
428         case 'b':   /* Do not convert buffers to resource descriptors */
429 
430             AcpiGbl_NoResourceDisassembly = TRUE;
431             break;
432 
433         case 'c':
434 
435             break;
436 
437         case 'f':
438 
439             AcpiGbl_ForceAmlDisassembly = TRUE;
440             break;
441 
442         case 'l':   /* Use legacy ASL code (not ASL+) for disassembly */
443 
444             Gbl_DoCompile = FALSE;
445             AcpiGbl_CstyleDisassembly = FALSE;
446             break;
447 
448         default:
449 
450             printf ("Unknown option: -d%s\n", AcpiGbl_Optarg);
451             return (-1);
452         }
453 
454         AcpiGbl_DisasmFlag = TRUE;
455         break;
456 
457     case 'D':   /* Define a symbol */
458 
459         PrAddDefine (AcpiGbl_Optarg, NULL, TRUE);
460         break;
461 
462     case 'e':   /* External files for disassembler */
463 
464         /* Get entire list of external files */
465 
466         AcpiGbl_Optind--;
467         argv[AcpiGbl_Optind] = AcpiGbl_Optarg;
468 
469         while (argv[AcpiGbl_Optind] &&
470               (argv[AcpiGbl_Optind][0] != '-'))
471         {
472             Status = AcpiDmAddToExternalFileList (argv[AcpiGbl_Optind]);
473             if (ACPI_FAILURE (Status))
474             {
475                 printf ("Could not add %s to external list\n",
476                     argv[AcpiGbl_Optind]);
477                 return (-1);
478             }
479 
480             AcpiGbl_Optind++;
481         }
482         break;
483 
484     case 'f':
485 
486         switch (AcpiGbl_Optarg[0])
487         {
488         case '^':   /* Ignore errors and force creation of aml file */
489 
490             Gbl_IgnoreErrors = TRUE;
491             break;
492 
493         case 'e':   /* Disassembler: Get external declaration file */
494 
495             if (AcpiGetoptArgument (argc, argv))
496             {
497                 return (-1);
498             }
499 
500             Gbl_ExternalRefFilename = AcpiGbl_Optarg;
501             break;
502 
503         default:
504 
505             printf ("Unknown option: -f%s\n", AcpiGbl_Optarg);
506             return (-1);
507         }
508         break;
509 
510     case 'G':
511 
512         Gbl_CompileGeneric = TRUE;
513         break;
514 
515     case 'g':   /* Get all ACPI tables */
516 
517         printf ("-g option is deprecated, use acpidump utility instead\n");
518         exit (1);
519 
520     case 'h':
521 
522         switch (AcpiGbl_Optarg[0])
523         {
524         case '^':
525 
526             Usage ();
527             exit (0);
528 
529         case 'c':
530 
531             UtDisplayConstantOpcodes ();
532             exit (0);
533 
534         case 'd':
535 
536             AslDisassemblyHelp ();
537             exit (0);
538 
539         case 'f':
540 
541             AslFilenameHelp ();
542             exit (0);
543 
544         case 'r':
545 
546             /* reserved names */
547 
548             ApDisplayReservedNames ();
549             exit (0);
550 
551         case 't':
552 
553             UtDisplaySupportedTables ();
554             exit (0);
555 
556         default:
557 
558             printf ("Unknown option: -h%s\n", AcpiGbl_Optarg);
559             return (-1);
560         }
561 
562     case 'I':   /* Add an include file search directory */
563 
564         FlAddIncludeDirectory (AcpiGbl_Optarg);
565         break;
566 
567     case 'i':   /* Output AML as an include file */
568 
569         switch (AcpiGbl_Optarg[0])
570         {
571         case 'a':
572 
573             /* Produce assembly code include file */
574 
575             Gbl_AsmIncludeOutputFlag = TRUE;
576             break;
577 
578         case 'c':
579 
580             /* Produce C include file */
581 
582             Gbl_C_IncludeOutputFlag = TRUE;
583             break;
584 
585         case 'n':
586 
587             /* Compiler/Disassembler: Ignore the NOOP operator */
588 
589             AcpiGbl_IgnoreNoopOperator = TRUE;
590             break;
591 
592         default:
593 
594             printf ("Unknown option: -i%s\n", AcpiGbl_Optarg);
595             return (-1);
596         }
597         break;
598 
599     case 'l':   /* Listing files */
600 
601         switch (AcpiGbl_Optarg[0])
602         {
603         case '^':
604 
605             /* Produce listing file (Mixed source/aml) */
606 
607             Gbl_ListingFlag = TRUE;
608             AcpiGbl_DmOpt_Listing = TRUE;
609             break;
610 
611         case 'i':
612 
613             /* Produce preprocessor output file */
614 
615             Gbl_PreprocessorOutputFlag = TRUE;
616             break;
617 
618         case 'm':
619 
620             /* Produce hardware map summary file */
621 
622             Gbl_MapfileFlag = TRUE;
623             break;
624 
625         case 'n':
626 
627             /* Produce namespace file */
628 
629             Gbl_NsOutputFlag = TRUE;
630             break;
631 
632         case 's':
633 
634             /* Produce combined source file */
635 
636             Gbl_SourceOutputFlag = TRUE;
637             break;
638 
639         case 'x':
640 
641             /* Produce cross-reference file */
642 
643             Gbl_CrossReferenceOutput = TRUE;
644             break;
645 
646         default:
647 
648             printf ("Unknown option: -l%s\n", AcpiGbl_Optarg);
649             return (-1);
650         }
651         break;
652 
653     case 'm':   /* Set line buffer size */
654 
655         Gbl_LineBufferSize = (UINT32) strtoul (AcpiGbl_Optarg, NULL, 0) * 1024;
656         if (Gbl_LineBufferSize < ASL_DEFAULT_LINE_BUFFER_SIZE)
657         {
658             Gbl_LineBufferSize = ASL_DEFAULT_LINE_BUFFER_SIZE;
659         }
660         printf ("Line Buffer Size: %u\n", Gbl_LineBufferSize);
661         break;
662 
663     case 'n':   /* Parse only */
664 
665         Gbl_ParseOnlyFlag = TRUE;
666         break;
667 
668     case 'o':   /* Control compiler AML optimizations */
669 
670         switch (AcpiGbl_Optarg[0])
671         {
672         case 'a':
673 
674             /* Disable all optimizations */
675 
676             Gbl_FoldConstants = FALSE;
677             Gbl_IntegerOptimizationFlag = FALSE;
678             Gbl_ReferenceOptimizationFlag = FALSE;
679             Gbl_OptimizeTrivialParseNodes = FALSE;
680 
681             break;
682 
683         case 'c':
684 
685             /* Display compile time(s) */
686 
687             Gbl_CompileTimesFlag = TRUE;
688             break;
689 
690         case 'd':
691 
692             /* Disable disassembler code optimizations */
693 
694             AcpiGbl_DoDisassemblerOptimizations = FALSE;
695             break;
696 
697         case 'e':
698 
699             /* Disassembler: Emit embedded external operators */
700 
701             AcpiGbl_DmEmitExternalOpcodes = TRUE;
702             break;
703 
704         case 'E':
705 
706             /*
707              * iASL: keep External opcodes in place.
708              * No affect if Gbl_DoExternals is false.
709              */
710 
711             Gbl_DoExternalsInPlace = TRUE;
712             break;
713 
714         case 'f':
715 
716             /* Disable folding on "normal" expressions */
717 
718             Gbl_FoldConstants = FALSE;
719             break;
720 
721         case 'i':
722 
723             /* Disable integer optimization to constants */
724 
725             Gbl_IntegerOptimizationFlag = FALSE;
726             break;
727 
728         case 'n':
729 
730             /* Disable named reference optimization */
731 
732             Gbl_ReferenceOptimizationFlag = FALSE;
733             break;
734 
735         case 't':
736 
737             /* Disable heavy typechecking */
738 
739             Gbl_DoTypechecking = FALSE;
740             break;
741 
742         default:
743 
744             printf ("Unknown option: -c%s\n", AcpiGbl_Optarg);
745             return (-1);
746         }
747         break;
748 
749     case 'P':   /* Preprocessor options */
750 
751         switch (AcpiGbl_Optarg[0])
752         {
753         case '^':   /* Proprocess only, emit (.i) file */
754 
755             Gbl_PreprocessOnly = TRUE;
756             Gbl_PreprocessorOutputFlag = TRUE;
757             break;
758 
759         case 'n':   /* Disable preprocessor */
760 
761             Gbl_PreprocessFlag = FALSE;
762             break;
763 
764         default:
765 
766             printf ("Unknown option: -P%s\n", AcpiGbl_Optarg);
767             return (-1);
768         }
769         break;
770 
771     case 'p':   /* Override default AML output filename */
772 
773         Gbl_OutputFilenamePrefix = AcpiGbl_Optarg;
774         UtConvertBackslashes (Gbl_OutputFilenamePrefix);
775         Gbl_UseDefaultAmlFilename = FALSE;
776         break;
777 
778     case 'q':   /* ASL/ASl+ converter: compile only and leave badaml. */
779 
780         printf ("Convert ASL to ASL+ with comments\n");
781         Gbl_FoldConstants = FALSE;
782         Gbl_IntegerOptimizationFlag = FALSE;
783         Gbl_ReferenceOptimizationFlag = FALSE;
784         Gbl_OptimizeTrivialParseNodes = FALSE;
785         Gbl_DoExternalsInPlace = TRUE;
786         AcpiGbl_CaptureComments = TRUE;
787         return (0);
788 
789     case 'r':   /* Override revision found in table header */
790 
791         Gbl_RevisionOverride = (UINT8) strtoul (AcpiGbl_Optarg, NULL, 0);
792         break;
793 
794     case 's':   /* Create AML in a source code file */
795 
796         switch (AcpiGbl_Optarg[0])
797         {
798         case 'a':
799 
800             /* Produce assembly code output file */
801 
802             Gbl_AsmOutputFlag = TRUE;
803             break;
804 
805         case 'c':
806 
807             /* Produce C hex output file */
808 
809             Gbl_C_OutputFlag = TRUE;
810             break;
811 
812         case 'o':
813 
814             /* Produce AML offset table in C */
815 
816             Gbl_C_OffsetTableFlag = TRUE;
817             break;
818 
819         default:
820 
821             printf ("Unknown option: -s%s\n", AcpiGbl_Optarg);
822             return (-1);
823         }
824         break;
825 
826     case 't':   /* Produce hex table output file */
827 
828         switch (AcpiGbl_Optarg[0])
829         {
830         case 'a':
831 
832             Gbl_HexOutputFlag = HEX_OUTPUT_ASM;
833             break;
834 
835         case 'c':
836 
837             Gbl_HexOutputFlag = HEX_OUTPUT_C;
838             break;
839 
840         case 's':
841 
842             Gbl_HexOutputFlag = HEX_OUTPUT_ASL;
843             break;
844 
845         default:
846 
847             printf ("Unknown option: -t%s\n", AcpiGbl_Optarg);
848             return (-1);
849         }
850         break;
851 
852     case 'T':   /* Create a ACPI table template file */
853 
854         Gbl_DoTemplates = TRUE;
855         break;
856 
857     case 'v':   /* Version and verbosity settings */
858 
859         switch (AcpiGbl_Optarg[0])
860         {
861         case '^':
862 
863             printf (ACPI_COMMON_SIGNON (ASL_COMPILER_NAME));
864             exit (0);
865 
866         case 'a':
867 
868             /* Disable all error/warning/remark messages */
869 
870             Gbl_NoErrors = TRUE;
871             break;
872 
873         case 'd':
874 
875             printf (ACPI_COMMON_SIGNON (ASL_COMPILER_NAME));
876             printf (ACPI_COMMON_BUILD_TIME);
877             exit (0);
878 
879         case 'e':
880 
881             /* Disable all warning/remark messages (errors only) */
882 
883             Gbl_DisplayRemarks = FALSE;
884             Gbl_DisplayWarnings = FALSE;
885             break;
886 
887         case 'i':
888             /*
889              * Support for integrated development environment(s).
890              *
891              * 1) No compiler signon
892              * 2) Send stderr messages to stdout
893              * 3) Less verbose error messages (single line only for each)
894              * 4) Error/warning messages are formatted appropriately to
895              *    be recognized by MS Visual Studio
896              */
897             Gbl_VerboseErrors = FALSE;
898             Gbl_DoSignon = FALSE;
899             Gbl_Files[ASL_FILE_STDERR].Handle = stdout;
900             break;
901 
902         case 'o':
903 
904             Gbl_DisplayOptimizations = TRUE;
905             break;
906 
907         case 'r':
908 
909             Gbl_DisplayRemarks = FALSE;
910             break;
911 
912         case 's':
913 
914             Gbl_DoSignon = FALSE;
915             break;
916 
917         case 't':
918 
919             Gbl_VerboseTemplates = TRUE;
920             break;
921 
922         case 'w':
923 
924             /* Get the required argument */
925 
926             if (AcpiGetoptArgument (argc, argv))
927             {
928                 return (-1);
929             }
930 
931             Status = AslDisableException (AcpiGbl_Optarg);
932             if (ACPI_FAILURE (Status))
933             {
934                 return (-1);
935             }
936             break;
937 
938         case 'x':
939 
940             /* Get the required argument */
941 
942             if (AcpiGetoptArgument (argc, argv))
943             {
944                 return (-1);
945             }
946 
947             Status = AslExpectException (AcpiGbl_Optarg);
948             if (ACPI_FAILURE (Status))
949             {
950                 return (-1);
951             }
952             break;
953 
954         default:
955 
956             printf ("Unknown option: -v%s\n", AcpiGbl_Optarg);
957             return (-1);
958         }
959         break;
960 
961     case 'w': /* Set warning levels */
962 
963         switch (AcpiGbl_Optarg[0])
964         {
965         case '1':
966 
967             Gbl_WarningLevel = ASL_WARNING;
968             break;
969 
970         case '2':
971 
972             Gbl_WarningLevel = ASL_WARNING2;
973             break;
974 
975         case '3':
976 
977             Gbl_WarningLevel = ASL_WARNING3;
978             break;
979 
980         case 'e':
981 
982             Gbl_WarningsAsErrors = TRUE;
983             break;
984 
985         default:
986 
987             printf ("Unknown option: -w%s\n", AcpiGbl_Optarg);
988             return (-1);
989         }
990         break;
991 
992     case 'x':   /* Set debug print output level */
993 
994         AcpiDbgLevel = strtoul (AcpiGbl_Optarg, NULL, 16);
995         break;
996 
997     case 'z':
998 
999         Gbl_UseOriginalCompilerId = TRUE;
1000         break;
1001 
1002     default:
1003 
1004         return (-1);
1005     }
1006 
1007     return (0);
1008 }
1009 
1010 
1011 /*******************************************************************************
1012  *
1013  * FUNCTION:    AslMergeOptionTokens
1014  *
1015  * PARAMETERS:  InBuffer            - Input containing an option string
1016  *              OutBuffer           - Merged output buffer
1017  *
1018  * RETURN:      None
1019  *
1020  * DESCRIPTION: Remove all whitespace from an option string.
1021  *
1022  ******************************************************************************/
1023 
1024 static void
AslMergeOptionTokens(char * InBuffer,char * OutBuffer)1025 AslMergeOptionTokens (
1026     char                    *InBuffer,
1027     char                    *OutBuffer)
1028 {
1029     char                    *Token;
1030 
1031 
1032     *OutBuffer = 0;
1033 
1034     Token = strtok (InBuffer, ASL_TOKEN_SEPARATORS);
1035     while (Token)
1036     {
1037         strcat (OutBuffer, Token);
1038         Token = strtok (NULL, ASL_TOKEN_SEPARATORS);
1039     }
1040 }
1041 
1042 
1043 /*******************************************************************************
1044  *
1045  * FUNCTION:    AslDoResponseFile
1046  *
1047  * PARAMETERS:  Filename        - Name of the response file
1048  *
1049  * RETURN:      Status
1050  *
1051  * DESCRIPTION: Open a response file and process all options within.
1052  *
1053  ******************************************************************************/
1054 
1055 static int
AslDoResponseFile(char * Filename)1056 AslDoResponseFile (
1057     char                    *Filename)
1058 {
1059     char                    *argv = StringBuffer2;
1060     FILE                    *ResponseFile;
1061     int                     OptStatus = 0;
1062     int                     Opterr;
1063     int                     Optind;
1064 
1065 
1066     ResponseFile = fopen (Filename, "r");
1067     if (!ResponseFile)
1068     {
1069         printf ("Could not open command file %s, %s\n",
1070             Filename, strerror (errno));
1071         return (-1);
1072     }
1073 
1074     /* Must save the current GetOpt globals */
1075 
1076     Opterr = AcpiGbl_Opterr;
1077     Optind = AcpiGbl_Optind;
1078 
1079     /*
1080      * Process all lines in the response file. There must be one complete
1081      * option per line
1082      */
1083     while (fgets (StringBuffer, ASL_STRING_BUFFER_SIZE, ResponseFile))
1084     {
1085         /* Compress all tokens, allowing us to use a single argv entry */
1086 
1087         AslMergeOptionTokens (StringBuffer, StringBuffer2);
1088 
1089         /* Process the option */
1090 
1091         AcpiGbl_Opterr = 0;
1092         AcpiGbl_Optind = 0;
1093 
1094         OptStatus = AslDoOptions (1, &argv, TRUE);
1095         if (OptStatus)
1096         {
1097             printf ("Invalid option in command file %s: %s\n",
1098                 Filename, StringBuffer);
1099             break;
1100         }
1101     }
1102 
1103     /* Restore the GetOpt globals */
1104 
1105     AcpiGbl_Opterr = Opterr;
1106     AcpiGbl_Optind = Optind;
1107 
1108     fclose (ResponseFile);
1109     return (OptStatus);
1110 }
1111