Lines Matching refs:pfile
193 #define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)
197 skip_rest_of_line (cpp_reader *pfile)
200 while (pfile->context->prev)
201 _cpp_pop_context (pfile);
205 while (_cpp_lex_token (pfile)->type != CPP_EOF)
211 check_eol (cpp_reader *pfile)
213 if (! SEEN_EOL () && _cpp_lex_token (pfile)->type != CPP_EOF)
214 cpp_error (pfile, CPP_DL_PEDWARN, "extra tokens at end of #%s directive",
215 pfile->directive->name);
221 check_eol_return_comments (cpp_reader *pfile)
235 tok = _cpp_lex_token (pfile);
239 cpp_error (pfile, CPP_DL_PEDWARN,
241 pfile->directive->name);
260 start_directive (cpp_reader *pfile)
263 pfile->state.in_directive = 1;
264 pfile->state.save_comments = 0;
265 pfile->directive_result.type = CPP_PADDING;
268 pfile->directive_line = pfile->line_table->highest_line;
273 end_directive (cpp_reader *pfile, int skip_line)
275 if (pfile->state.in_deferred_pragma)
277 else if (CPP_OPTION (pfile, traditional))
280 pfile->state.prevent_expansion--;
282 if (pfile->directive != &dtable[T_DEFINE])
283 _cpp_remove_overlay (pfile);
288 skip_rest_of_line (pfile);
289 if (!pfile->keep_tokens)
291 pfile->cur_run = &pfile->base_run;
292 pfile->cur_token = pfile->base_run.base;
297 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
298 pfile->state.in_directive = 0;
299 pfile->state.in_expression = 0;
300 pfile->state.angled_headers = 0;
301 pfile->directive = 0;
304 /* Prepare to handle the directive in pfile->directive. */
306 prepare_directive_trad (cpp_reader *pfile)
308 if (pfile->directive != &dtable[T_DEFINE])
310 bool no_expand = (pfile->directive
311 && ! (pfile->directive->flags & EXPAND));
312 bool was_skipping = pfile->state.skipping;
314 pfile->state.in_expression = (pfile->directive == &dtable[T_IF]
315 || pfile->directive == &dtable[T_ELIF]);
316 if (pfile->state.in_expression)
317 pfile->state.skipping = false;
320 pfile->state.prevent_expansion++;
321 _cpp_scan_out_logical_line (pfile, NULL);
323 pfile->state.prevent_expansion--;
325 pfile->state.skipping = was_skipping;
326 _cpp_overlay_buffer (pfile, pfile->out.base,
327 pfile->out.cur - pfile->out.base);
331 pfile->state.prevent_expansion++;
337 directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented)
340 if (CPP_PEDANTIC (pfile)
341 && ! pfile->state.skipping
343 cpp_error (pfile, CPP_DL_PEDWARN, "#%s is a GCC extension", dir->name);
351 if (CPP_WTRADITIONAL (pfile))
354 cpp_error (pfile, CPP_DL_WARNING,
357 cpp_error (pfile, CPP_DL_WARNING,
361 cpp_error (pfile, CPP_DL_WARNING,
373 _cpp_handle_directive (cpp_reader *pfile, int indented)
377 bool was_parsing_args = pfile->state.parsing_args;
378 bool was_discarding_output = pfile->state.discarding_output;
382 pfile->state.prevent_expansion = 0;
386 if (CPP_OPTION (pfile, pedantic))
387 cpp_error (pfile, CPP_DL_PEDWARN,
389 pfile->state.parsing_args = 0;
390 pfile->state.prevent_expansion = 0;
392 start_directive (pfile);
393 dname = _cpp_lex_token (pfile);
402 else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)
405 if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)
406 && ! pfile->state.skipping)
407 cpp_error (pfile, CPP_DL_PEDWARN,
416 pfile->mi_valid = false;
431 if (CPP_OPTION (pfile, preprocessed)
432 && !CPP_OPTION (pfile, directives_only)
444 pfile->state.angled_headers = dir->flags & INCL;
445 pfile->state.directive_wants_padding = dir->flags & INCL;
446 if (! CPP_OPTION (pfile, preprocessed))
447 directive_diagnostics (pfile, dir, indented);
448 if (pfile->state.skipping && !(dir->flags & COND))
460 if (CPP_OPTION (pfile, lang) == CLK_ASM)
462 else if (!pfile->state.skipping)
463 cpp_error (pfile, CPP_DL_ERROR, "invalid preprocessing directive #%s",
464 cpp_token_as_text (pfile, dname));
467 pfile->directive = dir;
468 if (CPP_OPTION (pfile, traditional))
469 prepare_directive_trad (pfile);
472 pfile->directive->handler (pfile);
474 _cpp_backup_tokens (pfile, 1);
476 end_directive (pfile, skip);
480 pfile->state.parsing_args = 2;
481 pfile->state.prevent_expansion = 1;
484 pfile->state.prevent_expansion = 1;
491 run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count)
493 cpp_push_buffer (pfile, (const uchar *) buf, count,
495 start_directive (pfile);
499 _cpp_clean_line (pfile);
501 pfile->directive = &dtable[dir_no];
502 if (CPP_OPTION (pfile, traditional))
503 prepare_directive_trad (pfile);
504 pfile->directive->handler (pfile);
505 end_directive (pfile, 1);
506 _cpp_pop_buffer (pfile);
512 lex_macro_node (cpp_reader *pfile)
514 const cpp_token *token = _cpp_lex_token (pfile);
527 if (node == pfile->spec_nodes.n_defined)
528 cpp_error (pfile, CPP_DL_ERROR,
534 cpp_error (pfile, CPP_DL_ERROR,
538 cpp_error (pfile, CPP_DL_ERROR, "no macro name given in #%s directive",
539 pfile->directive->name);
541 cpp_error (pfile, CPP_DL_ERROR, "macro names must be identifiers");
548 do_define (cpp_reader *pfile)
550 cpp_hashnode *node = lex_macro_node (pfile);
556 pfile->state.save_comments =
557 ! CPP_OPTION (pfile, discard_comments_in_macro_exp);
559 if (_cpp_create_definition (pfile, node))
560 if (pfile->cb.define)
561 pfile->cb.define (pfile, pfile->directive_line, node);
567 do_undef (cpp_reader *pfile)
569 cpp_hashnode *node = lex_macro_node (pfile);
573 if (pfile->cb.undef)
574 pfile->cb.undef (pfile, pfile->directive_line, node);
581 cpp_error (pfile, CPP_DL_WARNING,
584 if (CPP_OPTION (pfile, warn_unused_macros))
585 _cpp_warn_if_unused_macro (pfile, node, NULL);
591 check_eol (pfile);
597 undefine_macros (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *h,
610 cpp_undef_all (cpp_reader *pfile)
612 cpp_forall_identifiers (pfile, undefine_macros, NULL);
620 glue_header_name (cpp_reader *pfile)
631 token = get_token_no_padding (pfile);
637 cpp_error (pfile, CPP_DL_ERROR, "missing terminating > character");
651 total_len = (cpp_spell_token (pfile, token, (uchar *) &buffer[total_len],
664 parse_include (cpp_reader *pfile, int *pangle_brackets,
671 header = get_token_no_padding (pfile);
681 fname = glue_header_name (pfile);
688 if (pfile->directive == &dtable[T_PRAGMA])
691 dir = pfile->directive->name;
692 cpp_error (pfile, CPP_DL_ERROR, "#%s expects \"FILENAME\" or <FILENAME>",
698 if (buf == NULL || CPP_OPTION (pfile, discard_comments))
699 check_eol (pfile);
704 *buf = check_eol_return_comments (pfile);
712 do_include_common (cpp_reader *pfile, enum include_type type)
720 pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);
722 fname = parse_include (pfile, &angle_brackets, &buf);
732 cpp_error (pfile, CPP_DL_ERROR, "empty filename in #%s",
733 pfile->directive->name);
741 if (pfile->line_table->depth >= CPP_STACK_MAX)
742 cpp_error (pfile, CPP_DL_ERROR, "#include nested too deeply");
746 skip_rest_of_line (pfile);
748 if (pfile->cb.include)
749 pfile->cb.include (pfile, pfile->directive_line,
750 pfile->directive->name, fname, angle_brackets,
753 _cpp_stack_include (pfile, fname, angle_brackets, type);
762 do_include (cpp_reader *pfile)
764 do_include_common (pfile, IT_INCLUDE);
768 do_import (cpp_reader *pfile)
770 do_include_common (pfile, IT_IMPORT);
774 do_include_next (cpp_reader *pfile)
780 if (! pfile->buffer->prev)
782 cpp_error (pfile, CPP_DL_WARNING,
786 do_include_common (pfile, type);
794 read_flag (cpp_reader *pfile, unsigned int last)
796 const cpp_token *token = _cpp_lex_token (pfile);
809 cpp_error (pfile, CPP_DL_ERROR, "invalid flag \"%s\" in line directive",
810 cpp_token_as_text (pfile, token));
838 do_line (cpp_reader *pfile)
840 const struct line_maps *line_table = pfile->line_table;
852 unsigned int cap = CPP_OPTION (pfile, c99) ? 2147483647 : 32767;
855 token = cpp_get_token (pfile);
860 cpp_error (pfile, CPP_DL_ERROR,
862 cpp_token_as_text (pfile, token));
866 if (CPP_PEDANTIC (pfile) && (new_lineno == 0 || new_lineno > cap))
867 cpp_error (pfile, CPP_DL_PEDWARN, "line number out of range");
869 token = cpp_get_token (pfile);
873 if (cpp_interpret_string_notranslate (pfile, &token->val.str, 1,
876 check_eol (pfile);
880 cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
881 cpp_token_as_text (pfile, token));
885 skip_rest_of_line (pfile);
886 _cpp_do_file_change (pfile, LC_RENAME, new_file, new_lineno,
894 do_linemarker (cpp_reader *pfile)
896 const struct line_maps *line_table = pfile->line_table;
908 _cpp_backup_tokens (pfile, 1);
911 token = cpp_get_token (pfile);
916 cpp_error (pfile, CPP_DL_ERROR,
918 cpp_token_as_text (pfile, token));
922 token = cpp_get_token (pfile);
926 if (cpp_interpret_string_notranslate (pfile, &token->val.str,
931 flag = read_flag (pfile, 0);
936 _cpp_fake_include (pfile, new_file);
937 flag = read_flag (pfile, flag);
942 flag = read_flag (pfile, flag);
947 flag = read_flag (pfile, flag);
951 pfile->buffer->sysp = new_sysp;
953 check_eol (pfile);
957 cpp_error (pfile, CPP_DL_ERROR, "\"%s\" is not a valid filename",
958 cpp_token_as_text (pfile, token));
962 skip_rest_of_line (pfile);
963 _cpp_do_file_change (pfile, reason, new_file, new_lineno, new_sysp);
966 /* Arrange the file_change callback. pfile->line has changed to
971 _cpp_do_file_change (cpp_reader *pfile, enum lc_reason reason,
975 const struct line_map *map = linemap_add (pfile->line_table, reason, sysp,
978 linemap_line_start (pfile->line_table, map->to_line, 127);
980 if (pfile->cb.file_change)
981 pfile->cb.file_change (pfile, map);
987 do_diagnostic (cpp_reader *pfile, int code, int print_dir)
989 if (_cpp_begin_message (pfile, code, pfile->cur_token[-1].src_loc, 0))
992 fprintf (stderr, "#%s ", pfile->directive->name);
993 pfile->state.prevent_expansion++;
995 pfile->state.in_diagnostic++;
996 cpp_output_line (pfile, stderr);
998 pfile->state.in_diagnostic--;
999 pfile->state.prevent_expansion--;
1004 do_error (cpp_reader *pfile)
1006 do_diagnostic (pfile, CPP_DL_ERROR, 1);
1010 do_warning (cpp_reader *pfile)
1013 do_diagnostic (pfile, CPP_DL_WARNING_SYSHDR, 1);
1018 do_ident (cpp_reader *pfile)
1020 const cpp_token *str = cpp_get_token (pfile);
1023 cpp_error (pfile, CPP_DL_ERROR, "invalid #%s directive",
1024 pfile->directive->name);
1025 else if (pfile->cb.ident)
1026 pfile->cb.ident (pfile, pfile->directive_line, &str->val.str);
1028 check_eol (pfile);
1046 new_pragma_entry (cpp_reader *pfile, struct pragma_entry **chain)
1051 _cpp_aligned_alloc (pfile, sizeof (struct pragma_entry));
1063 register_pragma_1 (cpp_reader *pfile, const char *space, const char *name,
1066 struct pragma_entry **chain = &pfile->pragmas;
1072 node = cpp_lookup (pfile, U space, strlen (space));
1076 entry = new_pragma_entry (pfile, chain);
1085 cpp_error (pfile, CPP_DL_ICE,
1094 cpp_error (pfile, CPP_DL_ICE,
1101 node = cpp_lookup (pfile, U name, strlen (name));
1105 entry = new_pragma_entry (pfile, chain);
1112 cpp_error (pfile, CPP_DL_ICE,
1116 cpp_error (pfile, CPP_DL_ICE, "#pragma %s %s is already registered",
1119 cpp_error (pfile, CPP_DL_ICE, "#pragma %s is already registered", name);
1126 register_pragma_internal (cpp_reader *pfile, const char *space,
1131 entry = register_pragma_1 (pfile, space, name, false);
1142 cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name,
1149 cpp_error (pfile, CPP_DL_ICE, "registering pragma with NULL handler");
1153 entry = register_pragma_1 (pfile, space, name, false);
1165 cpp_register_deferred_pragma (cpp_reader *pfile, const char *space,
1171 entry = register_pragma_1 (pfile, space, name, allow_name_expansion);
1183 do_pragma_mark (cpp_reader *pfile)
1185 ++pfile->state.skipping;
1186 skip_rest_of_line (pfile);
1187 --pfile->state.skipping;
1193 _cpp_init_internal_pragmas (cpp_reader *pfile)
1196 register_pragma_internal (pfile, 0, "once", do_pragma_once);
1198 register_pragma_internal (pfile, 0, "mark", do_pragma_mark);
1201 register_pragma_internal (pfile, "GCC", "poison", do_pragma_poison);
1202 register_pragma_internal (pfile, "GCC", "system_header",
1204 register_pragma_internal (pfile, "GCC", "dependency", do_pragma_dependency);
1243 _cpp_save_pragma_names (cpp_reader *pfile)
1245 int ct = count_registered_pragmas (pfile->pragmas);
1247 (void) save_registered_pragmas (pfile->pragmas, result);
1255 restore_registered_pragmas (cpp_reader *pfile, struct pragma_entry *pe,
1261 sd = restore_registered_pragmas (pfile, pe->u.space, sd);
1262 pe->pragma = cpp_lookup (pfile, U *sd, strlen (*sd));
1272 _cpp_restore_pragma_names (cpp_reader *pfile, char **saved)
1274 (void) restore_registered_pragmas (pfile, pfile->pragmas, saved);
1286 do_pragma (cpp_reader *pfile)
1289 const cpp_token *token, *pragma_token = pfile->cur_token;
1293 pfile->state.prevent_expansion++;
1295 token = cpp_get_token (pfile);
1299 p = lookup_pragma_entry (pfile->pragmas, token->val.node);
1304 pfile->state.prevent_expansion--;
1305 token = cpp_get_token (pfile);
1311 pfile->state.prevent_expansion++;
1320 pfile->directive_result.src_loc = pragma_token->src_loc;
1321 pfile->directive_result.type = CPP_PRAGMA;
1322 pfile->directive_result.flags = pragma_token->flags;
1323 pfile->directive_result.val.pragma = p->u.ident;
1324 pfile->state.in_deferred_pragma = true;
1325 pfile->state.pragma_allow_expansion = p->allow_expansion;
1327 pfile->state.prevent_expansion++;
1334 if (pfile->cb.line_change)
1335 (*pfile->cb.line_change) (pfile, pragma_token, false);
1337 pfile->state.prevent_expansion--;
1338 (*p->u.handler) (pfile);
1340 pfile->state.prevent_expansion++;
1343 else if (pfile->cb.def_pragma)
1345 if (count == 1 || pfile->context->prev == NULL)
1346 _cpp_backup_tokens (pfile, count);
1359 _cpp_push_token_context (pfile, NULL, toks, 2);
1361 pfile->cb.def_pragma (pfile, pfile->directive_line);
1364 pfile->state.prevent_expansion--;
1369 do_pragma_once (cpp_reader *pfile)
1371 if (pfile->buffer->prev == NULL)
1372 cpp_error (pfile, CPP_DL_WARNING, "#pragma once in main file");
1374 check_eol (pfile);
1375 _cpp_mark_file_once_only (pfile, pfile->buffer->file);
1381 do_pragma_poison (cpp_reader *pfile)
1386 pfile->state.poisoned_ok = 1;
1389 tok = _cpp_lex_token (pfile);
1394 cpp_error (pfile, CPP_DL_ERROR,
1404 cpp_error (pfile, CPP_DL_WARNING, "poisoning existing macro \"%s\"",
1409 pfile->state.poisoned_ok = 0;
1419 do_pragma_system_header (cpp_reader *pfile)
1421 cpp_buffer *buffer = pfile->buffer;
1424 cpp_error (pfile, CPP_DL_WARNING,
1428 check_eol (pfile);
1429 skip_rest_of_line (pfile);
1430 cpp_make_system_header (pfile, 1, 0);
1438 do_pragma_dependency (cpp_reader *pfile)
1443 fname = parse_include (pfile, &angle_brackets, NULL);
1447 ordering = _cpp_compare_file_date (pfile, fname, angle_brackets);
1449 cpp_error (pfile, CPP_DL_WARNING, "cannot find source file %s", fname);
1452 cpp_error (pfile, CPP_DL_WARNING,
1454 if (cpp_get_token (pfile)->type != CPP_EOF)
1456 _cpp_backup_tokens (pfile, 1);
1457 do_diagnostic (pfile, CPP_DL_WARNING, 0);
1466 get_token_no_padding (cpp_reader *pfile)
1470 const cpp_token *result = cpp_get_token (pfile);
1479 get__Pragma_string (cpp_reader *pfile)
1483 if (get_token_no_padding (pfile)->type != CPP_OPEN_PAREN)
1486 string = get_token_no_padding (pfile);
1490 if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
1499 destringize_and_run (cpp_reader *pfile, const cpp_string *in)
1529 saved_context = pfile->context;
1530 saved_cur_token = pfile->cur_token;
1531 saved_cur_run = pfile->cur_run;
1533 pfile->context = XNEW (cpp_context);
1534 pfile->context->macro = 0;
1535 pfile->context->prev = 0;
1536 pfile->context->next = 0;
1540 cpp_push_buffer (pfile, (const uchar *) result, dest - result,
1543 if (pfile->buffer->prev)
1544 pfile->buffer->file = pfile->buffer->prev->file;
1546 start_directive (pfile);
1547 _cpp_clean_line (pfile);
1548 do_pragma (pfile);
1549 end_directive (pfile, 1);
1561 if (pfile->directive_result.type == CPP_PRAGMA)
1568 toks[0] = pfile->directive_result;
1577 toks[count] = *cpp_get_token (pfile);
1588 toks[0] = pfile->directive_result;
1592 if (pfile->cb.line_change)
1593 pfile->cb.line_change (pfile, pfile->cur_token, false);
1597 pfile->buffer->file = NULL;
1598 _cpp_pop_buffer (pfile);
1601 XDELETE (pfile->context);
1602 pfile->context = saved_context;
1603 pfile->cur_token = saved_cur_token;
1604 pfile->cur_run = saved_cur_run;
1607 _cpp_push_token_context (pfile, NULL, toks, count);
1612 _cpp_do__Pragma (cpp_reader *pfile)
1614 const cpp_token *string = get__Pragma_string (pfile);
1615 pfile->directive_result.type = CPP_PADDING;
1618 destringize_and_run (pfile, &string->val.str);
1620 cpp_error (pfile, CPP_DL_ERROR,
1626 do_ifdef (cpp_reader *pfile)
1630 if (! pfile->state.skipping)
1632 const cpp_hashnode *node = lex_macro_node (pfile);
1638 check_eol (pfile);
1642 push_conditional (pfile, skip, T_IFDEF, 0);
1647 do_ifndef (cpp_reader *pfile)
1652 if (! pfile->state.skipping)
1654 node = lex_macro_node (pfile);
1660 check_eol (pfile);
1664 push_conditional (pfile, skip, T_IFNDEF, node);
1668 pfile->mi_ind_cmacro so we can handle multiple-include
1673 do_if (cpp_reader *pfile)
1677 if (! pfile->state.skipping)
1678 skip = _cpp_parse_expr (pfile) == false;
1680 push_conditional (pfile, skip, T_IF, pfile->mi_ind_cmacro);
1687 do_else (cpp_reader *pfile)
1689 cpp_buffer *buffer = pfile->buffer;
1693 cpp_error (pfile, CPP_DL_ERROR, "#else without #if");
1698 cpp_error (pfile, CPP_DL_ERROR, "#else after #else");
1699 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1705 pfile->state.skipping = ifs->skip_elses;
1712 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1713 check_eol (pfile);
1720 do_elif (cpp_reader *pfile)
1722 cpp_buffer *buffer = pfile->buffer;
1726 cpp_error (pfile, CPP_DL_ERROR, "#elif without #if");
1731 cpp_error (pfile, CPP_DL_ERROR, "#elif after #else");
1732 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
1740 pfile->state.skipping = 1;
1743 pfile->state.skipping = 0;
1744 pfile->state.skipping = ! _cpp_parse_expr (pfile);
1745 ifs->skip_elses = ! pfile->state.skipping;
1753 /* #endif pops the if stack and resets pfile->state.skipping. */
1755 do_endif (cpp_reader *pfile)
1757 cpp_buffer *buffer = pfile->buffer;
1761 cpp_error (pfile, CPP_DL_ERROR, "#endif without #if");
1765 if (!ifs->was_skipping && CPP_OPTION (pfile, warn_endif_labels))
1766 check_eol (pfile);
1771 pfile->mi_valid = true;
1772 pfile->mi_cmacro = ifs->mi_cmacro;
1776 pfile->state.skipping = ifs->was_skipping;
1777 obstack_free (&pfile->buffer_ob, ifs);
1782 pfile->state.skipping to SKIP. If TYPE indicates the conditional
1786 push_conditional (cpp_reader *pfile, int skip, int type,
1790 cpp_buffer *buffer = pfile->buffer;
1792 ifs = XOBNEW (&pfile->buffer_ob, struct if_stack);
1793 ifs->line = pfile->directive_line;
1795 ifs->skip_elses = pfile->state.skipping || !skip;
1796 ifs->was_skipping = pfile->state.skipping;
1799 if (pfile->mi_valid && pfile->mi_cmacro == 0)
1804 pfile->state.skipping = skip;
1813 parse_answer (cpp_reader *pfile, struct answer **answerp, int type)
1821 paren = cpp_get_token (pfile);
1830 _cpp_backup_tokens (pfile, 1);
1838 cpp_error (pfile, CPP_DL_ERROR, "missing '(' after predicate");
1845 const cpp_token *token = cpp_get_token (pfile);
1853 cpp_error (pfile, CPP_DL_ERROR, "missing ')' to complete answer");
1860 if (BUFF_ROOM (pfile->a_buff) < room_needed)
1861 _cpp_extend_buff (pfile, &pfile->a_buff, sizeof (struct answer));
1863 dest = &((struct answer *) BUFF_FRONT (pfile->a_buff))->first[acount];
1873 cpp_error (pfile, CPP_DL_ERROR, "predicate's answer is empty");
1877 answer = (struct answer *) BUFF_FRONT (pfile->a_buff);
1889 parse_assertion (cpp_reader *pfile, struct answer **answerp, int type)
1895 pfile->state.prevent_expansion++;
1898 predicate = cpp_get_token (pfile);
1900 cpp_error (pfile, CPP_DL_ERROR, "assertion without predicate");
1902 cpp_error (pfile, CPP_DL_ERROR, "predicate must be an identifier");
1903 else if (parse_answer (pfile, answerp, type) == 0)
1911 result = cpp_lookup (pfile, sym, len + 1);
1914 pfile->state.prevent_expansion--;
1948 _cpp_test_assertion (cpp_reader *pfile, unsigned int *value)
1953 node = parse_assertion (pfile, &answer, T_IF);
1962 else if (pfile->cur_token[-1].type == CPP_EOF)
1963 _cpp_backup_tokens (pfile, 1);
1971 do_assert (cpp_reader *pfile)
1976 node = parse_assertion (pfile, &new_answer, T_ASSERT);
1988 cpp_error (pfile, CPP_DL_WARNING, "\"%s\" re-asserted",
1998 if (pfile->hash_table->alloc_subobject)
2001 new_answer = (struct answer *) pfile->hash_table->alloc_subobject
2006 BUFF_FRONT (pfile->a_buff) += answer_size;
2010 check_eol (pfile);
2016 do_unassert (cpp_reader *pfile)
2021 node = parse_assertion (pfile, &answer, T_UNASSERT);
2038 check_eol (pfile);
2054 cpp_define (cpp_reader *pfile, const char *str)
2077 run_directive (pfile, T_DEFINE, buf, count);
2082 _cpp_define_builtin (cpp_reader *pfile, const char *str)
2088 run_directive (pfile, T_DEFINE, buf, len);
2093 cpp_undef (cpp_reader *pfile, const char *macro)
2099 run_directive (pfile, T_UNDEF, buf, len);
2104 cpp_assert (cpp_reader *pfile, const char *str)
2106 handle_assertion (pfile, str, T_ASSERT);
2111 cpp_unassert (cpp_reader *pfile, const char *str)
2113 handle_assertion (pfile, str, T_UNASSERT);
2118 handle_assertion (cpp_reader *pfile, const char *str, int type)
2136 run_directive (pfile, type, str, count);
2141 cpp_errors (cpp_reader *pfile)
2143 return pfile->errors;
2148 cpp_get_options (cpp_reader *pfile)
2150 return &pfile->opts;
2155 cpp_get_callbacks (cpp_reader *pfile)
2157 return &pfile->cb;
2162 cpp_set_callbacks (cpp_reader *pfile, cpp_callbacks *cb)
2164 pfile->cb = *cb;
2169 cpp_get_deps (cpp_reader *pfile)
2171 if (!pfile->deps)
2172 pfile->deps = deps_init ();
2173 return pfile->deps;
2180 cpp_push_buffer (cpp_reader *pfile, const uchar *buffer, size_t len,
2183 cpp_buffer *new_buffer = XOBNEW (&pfile->buffer_ob, cpp_buffer);
2191 new_buffer->prev = pfile->buffer;
2194 pfile->buffer = new_buffer;
2202 _cpp_pop_buffer (cpp_reader *pfile)
2204 cpp_buffer *buffer = pfile->buffer;
2211 cpp_error_with_line (pfile, CPP_DL_ERROR, ifs->line, 0,
2215 pfile->state.skipping = 0;
2217 /* _cpp_do_file_change expects pfile->buffer to be the new one. */
2218 pfile->buffer = buffer->prev;
2224 obstack_free (&pfile->buffer_ob, buffer);
2228 _cpp_pop_file_buffer (pfile, inc);
2230 _cpp_do_file_change (pfile, LC_LEAVE, 0, 0, 0);
2236 _cpp_init_directives (cpp_reader *pfile)
2243 node = cpp_lookup (pfile, dtable[i].name, dtable[i].length);