1 /******************************************************************************
2 *
3 * Module Name: prmacros - Preprocessor #define macro support
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
43
44 #include "aslcompiler.h"
45 #include "dtcompiler.h"
46
47
48 #define _COMPONENT ASL_PREPROCESSOR
49 ACPI_MODULE_NAME ("prmacros")
50
51
52 /*******************************************************************************
53 *
54 * FUNCTION: PrDumpPredefinedNames
55 *
56 * PARAMETERS: None
57 *
58 * RETURN: None
59 *
60 * DESCRIPTION: Dump the list of #defines. Used as the preprocessor starts, to
61 * display the names that were defined on the command line.
62 * Debug information only.
63 *
64 ******************************************************************************/
65
66 void
67 PrDumpPredefinedNames (
68 void)
69 {
70 PR_DEFINE_INFO *DefineInfo;
71
72
73 DefineInfo = Gbl_DefineList;
74 while (DefineInfo)
75 {
76 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
77 "Predefined #define: %s->%s\n",
78 0, DefineInfo->Identifier, DefineInfo->Replacement);
79
80 DefineInfo = DefineInfo->Next;
81 }
82 }
83
84
85 /*******************************************************************************
86 *
87 * FUNCTION: PrAddDefine
88 *
89 * PARAMETERS: Identifier - Name to be replaced
90 * Replacement - Replacement for Identifier
91 * Persist - Keep define across multiple compiles?
92 *
93 * RETURN: A new define_info struct. NULL on error.
94 *
95 * DESCRIPTION: Add a new #define to the global list
96 *
97 ******************************************************************************/
98
99 PR_DEFINE_INFO *
100 PrAddDefine (
101 char *Identifier,
102 char *Replacement,
103 BOOLEAN Persist)
104 {
105 char *IdentifierString;
106 char *ReplacementString;
107 PR_DEFINE_INFO *DefineInfo;
108
109
110 if (!Replacement)
111 {
112 Replacement = "";
113 }
114
115 /* Check for already-defined first */
116
117 DefineInfo = PrMatchDefine (Identifier);
118 if (DefineInfo)
119 {
120 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID,
121 "#define: name already exists: %s\n",
122 Gbl_CurrentLineNumber, Identifier);
123
124 /*
125 * Name already exists. This is only an error if the target name
126 * is different.
127 */
128 if (strcmp (Replacement, DefineInfo->Replacement))
129 {
130 PrError (ASL_ERROR, ASL_MSG_EXISTING_NAME,
131 THIS_TOKEN_OFFSET (Identifier));
132
133 return (NULL);
134 }
135
136 return (DefineInfo);
137 }
138
139 /* Copy input strings */
140
141 IdentifierString = UtLocalCalloc (strlen (Identifier) + 1);
142 strcpy (IdentifierString, Identifier);
143
144 ReplacementString = UtLocalCalloc (strlen (Replacement) + 1);
145 strcpy (ReplacementString, Replacement);
146
147 /* Init and link new define info struct */
148
149 DefineInfo = UtLocalCalloc (sizeof (PR_DEFINE_INFO));
150 DefineInfo->Replacement = ReplacementString;
151 DefineInfo->Identifier = IdentifierString;
152 DefineInfo->Persist = Persist;
153
154 if (Gbl_DefineList)
155 {
156 Gbl_DefineList->Previous = DefineInfo;
157 }
158
159 DefineInfo->Next = Gbl_DefineList;
160 Gbl_DefineList = DefineInfo;
161 return (DefineInfo);
162 }
163
164
165 /*******************************************************************************
166 *
167 * FUNCTION: PrRemoveDefine
168 *
169 * PARAMETERS: DefineName - Name of define to be removed
170 *
171 * RETURN: None
172 *
173 * DESCRIPTION: Implements #undef. Remove a #define if found in the global
174 * list. No error if the target of the #undef does not exist,
175 * as per the C #undef definition.
176 *
177 ******************************************************************************/
178
179 void
180 PrRemoveDefine (
181 char *DefineName)
182 {
183 PR_DEFINE_INFO *DefineInfo;
184
185
186 /* Match name and delete the node */
187
188 DefineInfo = Gbl_DefineList;
189 while (DefineInfo)
190 {
191 if (!strcmp (DefineName, DefineInfo->Identifier))
192 {
193 /* Remove from linked list */
194
195 if (DefineInfo->Previous)
196 {
197 (DefineInfo->Previous)->Next = DefineInfo->Next;
198 }
199 else
200 {
201 Gbl_DefineList = DefineInfo->Next;
202 }
203
204 if (DefineInfo->Next)
205 {
206 (DefineInfo->Next)->Previous = DefineInfo->Previous;
207 }
208
209 free (DefineInfo);
210 return;
211 }
212
213 DefineInfo = DefineInfo->Next;
214 }
215
216 /*
217 * Name was not found. By definition of #undef, this is not
218 * an error, however.
219 */
220 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
221 "#undef: could not find %s\n",
222 Gbl_CurrentLineNumber, DefineName);
223 }
224
225
226 /*******************************************************************************
227 *
228 * FUNCTION: PrMatchDefine
229 *
230 * PARAMETERS: MatchString - Name associated with the #define
231 *
232 * RETURN: Matched string if found. NULL otherwise.
233 *
234 * DESCRIPTION: Find a name in global #define list
235 *
236 ******************************************************************************/
237
238 PR_DEFINE_INFO *
239 PrMatchDefine (
240 char *MatchString)
241 {
242 PR_DEFINE_INFO *DefineInfo;
243
244
245 DefineInfo = Gbl_DefineList;
246 while (DefineInfo)
247 {
248 if (!strcmp (MatchString, DefineInfo->Identifier))
249 {
250 return (DefineInfo);
251 }
252
253 DefineInfo = DefineInfo->Next;
254 }
255
256 return (NULL);
257 }
258
259
260 /*******************************************************************************
261 *
262 * FUNCTION: PrAddMacro
263 *
264 * PARAMETERS: Name - Start of the macro definition
265 * Next - "Next" buffer from GetNextToken
266 *
267 * RETURN: None
268 *
269 * DESCRIPTION: Add a new macro to the list of #defines. Handles argument
270 * processing.
271 *
272 ******************************************************************************/
273
274 void
275 PrAddMacro (
276 char *Name,
277 char **Next)
278 {
279 char *Token = NULL;
280 ACPI_SIZE TokenOffset;
281 ACPI_SIZE MacroBodyOffset;
282 PR_DEFINE_INFO *DefineInfo;
283 PR_MACRO_ARG *Args;
284 char *Body;
285 char *BodyInSource;
286 UINT32 i;
287 UINT16 UseCount = 0;
288 UINT16 ArgCount = 0;
289 UINT32 Depth = 1;
290 UINT32 EndOfArgList;
291 char BufferChar;
292
293
294 /* Find the end of the arguments list */
295
296 TokenOffset = Name - Gbl_MainTokenBuffer + strlen (Name) + 1;
297 while (1)
298 {
299 BufferChar = Gbl_CurrentLineBuffer[TokenOffset];
300 if (BufferChar == '(')
301 {
302 Depth++;
303 }
304 else if (BufferChar == ')')
305 {
306 Depth--;
307 }
308 else if (BufferChar == 0)
309 {
310 PrError (ASL_ERROR, ASL_MSG_MACRO_SYNTAX, TokenOffset);
311 return;
312 }
313
314 if (Depth == 0)
315 {
316 /* Found arg list end */
317
318 EndOfArgList = TokenOffset;
319 break;
320 }
321
322 TokenOffset++;
323 }
324
325 /* At this point, we know that we have a reasonable argument list */
326
327 Args = UtLocalCalloc (sizeof (PR_MACRO_ARG) * PR_MAX_MACRO_ARGS);
328
329 /* Get the macro argument names */
330
331 for (i = 0; i < PR_MAX_MACRO_ARGS; i++)
332 {
333 Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
334 if (!Token)
335 {
336 /* This is the case for a NULL macro body */
337
338 BodyInSource = "";
339 goto AddMacroToList;
340 }
341
342 /* Don't go beyond the argument list */
343
344 TokenOffset = Token - Gbl_MainTokenBuffer + strlen (Token);
345 if (TokenOffset > EndOfArgList)
346 {
347 break;
348 }
349
350 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
351 "Macro arg: %s \n",
352 Gbl_CurrentLineNumber, Token);
353
354 Args[i].Name = UtLocalCalloc (strlen (Token) + 1);
355 strcpy (Args[i].Name, Token);
356
357 Args[i].UseCount = 0;
358
359 ArgCount++;
360 if (ArgCount >= PR_MAX_MACRO_ARGS)
361 {
362 PrError (ASL_ERROR, ASL_MSG_TOO_MANY_ARGUMENTS, TokenOffset);
363 return;
364 }
365 }
366
367 /* Get the macro body. Token now points to start of body */
368
369 MacroBodyOffset = Token - Gbl_MainTokenBuffer;
370
371 /* Match each method arg in the macro body for later use */
372
373 Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
374 while (Token)
375 {
376 /* Search the macro arg list for matching arg */
377
378 for (i = 0; Args[i].Name && (i < PR_MAX_MACRO_ARGS); i++)
379 {
380 /*
381 * Save argument offset within macro body. This is the mechanism
382 * used to expand the macro upon invocation.
383 *
384 * Handles multiple instances of the same argument
385 */
386 if (!strcmp (Token, Args[i].Name))
387 {
388 UseCount = Args[i].UseCount;
389
390 Args[i].Offset[UseCount] = (Token - Gbl_MainTokenBuffer) - MacroBodyOffset;
391
392 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
393 "Macro Arg #%u: %s UseCount %u Offset %u \n",
394 Gbl_CurrentLineNumber, i, Token,
395 UseCount+1, Args[i].Offset[UseCount]);
396
397 Args[i].UseCount++;
398 if (Args[i].UseCount >= PR_MAX_ARG_INSTANCES)
399 {
400 PrError (ASL_ERROR, ASL_MSG_TOO_MANY_ARGUMENTS,
401 THIS_TOKEN_OFFSET (Token));
402
403 return;
404 }
405 break;
406 }
407 }
408
409 Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
410 }
411
412 BodyInSource = &Gbl_CurrentLineBuffer[MacroBodyOffset];
413
414
415 AddMacroToList:
416
417 /* Check if name is already defined first */
418
419 DefineInfo = PrMatchDefine (Name);
420 if (DefineInfo)
421 {
422 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
423 "#define: macro name already exists: %s\n",
424 Gbl_CurrentLineNumber, Name);
425
426 /* Error only if not exactly the same macro */
427
428 if (strcmp (DefineInfo->Body, BodyInSource) ||
429 (DefineInfo->ArgCount != ArgCount))
430 {
431 PrError (ASL_ERROR, ASL_MSG_EXISTING_NAME,
432 THIS_TOKEN_OFFSET (Name));
433 }
434
435 return;
436 }
437
438 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
439 "Macro body: %s \n",
440 Gbl_CurrentLineNumber, BodyInSource);
441
442 /* Add macro to the #define list */
443
444 DefineInfo = PrAddDefine (Name, BodyInSource, FALSE);
445 if (DefineInfo)
446 {
447 Body = UtLocalCalloc (strlen (BodyInSource) + 1);
448 strcpy (Body, BodyInSource);
449
450 DefineInfo->Body = Body;
451 DefineInfo->Args = Args;
452 DefineInfo->ArgCount = ArgCount;
453 }
454 }
455
456
457 /*******************************************************************************
458 *
459 * FUNCTION: PrDoMacroInvocation
460 *
461 * PARAMETERS: TokenBuffer - Current line buffer
462 * MacroStart - Start of the macro invocation within
463 * the token buffer
464 * DefineInfo - Info for this macro
465 * Next - "Next" buffer from GetNextToken
466 *
467 * RETURN: None
468 *
469 * DESCRIPTION: Expand a macro invocation
470 *
471 ******************************************************************************/
472
473 void
474 PrDoMacroInvocation (
475 char *TokenBuffer,
476 char *MacroStart,
477 PR_DEFINE_INFO *DefineInfo,
478 char **Next)
479 {
480 PR_MACRO_ARG *Args;
481 char *Token = NULL;
482 UINT32 TokenOffset;
483 UINT32 Length;
484 UINT32 i;
485
486
487 /* Take a copy of the macro body for expansion */
488
489 strcpy (Gbl_MacroTokenBuffer, DefineInfo->Body);
490
491 /* Replace each argument within the prototype body */
492
493 Args = DefineInfo->Args;
494 if (!Args->Name)
495 {
496 /* This macro has no arguments */
497
498 Token = PrGetNextToken (NULL, PR_MACRO_ARGUMENTS, Next);
499 if (!Token)
500 {
501 goto BadInvocation;
502 }
503
504 TokenOffset = (MacroStart - TokenBuffer);
505 Length = Token - MacroStart + strlen (Token) + 1;
506
507 PrReplaceData (
508 &Gbl_CurrentLineBuffer[TokenOffset], Length,
509 Gbl_MacroTokenBuffer, strlen (Gbl_MacroTokenBuffer));
510 return;
511 }
512
513 while (Args->Name)
514 {
515 /* Get the next argument from macro invocation */
516
517 Token = PrGetNextToken (NULL, PR_MACRO_SEPARATORS, Next);
518 if (!Token)
519 {
520 goto BadInvocation;
521 }
522
523 /* Replace all instances of this argument */
524
525 for (i = 0; i < Args->UseCount; i++)
526 {
527 /* Offset zero indicates "arg not used" */
528 /* TBD: Not really needed now, with UseCount available */
529
530 if (Args->Offset[i] == 0)
531 {
532 break;
533 }
534
535 PrReplaceData (
536 &Gbl_MacroTokenBuffer[Args->Offset[i]], strlen (Args->Name),
537 Token, strlen (Token));
538
539 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
540 "ExpandArg: %s \n",
541 Gbl_CurrentLineNumber, Gbl_MacroTokenBuffer);
542 }
543
544 Args++;
545 }
546
547 /* TBD: need to make sure macro was not invoked with too many arguments */
548
549 if (!Token)
550 {
551 return;
552 }
553
554 /* Replace the entire macro invocation with the expanded macro */
555
556 TokenOffset = (MacroStart - TokenBuffer);
557 Length = Token - MacroStart + strlen (Token) + 1;
558
559 PrReplaceData (
560 &Gbl_CurrentLineBuffer[TokenOffset], Length,
561 Gbl_MacroTokenBuffer, strlen (Gbl_MacroTokenBuffer));
562
563 return;
564
565
566 BadInvocation:
567 PrError (ASL_ERROR, ASL_MSG_INVALID_INVOCATION,
568 THIS_TOKEN_OFFSET (MacroStart));
569
570 DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
571 "Bad macro invocation: %s \n",
572 Gbl_CurrentLineNumber, Gbl_MacroTokenBuffer);
573 return;
574 }