Mercurial > hg > CbC > CbC_gcc

comparison libcpp/pch.c @ 67:f6334be47118

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
date Tue, 22 Mar 2011 17:18:12 +0900
parents b7f97abdc517
children 04ced10e8804
comparison
equal deleted inserted replaced
65:65488c3d617d 67:f6334be47118
1 /* Part of CPP library. (Precompiled header reading/writing.) 1 /* Part of CPP library. (Precompiled header reading/writing.)
2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009 2 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009, 2010
3 Free Software Foundation, Inc. 3 Free Software Foundation, Inc.
4 4
5 This program is free software; you can redistribute it and/or modify it 5 This program is free software; you can redistribute it and/or modify it
6 under the terms of the GNU General Public License as published by the 6 under the terms of the GNU General Public License as published by the
7 Free Software Foundation; either version 3, or (at your option) any 7 Free Software Foundation; either version 3, or (at your option) any
56 case NT_VOID: 56 case NT_VOID:
57 if (! (hn->flags & NODE_POISONED)) 57 if (! (hn->flags & NODE_POISONED))
58 return 1; 58 return 1;
59 59
60 case NT_MACRO: 60 case NT_MACRO:
61 if ((hn->flags & NODE_BUILTIN)) 61 if ((hn->flags & NODE_BUILTIN)
62 && (!pfile->cb.user_builtin_macro
63 || !pfile->cb.user_builtin_macro (pfile, hn)))
62 return 1; 64 return 1;
63 65
64 { 66 {
65 struct macrodef_struct s; 67 struct macrodef_struct s;
66 const unsigned char *defn; 68 const unsigned char *defn;
395 { 397 {
396 size_t count_saved = 0; 398 size_t count_saved = 0;
397 size_t i; 399 size_t i;
398 struct def_pragma_macro *p; 400 struct def_pragma_macro *p;
399 size_t nlen; 401 size_t nlen;
400 cpp_hashnode *h = NULL;
401 cpp_macro *m;
402 uchar *defn; 402 uchar *defn;
403 size_t defnlen; 403 size_t defnlen;
404 404
405 if (fread (&count_saved, sizeof (count_saved), 1, f) != 1) 405 if (fread (&count_saved, sizeof (count_saved), 1, f) != 1)
406 return 0; 406 return 0;
409 for (i = 0; i < count_saved; i++) 409 for (i = 0; i < count_saved; i++)
410 { 410 {
411 if (fread (&nlen, sizeof (nlen), 1, f) != 1) 411 if (fread (&nlen, sizeof (nlen), 1, f) != 1)
412 return 0; 412 return 0;
413 p = XNEW (struct def_pragma_macro); 413 p = XNEW (struct def_pragma_macro);
414 memset (p, 0, sizeof (struct def_pragma_macro));
414 p->name = XNEWVAR (char, nlen + 1); 415 p->name = XNEWVAR (char, nlen + 1);
415 p->name[nlen] = 0; 416 p->name[nlen] = 0;
416 if (fread (p->name, nlen, 1, f) != 1) 417 if (fread (p->name, nlen, 1, f) != 1)
417 return 0; 418 return 0;
418 /* Save old state. */
419 m = cpp_push_definition (r, p->name);
420 if (fread (&defnlen, sizeof (defnlen), 1, f) != 1) 419 if (fread (&defnlen, sizeof (defnlen), 1, f) != 1)
421 return 0; 420 return 0;
422 defn = XNEWVAR (uchar, defnlen + 2); 421 if (defnlen == 0)
423 defn[defnlen] = '\n'; 422 p->is_undef = 1;
424 defn[defnlen + 1] = 0; 423 else
425 424 {
426 if (fread (defn, defnlen, 1, f) != 1) 425 defn = XNEWVEC (uchar, defnlen + 1);
427 return 0; 426 defn[defnlen] = 0;
428 cpp_pop_definition (r, p->name, NULL); 427
429 { 428 if (fread (defn, defnlen, 1, f) != 1)
430 size_t namelen; 429 return 0;
431 uchar *dn; 430
432 431 p->definition = defn;
433 namelen = ustrcspn (defn, "( \n"); 432 if (fread (&(p->line), sizeof (source_location), 1, f) != 1)
434 h = cpp_lookup (r, defn, namelen); 433 return 0;
435 dn = defn + namelen; 434 defnlen = 0;
436 435 if (fread (&defnlen, sizeof (defnlen), 1, f) != 1)
437 h->type = NT_VOID; 436 return 0;
438 h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED); 437 p->syshdr = ((defnlen & 1) != 0 ? 1 : 0);
439 if (cpp_push_buffer (r, dn, ustrchr (dn, '\n') - dn, true) 438 p->used = ((defnlen & 2) != 0 ? 1 : 0);
440 != NULL) 439 }
441 { 440
442 _cpp_clean_line (r);
443 if (!_cpp_create_definition (r, h))
444 abort ();
445 _cpp_pop_buffer (r);
446 }
447 else
448 abort ();
449 }
450 p->value = cpp_push_definition (r, p->name);
451
452 free (defn);
453 p->next = r->pushed_macros; 441 p->next = r->pushed_macros;
454 r->pushed_macros = p; 442 r->pushed_macros = p;
455 /* Restore current state. */
456 cpp_pop_definition (r, p->name, m);
457 } 443 }
458 return 1; 444 return 1;
459 } 445 }
460 446
461 static int 447 static int
462 _cpp_save_pushed_macros (cpp_reader *r, FILE *f) 448 _cpp_save_pushed_macros (cpp_reader *r, FILE *f)
463 { 449 {
464 size_t count_saved = 0; 450 size_t count_saved = 0;
465 size_t i; 451 size_t i;
466 struct def_pragma_macro *p,**pp; 452 struct def_pragma_macro *p,**pp;
467 cpp_hashnode *node;
468 cpp_macro *m;
469 size_t defnlen; 453 size_t defnlen;
470 const uchar *defn;
471 454
472 /* Get count. */ 455 /* Get count. */
473 p = r->pushed_macros; 456 p = r->pushed_macros;
474 while (p != NULL) 457 while (p != NULL)
475 { 458 {
492 pp[i] = p; 475 pp[i] = p;
493 p = p->next; 476 p = p->next;
494 } 477 }
495 for (i = 0; i < count_saved; i++) 478 for (i = 0; i < count_saved; i++)
496 { 479 {
497 /* Save old state. */
498 m = cpp_push_definition (r, pp[i]->name);
499 /* Set temporary macro name to saved state. */
500 cpp_pop_definition (r, pp[i]->name, pp[i]->value);
501 node = _cpp_lex_identifier (r, pp[i]->name);
502 defnlen = strlen (pp[i]->name); 480 defnlen = strlen (pp[i]->name);
503 if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1 481 if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1
504 || fwrite (pp[i]->name, defnlen, 1, f) != 1) 482 || fwrite (pp[i]->name, defnlen, 1, f) != 1)
505 return 0; 483 return 0;
506 defn = cpp_macro_definition (r, node); 484 if (pp[i]->is_undef)
507 defnlen = ustrlen (defn); 485 {
508 if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1 486 defnlen = 0;
509 || fwrite (defn, defnlen, 1, f) != 1) 487 if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1)
510 return 0; 488 return 0;
511 /* Restore current state. */ 489 }
512 cpp_pop_definition (r, pp[i]->name, m); 490 else
491 {
492 defnlen = ustrlen (pp[i]->definition);
493 if (fwrite (&defnlen, sizeof (size_t), 1, f) != 1
494 || fwrite (pp[i]->definition, defnlen, 1, f) != 1)
495 return 0;
496 if (fwrite (&(pp[i]->line), sizeof (source_location), 1, f) != 1)
497 return 0;
498 defnlen = 0;
499 defnlen |= (pp[i]->syshdr != 0 ? 1 : 0);
500 defnlen |= (pp[i]->used != 0 ? 2 : 0);
501 if (fwrite (&defnlen, sizeof (defnlen), 1, f) != 1)
502 return 0;
503 }
513 } 504 }
514 return 1; 505 return 1;
515 } 506 }
516 507
517 508
757 748
758 static int 749 static int
759 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p) 750 save_macros (cpp_reader *r, cpp_hashnode *h, void *data_p)
760 { 751 {
761 struct save_macro_data *data = (struct save_macro_data *)data_p; 752 struct save_macro_data *data = (struct save_macro_data *)data_p;
753
754 if ((h->flags & NODE_BUILTIN)
755 && h->type == NT_MACRO
756 && r->cb.user_builtin_macro)
757 r->cb.user_builtin_macro (r, h);
758
762 if (h->type != NT_VOID 759 if (h->type != NT_VOID
763 && (h->flags & NODE_BUILTIN) == 0) 760 && (h->flags & NODE_BUILTIN) == 0)
764 { 761 {
765 if (data->count == data->array_size) 762 if (data->count == data->array_size)
766 { 763 {