xref: /freebsd/sys/contrib/dev/acpica/compiler/prmacros.c (revision 722b16673c40aedf280895f2f2f676bb494518d7)
1 /******************************************************************************
2  *
3  * Module Name: prmacros - Preprocessor #define macro support
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2023, 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 
154 #define _COMPONENT          ASL_PREPROCESSOR
155         ACPI_MODULE_NAME    ("prmacros")
156 
157 
158 /*******************************************************************************
159  *
160  * FUNCTION:    PrDumpPredefinedNames
161  *
162  * PARAMETERS:  None
163  *
164  * RETURN:      None
165  *
166  * DESCRIPTION: Dump the list of #defines. Used as the preprocessor starts, to
167  *              display the names that were defined on the command line.
168  *              Debug information only.
169  *
170  ******************************************************************************/
171 
172 void
PrDumpPredefinedNames(void)173 PrDumpPredefinedNames (
174     void)
175 {
176     PR_DEFINE_INFO          *DefineInfo;
177 
178 
179     DefineInfo = AslGbl_DefineList;
180     while (DefineInfo)
181     {
182         DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
183             "Predefined #define: %s->%s\n",
184             0, DefineInfo->Identifier, DefineInfo->Replacement);
185 
186         DefineInfo = DefineInfo->Next;
187     }
188 }
189 
190 
191 /*******************************************************************************
192  *
193  * FUNCTION:    PrAddDefine
194  *
195  * PARAMETERS:  Identifier          - Name to be replaced
196  *              Replacement         - Replacement for Identifier
197  *              Persist             - Keep define across multiple compiles?
198  *
199  * RETURN:      A new define_info struct. NULL on error.
200  *
201  * DESCRIPTION: Add a new #define to the global list
202  *
203  ******************************************************************************/
204 
205 PR_DEFINE_INFO *
PrAddDefine(char * Identifier,char * Replacement,BOOLEAN Persist)206 PrAddDefine (
207     char                    *Identifier,
208     char                    *Replacement,
209     BOOLEAN                 Persist)
210 {
211     char                    *IdentifierString;
212     char                    *ReplacementString;
213     PR_DEFINE_INFO          *DefineInfo;
214 
215 
216     if (!Replacement)
217     {
218         Replacement = "";
219     }
220 
221     /* Check for already-defined first */
222 
223     DefineInfo = PrMatchDefine (Identifier);
224     if (DefineInfo)
225     {
226         DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
227             "#define: name already exists: %s\n",
228             AslGbl_CurrentLineNumber, Identifier);
229 
230         /*
231          * Name already exists. This is only an error if the target name
232          * is different.
233          */
234         if (strcmp (Replacement, DefineInfo->Replacement))
235         {
236             PrError (ASL_ERROR, ASL_MSG_EXISTING_NAME,
237                 THIS_TOKEN_OFFSET (Identifier));
238 
239             return (NULL);
240         }
241 
242         return (DefineInfo);
243     }
244 
245     /* Copy input strings */
246 
247     IdentifierString = UtLocalCalloc (strlen (Identifier) + 1);
248     strcpy (IdentifierString, Identifier);
249 
250     ReplacementString = UtLocalCalloc (strlen (Replacement) + 1);
251     strcpy (ReplacementString, Replacement);
252 
253     /* Init and link new define info struct */
254 
255     DefineInfo = UtLocalCalloc (sizeof (PR_DEFINE_INFO));
256     DefineInfo->Replacement = ReplacementString;
257     DefineInfo->Identifier = IdentifierString;
258     DefineInfo->Persist = Persist;
259 
260     if (AslGbl_DefineList)
261     {
262         AslGbl_DefineList->Previous = DefineInfo;
263     }
264 
265     DefineInfo->Next = AslGbl_DefineList;
266     AslGbl_DefineList = DefineInfo;
267     return (DefineInfo);
268 }
269 
270 
271 /*******************************************************************************
272  *
273  * FUNCTION:    PrRemoveDefine
274  *
275  * PARAMETERS:  DefineName          - Name of define to be removed
276  *
277  * RETURN:      None
278  *
279  * DESCRIPTION: Implements #undef. Remove a #define if found in the global
280  *              list. No error if the target of the #undef does not exist,
281  *              as per the C #undef definition.
282  *
283  ******************************************************************************/
284 
285 void
PrRemoveDefine(char * DefineName)286 PrRemoveDefine (
287     char                    *DefineName)
288 {
289     PR_DEFINE_INFO          *DefineInfo;
290 
291 
292     /* Match name and delete the node */
293 
294     DefineInfo = AslGbl_DefineList;
295     while (DefineInfo)
296     {
297         if (!strcmp (DefineName, DefineInfo->Identifier))
298         {
299             /* Remove from linked list */
300 
301             if (DefineInfo->Previous)
302             {
303                 (DefineInfo->Previous)->Next = DefineInfo->Next;
304             }
305             else
306             {
307                 AslGbl_DefineList = DefineInfo->Next;
308             }
309 
310             if (DefineInfo->Next)
311             {
312                 (DefineInfo->Next)->Previous = DefineInfo->Previous;
313             }
314 
315             free (DefineInfo);
316             return;
317         }
318 
319         DefineInfo = DefineInfo->Next;
320     }
321 
322     /*
323      * Name was not found. By definition of #undef, this is not
324      * an error, however.
325      */
326     DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
327         "#undef: could not find %s\n",
328         AslGbl_CurrentLineNumber, DefineName);
329 }
330 
331 
332 /*******************************************************************************
333  *
334  * FUNCTION:    PrMatchDefine
335  *
336  * PARAMETERS:  MatchString         - Name associated with the #define
337  *
338  * RETURN:      Matched string if found. NULL otherwise.
339  *
340  * DESCRIPTION: Find a name in global #define list
341  *
342  ******************************************************************************/
343 
344 PR_DEFINE_INFO *
PrMatchDefine(char * MatchString)345 PrMatchDefine (
346     char                    *MatchString)
347 {
348     PR_DEFINE_INFO          *DefineInfo;
349 
350 
351     DefineInfo = AslGbl_DefineList;
352     while (DefineInfo)
353     {
354         if (!strcmp (MatchString, DefineInfo->Identifier))
355         {
356             return (DefineInfo);
357         }
358 
359         DefineInfo = DefineInfo->Next;
360     }
361 
362     return (NULL);
363 }
364 
365 
366 /*******************************************************************************
367  *
368  * FUNCTION:    PrAddMacro
369  *
370  * PARAMETERS:  Name                - Start of the macro definition
371  *              Next                - "Next" buffer from GetNextToken
372  *
373  * RETURN:      None
374  *
375  * DESCRIPTION: Add a new macro to the list of #defines. Handles argument
376  *              processing.
377  *
378  ******************************************************************************/
379 
380 void
PrAddMacro(char * Name,char ** Next)381 PrAddMacro (
382     char                    *Name,
383     char                    **Next)
384 {
385     char                    *Token = NULL;
386     ACPI_SIZE               TokenOffset;
387     ACPI_SIZE               MacroBodyOffset;
388     PR_DEFINE_INFO          *DefineInfo;
389     PR_MACRO_ARG            *Args;
390     char                    *Body;
391     char                    *BodyInSource;
392     UINT32                  i;
393     UINT16                  UseCount = 0;
394     UINT16                  ArgCount = 0;
395     UINT32                  Depth = 1;
396     /*UINT32                  Depth = 1;*/
397     UINT32                  EndOfArgList;
398     char                    BufferChar;
399 
400     /* Find the end of the arguments list */
401 
402     TokenOffset = Name - AslGbl_MainTokenBuffer + strlen (Name) + 1;
403     while (1)
404     {
405         BufferChar = AslGbl_CurrentLineBuffer[TokenOffset];
406         if (BufferChar == '(')
407         {
408             Depth++;
409         }
410         else if (BufferChar == ')')
411         {
412             Depth--;
413         }
414         else if (BufferChar == 0)
415         {
416             PrError (ASL_ERROR, ASL_MSG_MACRO_SYNTAX, TokenOffset);
417             return;
418         }
419 
420         if (Depth == 0)
421         {
422             /* Found arg list end */
423 
424             EndOfArgList = TokenOffset;
425             break;
426         }
427 
428         TokenOffset++;
429     }
430 
431     /* At this point, we know that we have a reasonable argument list */
432 
433     Args = UtLocalCalloc (sizeof (PR_MACRO_ARG) * PR_MAX_MACRO_ARGS);
434 
435     /* Get the macro argument names */
436 
437     for (i = 0; i < PR_MAX_MACRO_ARGS; i++)
438     {
439         Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
440 
441         if (!Token)
442         {
443             /* This is the case for a NULL macro body */
444 
445             BodyInSource = "";
446             goto AddMacroToList;
447         }
448 
449         /* Don't go beyond the argument list */
450 
451         TokenOffset = Token - AslGbl_MainTokenBuffer + strlen (Token);
452         if (TokenOffset > EndOfArgList)
453         {
454             break;
455         }
456 
457         DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
458             "Macro param: %s \n",
459             AslGbl_CurrentLineNumber, Token);
460 
461         Args[i].Name = UtLocalCalloc (strlen (Token) + 1);
462         strcpy (Args[i].Name, Token);
463 
464         Args[i].UseCount = 0;
465         ArgCount++;
466         if (ArgCount >= PR_MAX_MACRO_ARGS)
467         {
468             PrError (ASL_ERROR, ASL_MSG_TOO_MANY_ARGUMENTS, TokenOffset);
469             goto ErrorExit;
470         }
471     }
472 
473     /* Get the macro body. Token now points to start of body */
474 
475     MacroBodyOffset = Token - AslGbl_MainTokenBuffer;
476 
477     /* Match each method arg in the macro body for later use */
478 
479     while (Token)
480     {
481         /* Search the macro arg list for matching arg */
482 
483         for (i = 0; ((i < PR_MAX_MACRO_ARGS) && Args[i].Name); i++)
484         {
485             /*
486              * Save argument offset within macro body. This is the mechanism
487              * used to expand the macro upon invocation.
488              *
489              * Handles multiple instances of the same argument
490              */
491             if (!strcmp (Token, Args[i].Name))
492             {
493                 UseCount = Args[i].UseCount;
494 
495                 Args[i].Offset[UseCount] =
496                     (Token - AslGbl_MainTokenBuffer) - MacroBodyOffset;
497 
498 
499                 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
500                     "Macro Arg #%u: %s UseCount %u Offset %u \n",
501                     AslGbl_CurrentLineNumber, i, Token,
502                     UseCount+1, Args[i].Offset[UseCount]);
503 
504                 Args[i].UseCount++;
505 
506                 if (Args[i].UseCount >= PR_MAX_ARG_INSTANCES)
507                 {
508                     PrError (ASL_ERROR, ASL_MSG_TOO_MANY_ARGUMENTS,
509                         THIS_TOKEN_OFFSET (Token));
510 
511                     goto ErrorExit;
512                 }
513                 break;
514             }
515         }
516 
517         Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
518     }
519 
520     BodyInSource = &AslGbl_CurrentLineBuffer[MacroBodyOffset];
521 
522 
523 AddMacroToList:
524 
525     /* Check if name is already defined first */
526 
527     DefineInfo = PrMatchDefine (Name);
528     if (DefineInfo)
529     {
530         DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
531             "#define: macro name already exists: %s\n",
532             AslGbl_CurrentLineNumber, Name);
533 
534         /* Error only if not exactly the same macro */
535 
536         if (strcmp (DefineInfo->Body, BodyInSource) ||
537             (DefineInfo->ArgCount != ArgCount))
538         {
539             PrError (ASL_ERROR, ASL_MSG_EXISTING_NAME,
540                 THIS_TOKEN_OFFSET (Name));
541         }
542 
543         goto ErrorExit;
544     }
545 
546     DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
547         "Macro body: %s \n",
548         AslGbl_CurrentLineNumber, BodyInSource);
549 
550     /* Add macro to the #define list */
551 
552     DefineInfo = PrAddDefine (Name, BodyInSource, FALSE);
553     if (DefineInfo)
554     {
555         Body = UtLocalCalloc (strlen (BodyInSource) + 1);
556         strcpy (Body, BodyInSource);
557 
558         DefineInfo->Body = Body;
559         DefineInfo->Args = Args;
560         DefineInfo->ArgCount = ArgCount;
561     }
562 
563     return;
564 
565 
566 ErrorExit:
567     ACPI_FREE (Args);
568     return;
569 }
570 
571 
572 /*******************************************************************************
573  *
574  * FUNCTION:    PrDoMacroInvocation
575  *
576  * PARAMETERS:  TokenBuffer         - Current line buffer
577  *              MacroStart          - Start of the macro invocation within
578  *                                    the token buffer
579  *              DefineInfo          - Info for this macro
580  *              Next                - "Next" buffer from GetNextToken
581  *
582  * RETURN:      None
583  *
584  * DESCRIPTION: Expand a macro invocation
585  *
586  ******************************************************************************/
587 
588 void
PrDoMacroInvocation(char * TokenBuffer,char * MacroStart,PR_DEFINE_INFO * DefineInfo,char ** Next)589 PrDoMacroInvocation (
590     char                    *TokenBuffer,
591     char                    *MacroStart,
592     PR_DEFINE_INFO          *DefineInfo,
593     char                    **Next)
594 {
595     PR_MACRO_ARG            *Args;
596     char                    *Token = NULL;
597     UINT32                  TokenOffset;
598     UINT32                  Length;
599     UINT32                  i;
600     UINT32                  Diff1;
601     UINT32                  Diff2;
602 
603     /* Take a copy of the macro body for expansion */
604 
605     strcpy (AslGbl_MacroTokenBuffer, DefineInfo->Body);
606 
607     /* Replace each argument within the prototype body */
608 
609     Args = DefineInfo->Args;
610     if (!Args->Name)
611     {
612         /* This macro has no arguments */
613 
614         Token = PrGetNextToken (NULL, PR_MACRO_ARGUMENTS, Next);
615 
616         if (!Token)
617         {
618             goto BadInvocation;
619         }
620 
621         TokenOffset = (MacroStart - TokenBuffer);
622         Length = Token - MacroStart + strlen (Token) + 1;
623 
624         PrReplaceData (
625             &AslGbl_CurrentLineBuffer[TokenOffset], Length,
626             AslGbl_MacroTokenBuffer, strlen (AslGbl_MacroTokenBuffer));
627         return;
628     }
629 
630     while (Args->Name)
631     {
632         /* Get the next argument from macro invocation */
633 
634         Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
635         if (!Token)
636         {
637             goto BadInvocation;
638         }
639 
640         /*
641          * Avoid optimizing using just 1 signed int due to specific
642          * non-portable implementations of signed ints
643          */
644         Diff1 = strlen (Args->Name) > strlen (Token) ? strlen (Args->Name) -
645             strlen (Token) : 0;
646 
647         Diff2 = strlen (Args->Name) < strlen (Token) ? strlen (Token) -
648             strlen (Args->Name) : 0;
649 
650         /* Replace all instances of this argument */
651 
652         for (i = 0; i < Args->UseCount; i++)
653         {
654             /*
655              * To test the output of the preprocessed macro function that
656              * is passed to the compiler
657              */
658 
659              /*
660               * fprintf (stderr, "Current token = %s \t Current arg_name = %s \
661               * \t strlen (Token) = %u \t strlen (Args->Name) = %u \t Offset = %u \
662               * \t UseCount = %u \t", Token, Args->Name, strlen (Token), \
663               *     strlen (Args->Name), Args->Offset[i], Args->UseCount);
664               */
665 
666             AslGbl_MacroTokenReplaceBuffer = (char *) calloc ((strlen (AslGbl_MacroTokenBuffer)), sizeof (char));
667 
668             PrReplaceResizeSubstring (Args, Diff1, Diff2, i, Token);
669 
670             DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
671                 "ExpandArg: %s \n",
672                 AslGbl_CurrentLineNumber, AslGbl_MacroTokenBuffer);
673         }
674 
675         Args++;
676     }
677 
678     if (!Token)
679     {
680         return;
681     }
682 
683     /* Replace the entire macro invocation with the expanded macro */
684 
685     TokenOffset = (MacroStart - TokenBuffer);
686     Length = Token - MacroStart + strlen (Token) + 1;
687 
688     PrReplaceData (
689         &AslGbl_CurrentLineBuffer[TokenOffset], Length,
690         AslGbl_MacroTokenBuffer, strlen (AslGbl_MacroTokenBuffer));
691 
692     return;
693 
694 BadInvocation:
695     PrError (ASL_ERROR, ASL_MSG_INVALID_INVOCATION,
696         THIS_TOKEN_OFFSET (MacroStart));
697 
698     DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
699         "Bad macro invocation: %s \n",
700         AslGbl_CurrentLineNumber, AslGbl_MacroTokenBuffer);
701     return;
702 }
703