Studying note of GCC-3.4.6 source (72)

最新推荐文章于 2021-08-30 23:18:00 发布

wuhui_gdnt

最新推荐文章于 2021-08-30 23:18:00 发布

阅读量1k

点赞数

分类专栏： Studying note of GCC-3.4.6 source 文章标签： macros constants struct token whitespace deprecated

本文链接：https://blog.csdn.net/wuhui_gdnt/article/details/5784807

版权

Studying note of GCC-3.4.6 source 专栏收录该内容

202 篇文章 1 订阅

订阅专栏

5.1.2. C builtin macros

Below flag_undef is 0 by default, but it can be revised by option –undef, which if is nonzero, means do not predefine any system-specific or GCC-specific macros, but still predefine the standard predefined macros (i.e, macros defined in builtin_array).

295 void

296 c_cpp_builtins (cpp_reader *pfile) in c-cppbuiltin.c

297 {

298 /* -undef turns off target-specific built-ins. */

299 if (flag_undef)

300 return;

301

302 define__GNUC__ ();

5.1.2.1. Macros of GUNC family

In GCC, predefined macro __GNUC__ is always defined as the major version number of the compiler. For example, if the compiler version number is 3.4.6, this macro is defined as 3; while __GNUC_MINOR__, __GNUC_PATCHLEVEL__ are defined as 4 and 6 respectively. Further macro __GNUG__ is similar with __GNC__ but for C++. define__GNUC__ defines these macros from version_string which saves the version literal string.

252 static void

253 define__GNUC__ (void) in c-cppbuiltin.c

254 {

255 /* The format of the version string, enforced below, is

256 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */

257 const char *q, *v = version_string;

258

259 while (*v && ! ISDIGIT (*v))

260 v++;

261 if (!*v || (v > version_string && v[-1] != '-'))

262 abort ();

263

264 q = v;

265 while (ISDIGIT (*v))

266 v++;

267 builtin_define_with_value_n ("__GNUC__", q, v - q);

268 if (c_dialect_cxx ())

269 builtin_define_with_value_n ("__GNUG__", q, v - q);

270

271 if (*v != '.' || !ISDIGIT (v[1]))

272 abort ();

273 q = ++v;

274 while (ISDIGIT (*v))

275 v++;

276 builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);

277

278 if (*v == '.')

279 {

280 if (!ISDIGIT (v[1]))

281 abort ();

282 q = ++v;

283 while (ISDIGIT (*v))

284 v++;

285 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);

286 }

287 else

288 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);

289

290 if (*v && *v != ' ' && *v != '-')

291 abort ();

292 }

builtin_define_with_value_n will combine arguments macro and expansion to form definition pair and pass it to cpp_define.

492 static void

493 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)

494 {

495 char *buf;

496 size_t mlen = strlen (macro);

497

498 /* Space for an = and a NUL. */

499 buf = alloca (mlen + elen + 2);

500 memcpy (buf, macro, mlen);

501 buf[mlen] = '=';

502 memcpy (buf + mlen + 1, expansion, elen);

503 buf[mlen + elen + 1] = '/0';

504

505 cpp_define (parse_in, buf);

506 }

cpp_define also handles command line defined macros, which has form of m=val or m. For former ones, it needs be transformed into m val, and for rear ones, should be m 1. Then this regular form can be handled by run_directive which we have seen above.

1804 void

1805 cpp_define (cpp_reader *pfile, const char *str) in cpplib.c

1806 {

1807 char *buf, *p;

1808 size_t count;

1809

1810 /* Copy the entire option so we can modify it.

1811 Change the first "=" in the string to a space. If there is none,

1812 tack " 1" on the end. */

1813

1814 count = strlen (str);

1815 buf = alloca (count + 3);

1816 memcpy (buf, str, count);

1817

1818 p = strchr (str, '=');

1819 if (p)

1820 buf[p - str] = ' ';

1821 else

1822 {

1823 buf[count++] = ' ';

1824 buf[count++] = '1';

1825 }

1826 buf[count] = '/n';

1827

1828 run_directive (pfile, T_DEFINE, buf, count);

1829 }

5.1.2.2. Macros in stddef.h

C++ defines some predefined macros in system header file stddef.h. They are size_t, ptrdiff_t, wchar, and wint. c_stddef_cpp_builtins helps to create the related objects for these macros.

c_cpp_builtins (continue)

304 /* For stddef.h. They require macros defined in c-common.c. */

305 c_stddef_cpp_builtins ();

In below invocations, the second parameters, like SIZE_TYPE, are target related, and they are literal strings standing for specified type.

4249 void

4250 c_stddef_cpp_builtins(void) in c-common.c

4251 {

4252 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);

4253 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);

4254 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);

4255 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);

4256 }

See that builtin_define_with_value puts macro and expansion tegother into macro=expansion, however in cpp_define, we have seen, the expression will be transformed into macro expansion and run_directive is invoked.

470 void

471 builtin_define_with_value (const char *macro, const char *expansion, int is_str)

472 {

473 char *buf;

474 size_t mlen = strlen (macro);

475 size_t elen = strlen (expansion);

476 size_t extra = 2; /* space for an = and a NUL */

477

478 if (is_str)

479 extra += 2; /* space for two quote marks */

480

481 buf = alloca (mlen + elen + extra);

482 if (is_str)

483 sprintf (buf, "%s=/"%s/"", macro, expansion);

484 else

485 sprintf (buf, "%s=%s", macro, expansion);

486

487 cpp_define (parse_in, buf);

488 }

Following are controlling macros, they describe the characteristics about the compiler, and the target machine.

5.1.2.3. Control macros for language

The compiler needs some macros to describe the characteristics of the language. Then in our program, we can use them to select the matching definition, and make specific handling.

c_cpp_builtins (continue)

307 if (c_dialect_cxx ())

308 {

309 if (SUPPORTS_ONE_ONLY)

310 cpp_define (pfile, "__GXX_WEAK__=1");

311 else

312 cpp_define (pfile, "__GXX_WEAK__=0");

313 if (warn_deprecated)

314 cpp_define (pfile, "__DEPRECATED");

315 }

316 /* Note that we define this for C as well, so that we know if

317 __attribute__((cleanup)) will interface with EH. */

318 if (flag_exceptions)

319 cpp_define (pfile, "__EXCEPTIONS");

320

321 /* Represents the C++ ABI version, always defined so it can be used while

322 preprocessing C and assembler. */

323 if (flag_abi_version == 0)

324 /* Use a very large value so that:

325

326 #if __GXX_ABI_VERSION >= <value for version X>

327

328 will work whether the user explicitly says "-fabi-version=x" or

329 "-fabi-version=0". Do not use INT_MAX because that will be

330 different from system to system. */

331 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);

332 else if (flag_abi_version == 1)

333 /* Due to an historical accident, this version had the value

334 "102". */

335 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);

336 else

337 /* Newer versions have values 1002, 1003, .... */

338 builtin_define_with_int_value ("__GXX_ABI_VERSION",

339 1000 + flag_abi_version);

340

341 /* libgcc needs to know this. */

342 if (USING_SJLJ_EXCEPTIONS)

343 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");

5.1.2.4. Macros for fundmental types characteristics

The characteristics of fundmental types can be gotten with below macros. They exist to make the standard header given numerical limits work correctly. Below TARGET_FLT_EVAL_METHOD is a C expression for the value for FLT_EVAL_METHOD in float.h, which stands for the floating-point expression evaluation method, and its value,

if -1, indeterminate.

if 0, evaluate all operations and constants just to the range and precision of the type.

if 1, evaluate operations and constants of type float and double to the range and precision of the double type, evaluate long double operations and constants to the range and precision of the long double type.

if 2, evaluate all operations and constants to the range and precision of the long double type. For x86, the macro has below definition:

747 #define TARGET_FLT_EVAL_METHOD / in i386.h

748 (TARGET_MIX_SSE_I387 ? -1 : TARGET_SSE_MATH ? 0 : 2)

TARGET_MIX_SSE_I387 is set by option “-mfpmath=sse,387” which means utilize both the standard 387 floating point coprocessor and scalar floating point instructions present in the SSE instruction set, and results in indeterminate. And TARGET_SSE_MATH is set by “-mfpmath=sse” which just means using scalar floating point instructions present in the SSE instruction set. While by default, x86 uses 387 coprocessor, in which the temporary results are computed in 80bit precision instead of precision specified by the type resulting.

c_cpp_builtins (continue)

345 /* limits.h needs to know these. */

346 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);

347 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);

348 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);

349 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);

350 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);

351 builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);

352

353 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);

354

355 /* float.h needs to know these. */

356

357 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",

358 TARGET_FLT_EVAL_METHOD);

359

360 builtin_define_float_constants ("FLT", "F", float_type_node);

361 builtin_define_float_constants ("DBL", "", double_type_node);

362 builtin_define_float_constants ("LDBL", "L", long_double_type_node);

363

364 /* For use in assembly language. */

365 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);

366 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);

367

368 /* Misc. */

369 builtin_define_with_value ("__VERSION__", version_string, 1);

370

371 /* Definitions for LP64 model. */

372 if (TYPE_PRECISION (long_integer_type_node) == 64

373 && POINTER_SIZE == 64

374 && TYPE_PRECISION (integer_type_node) == 32)

375 {

376 cpp_define (pfile, "_LP64");

377 cpp_define (pfile, "__LP64__");

378 }

In section Convert to real mode, we see that GCC supports IEEE floating point standard. Now GCC outputs the data of the IEEE floating point standard into predefined macros by builtin_define_float_constants. This function is quite simple, we skip it here.

At line 365, REGISTER_PREFIX is the macro expanding to a single token (not a string constant) which is the prefix applied to register names in assembly language for this target. You can use it to write assembly that is usable in multiple environments. For example, in the `m68k-aout' environment it expands to nothing, but in the `m68k-coff' environment it expands to a single `%'. While __USER_LABEL_PREFIX__ is the macro expanding to a single token which is the prefix applied to user labels (symbols visible to C code) in assembly. For example, in the `m68k-aout' environment it expands to an `_', but in the `m68k-coff' environment it expands to nothing.

5.1.2.5. Control macros for compiler

This part of macros reveal some behavor of the compiler. And these macros cause certain GNU header files to provide optimized definitions, using macros or inline functions, of system library functions.

c_cpp_builtins (continue)

380 /* Other target-independent built-ins determined by command-line

381 options. */

382 if (optimize_size)

383 cpp_define (pfile, "__OPTIMIZE_SIZE__");

384 if (optimize)

385 cpp_define (pfile, "__OPTIMIZE__");

386

387 if (fast_math_flags_set_p ())

388 cpp_define (pfile, "__FAST_MATH__");

389 if (flag_really_no_inline)

390 cpp_define (pfile, "__NO_INLINE__");

391 if (flag_signaling_nans)

392 cpp_define (pfile, "__SUPPORT_SNAN__");

393 if (flag_finite_math_only)

394 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");

395 else

396 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");

397

398 if (flag_iso)

399 cpp_define (pfile, "__STRICT_ANSI__");

400

401 if (!flag_signed_char)

402 cpp_define (pfile, "__CHAR_UNSIGNED__");

403

404 if (c_dialect_cxx () && TREE_UNSIGNED (wchar_type_node))

405 cpp_define (pfile, "__WCHAR_UNSIGNED__");

406

407 /* Make the choice of ObjC runtime visible to source code. */

408 if (c_dialect_objc () && flag_next_runtime)

409 cpp_define (pfile, "__NEXT_RUNTIME__");

5.1.2.6. Control macros for target

The C preprocessor normally predefines several macros that indicate what type of system and machine is in use. They are obviously different on each target supported by GCC. All system-specific predefined macros expand to the constant 1, so you can test them with either `#ifdef' or `#if'.

c_cpp_builtins (continue)

411 /* A straightforward target hook doesn't work, because of problems

412 linking that hook's body when part of non-C front ends. */

413 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)

414 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)

415 # define builtin_define(TXT) cpp_define (pfile, TXT)

416 # define builtin_assert(TXT) cpp_assert (pfile, TXT)

417 TARGET_CPU_CPP_BUILTINS ();

418 TARGET_OS_CPP_BUILTINS ();

419 TARGET_OBJFMT_CPP_BUILTINS ();

420 }

The first series macros record information of CPU. Take x86 for example, if the target machine using PentiumPro chip, then TARGET_CPU_CPP_BUILTINS will define following macros. Note that builtin_define is defined as cpp_define.

548 #define TARGET_CPU_CPP_BUILTINS() / in i386.h

549 do /

550 { /

…

654 else if (ix86_arch == PROCESSOR_PENTIUMPRO) /

655 { /

656 builtin_define ("__i686"); /

657 builtin_define ("__i686__"); /

658 builtin_define ("__pentiumpro"); /

659 builtin_define ("__pentiumpro__"); /

660 } /

…

689 } /

690 while (0)

Following are macros describe language features related to target machine. We take Linux OS as the example. Linux support PIC (position independent code) which can be open or closed by GCC command line option, and defines __pic__ and __PIC__ (both have the same meaning) when GCC agrees. Note that to x86/Linux whether flag_pic is 1 (“small” pic) or 2 (“large” pic), there is no difference.

73 #define TARGET_OS_CPP_BUILTINS() / in linux.h

74 do /

75 { /

76 LINUX_TARGET_OS_CPP_BUILTINS(); /

77 if (flag_pic) /

78 { /

79 builtin_define ("__PIC__"); /

80 builtin_define ("__pic__"); /

81 } /

82 } /

83 while (0)

Every target OS needs engrave its formal name with corresponding macros. For Linux, it does define below macros.

100 #define LINUX_TARGET_OS_CPP_BUILTINS() / in linux.h

101 do { /

102 builtin_define ("__gnu_linux__"); /

103 builtin_define_std ("linux"); /

104 builtin_define_std ("unix"); /

105 builtin_assert ("system=linux"); /

106 builtin_assert ("system=unix"); /

107 builtin_assert ("system=posix"); /

108 } while (0)

Routine builtin_define_std is interesting and worthes a look. C/C++ requires that all system-specific macros be part of the "reserved namespace". All names begin with “__” or “_” and a capital letter, are reserved for the compiler and library to use as they wish. However, historically system-specific macros have had names with no special prefix; for instance, it is common to find `unix' defined on Unix systems. For all such macros, GCC provides a parallel macro with two underscores added at the beginning and the end. If `unix' is defined, `__unix__' will be defined too.

431 void

432 builtin_define_std (const char *macro) in c-cppbuiltin.c

433 {

434 size_t len = strlen (macro);

435 char *buff = alloca (len + 5);

436 char *p = buff + 2;

437 char *q = p + len;

438

439 /* prepend __ (or maybe just _) if in user's namespace. */

440 memcpy (p, macro, len + 1);

441 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))

442 {

443 if (*p != '_')

444 *--p = '_';

445 if (p[1] != '_')

446 *--p = '_';

447 }

448 cpp_define (parse_in, p);

449

450 /* If it was in user's namespace... */

451 if (p != buff + 2)

452 {

453 /* Define the macro with leading and following __. */

454 if (q[-1] != '_')

455 *q++ = '_';

456 if (q[-2] != '_')

457 *q++ = '_';

458 *q = '/0';

459 cpp_define (parse_in, p);

460

461 /* Finally, define the original macro if permitted. */

462 if (!flag_iso)

463 cpp_define (parse_in, macro);

464 }

465 }

Besides defining macros about the target OS, we also need prepare the answer for the possible assertions in system header files. In [13] the detail of assertion is given below:

"Assertions" are a deprecated alternative to macros in writing conditionals to test what sort of computer or system the compiled program will run on. Assertions are usually predefined, but you can define them with preprocessing directives or command-line options.

Assertions were intended to provide a more systematic way to describe the compiler's target system. However, in practice they are just as unpredictable as the system-specific predefined macros. In addition, they are not part of any standard, and only a few compilers support them. Therefore, the use of assertions is *less* portable than the use of system-specific predefined macros. We recommend you do not use them at all.

An assertion looks like this:

#PREDICATE (ANSWER)

PREDICATE must be a single identifier. ANSWER can be any sequence of tokens; all characters are significant except for leading and trailing whitespace, and differences in internal whitespace sequences are ignored. (This is similar to the rules governing macro redefinition.) Thus, `(x + y)' is different from `(x+y)' but equivalent to `( x + y )'. Parentheses do not nest inside an answer.

To test an assertion, you write it in an `#if'. For example, this conditional succeeds if either `vax' or `ns16000' has been asserted as an answer for `machine'.

#if #machine (vax) || #machine (ns16000)

You can test whether _any_ answer is asserted for a predicate by omitting the answer in the conditional:

#if #machine

Assertions are made with the `#assert' directive. Its sole argument is the assertion to make, without the leading `#' that identifies assertions in conditionals.

#assert PREDICATE (ANSWER)

You may make several assertions with the same predicate and different answers. Subsequent assertions do not override previous ones for the same predicate. All the answers for any given predicate are simultaneously true.

Assertions can be canceled with the `#unassert' directive. It has the same syntax as `#assert'. In that form it cancels only the answer which was specified on the `#unassert' line; other answers for that predicate remain true. You can cancel an entire predicate by leaving out the answer:

#unassert PREDICATE

In either form, if no such assertion has been made, `#unassert' has no effect.

1854 void

1855 cpp_assert (cpp_reader *pfile, const char *str) in cpplib.c

1856 {

1857 handle_assertion (pfile, str, T_ASSERT);

1858 }

In [10], the documented usage of assertion is #assert PRED=ANS. Then handle_assertion helps to converse the form into #assert PRED(ANS).

1868 static void

1869 handle_assertion (cpp_reader *pfile, const char *str, int type) in cpplib.c

1870 {

1871 size_t count = strlen (str);

1872 const char *p = strchr (str, '=');

1873

1874 /* Copy the entire option so we can modify it. Change the first

1875 "=" in the string to a '(', and tack a ')' on the end. */

1876 char *buf = alloca (count + 2);

1877

1878 memcpy (buf, str, count);

1879 if (p)

1880 {

1881 buf[p - str] = '(';

1882 buf[count++] = ')';

1883 }

1884 buf[count] = '/n';

1885 str = buf;

1886

1887 run_directive (pfile, type, str, count);

1888 }

The registered handle for assertion is do_assert which is invoked by run_directive.

1733 static void

1734 do_assert (cpp_reader *pfile) in cpplib.c

1735 {

1736 struct answer *new_answer;

1737 cpp_hashnode *node;

1738

1739 node = parse_assertion (pfile, &new_answer, T_ASSERT);

1740 if (node)

1741 {

1742 /* Place the new answer in the answer list. First check there

1743 is not a duplicate. */

1744 new_answer->next = 0;

1745 if (node->type == NT_ASSERTION)

1746 {

1747 if (*find_answer (node, new_answer))

1748 {

1749 cpp_error (pfile, CPP_DL_WARNING, "/"%s/" re-asserted",

1750 NODE_NAME (node) + 1);

1751 return;

1752 }

1753 new_answer->next = node->value.answers;

1754 }

1755

1756 node->type = NT_ASSERTION;

1757 node->value.answers = new_answer;

1758 BUFF_FRONT (pfile->a_buff) += (sizeof (struct answer)

1759 + (new_answer->count - 1)

1760 * sizeof (cpp_token));

1761 check_eol (pfile);

1762 }

1763 }

As part of cpp_hashnode, answer has following definition. Below the slot first is designed as variable length array, in which records tokens for the answer.

29 struct answer in cpplib.c

30 {

31 struct answer *next;

32 unsigned int count;

33 cpp_token first[1];

34 };

Notice that tokens in answer can’t be expanded further like macro. As it acts different from macro, and also handled by preprocessor, the system needs a way to tell it out from macro. So GCC appends heading ‘#’ in assertion’s name.

1651 static cpp_hashnode *

1652 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type) in cpplib.c

1653 {

1654 cpp_hashnode *result = 0;

1655 const cpp_token *predicate;

1656

1657 /* We don't expand predicates or answers. */

1658 pfile->state.prevent_expansion++;

1659

1660 *answerp = 0;

1661 predicate = cpp_get_token (pfile);

1662 if (predicate->type == CPP_EOF)

1663 cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");

1664 else if (predicate->type != CPP_NAME)

1665 cpp_error (pfile, CPP_DL_ERROR, "predicate must be an identifier");

1666 else if (parse_answer (pfile, answerp, type) == 0)

1667 {

1668 unsigned int len = NODE_LEN (predicate->val.node);

1669 unsigned char *sym = alloca (len + 1);

1670

1671 /* Prefix '#' to get it out of macro namespace. */

1672 sym[0] = '#';

1673 memcpy (sym + 1, NODE_NAME (predicate->val.node), len);

1674 result = cpp_lookup (pfile, sym, len + 1);

1675 }

1676

1677 pfile->state.prevent_expansion--;

1678 return result;

1679 }

The answer is extracted by parse_answer. This function is quite simple, and similar with those extracting macro defintion.

1575 static int

1576 parse_answer (cpp_reader *pfile, struct answer **answerp, int type) in cpplib.c

1577 {

1578 const cpp_token *paren;

1579 struct answer *answer;

1580 unsigned int acount;

1581

1582 /* In a conditional, it is legal to not have an open paren. We

1583 should save the following token in this case. */

1584 paren = cpp_get_token (pfile);

1585

1586 /* If not a paren, see if we're OK. */

1587 if (paren->type != CPP_OPEN_PAREN)

1588 {

1589 /* In a conditional no answer is a test for any answer. It

1590 could be followed by any token. */

1591 if (type == T_IF)

1592 {

1593 _cpp_backup_tokens (pfile, 1);

1594 return 0;

1595 }

1596

1597 /* #unassert with no answer is valid - it removes all answers. */

1598 if (type == T_UNASSERT && paren->type == CPP_EOF)

1599 return 0;

1600

1601 cpp_error (pfile, CPP_DL_ERROR, "missing '(' after predicate");

1602 return 1;

1603 }

1604

1605 for (acount = 0;; acount++)

1606 {

1607 size_t room_needed;

1608 const cpp_token *token = cpp_get_token (pfile);

1609 cpp_token *dest;

1610

1611 if (token->type == CPP_CLOSE_PAREN)

1612 break;

1613

1614 if (token->type == CPP_EOF)

1615 {

1616 cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");

1617 return 1;

1618 }

1619

1620 /* struct answer includes the space for one token. */

1621 room_needed = (sizeof (struct answer) + acount * sizeof (cpp_token));

1622

1623 if (BUFF_ROOM (pfile->a_buff) < room_needed)

1624 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));

1625

1626 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];

1627 *dest = *token;

1628

1629 /* Drop whitespace at start, for answer equivalence purposes. */

1630 if (acount == 0)

1631 dest->flags &= ~PREV_WHITE;

1632 }

1633

1634 if (acount == 0)

1635 {

1636 cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");

1637 return 1;

1638 }

1639

1640 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);

1641 answer->count = acount;

1642 answer->next = NULL;

1643 *answerp = answer;

1644

1645 return 0;

1646 }

find_answer is designed to find if specified answer of candidate has been added in node. Note that as answer contains tokens, the equivalence should be checked by _cpp_equiv_tokens one by one. Answer can’t be re-inserted.

1683 static struct answer **

1684 find_answer (cpp_hashnode *node, const struct answer *candidate) in cpplib.c

1685 {

1686 unsigned int i;

1687 struct answer **result;

1688

1689 for (result = &node->value.answers; *result; result = &(*result)->next)

1690 {

1691 struct answer *answer = *result;

1692

1693 if (answer->count == candidate->count)

1694 {