mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-21 04:42:53 +08:00
224c3ddb89
Most allocation functions (if not all) return a void* pointing to the allocated memory. In C++, we need to add an explicit cast when assigning the result to a pointer to another type (which is the case more often than not). The content of this patch is taken from Pedro's branch, from commit "(mostly) auto-generated patch to insert casts needed for C++". I validated that the changes make sense and manually reflowed the code to make it respect the coding style. I also found multiple places where I could use XNEW/XNEWVEC/XRESIZEVEC/etc. Thanks a lot to whoever did that automated script to insert casts, doing it completely by hand would have taken a ridiculous amount of time. Only files built on x86 with --enable-targets=all are modified. This means that all other -nat.c files are untouched and will have to be dealt with later by using appropiate compilers. Or maybe we can try to build them with a regular g++ just to know where to add casts, I don't know. I built-tested this with --enable-targets=all and reg-tested. Here's the changelog entry, which was not too bad to make despite the size, thanks to David Malcom's script. I fixed some bits by hand, but there might be some wrong parts left (hopefully not). gdb/ChangeLog: * aarch64-linux-tdep.c (aarch64_stap_parse_special_token): Add cast to allocation result assignment. * ada-exp.y (write_object_renaming): Likewise. (write_ambiguous_var): Likewise. (ada_nget_field_index): Likewise. (write_var_or_type): Likewise. * ada-lang.c (ada_decode_symbol): Likewise. (ada_value_assign): Likewise. (value_pointer): Likewise. (cache_symbol): Likewise. (add_nonlocal_symbols): Likewise. (ada_name_for_lookup): Likewise. (symbol_completion_add): Likewise. (ada_to_fixed_type_1): Likewise. (ada_get_next_arg): Likewise. (defns_collected): Likewise. * ada-lex.l (processId): Likewise. (processString): Likewise. * ada-tasks.c (read_known_tasks_array): Likewise. (read_known_tasks_list): Likewise. * ada-typeprint.c (decoded_type_name): Likewise. * addrmap.c (addrmap_mutable_create_fixed): Likewise. * amd64-tdep.c (amd64_push_arguments): Likewise. (amd64_displaced_step_copy_insn): Likewise. (amd64_classify_insn_at): Likewise. (amd64_relocate_instruction): Likewise. * amd64obsd-tdep.c (amd64obsd_sigtramp_p): Likewise. * arch-utils.c (simple_displaced_step_copy_insn): Likewise. (initialize_current_architecture): Likewise. * arm-linux-tdep.c (arm_stap_parse_special_token): Likewise. * arm-symbian-tdep.c (arm_symbian_osabi_sniffer): Likewise. * arm-tdep.c (arm_exidx_new_objfile): Likewise. (arm_push_dummy_call): Likewise. (extend_buffer_earlier): Likewise. (arm_adjust_breakpoint_address): Likewise. (arm_skip_stub): Likewise. * auto-load.c (filename_is_in_pattern): Likewise. (maybe_add_script_file): Likewise. (maybe_add_script_text): Likewise. (auto_load_objfile_script_1): Likewise. * auxv.c (ld_so_xfer_auxv): Likewise. * ax-general.c (new_agent_expr): Likewise. (grow_expr): Likewise. (ax_reg_mask): Likewise. * bcache.c (bcache_full): Likewise. * breakpoint.c (program_breakpoint_here_p): Likewise. * btrace.c (parse_xml_raw): Likewise. * build-id.c (build_id_to_debug_bfd): Likewise. * buildsym.c (end_symtab_with_blockvector): Likewise. * c-exp.y (string_exp): Likewise. (qualified_name): Likewise. (write_destructor_name): Likewise. (operator_stoken): Likewise. (parse_number): Likewise. (scan_macro_expansion): Likewise. (yylex): Likewise. (c_print_token): Likewise. * c-lang.c (c_get_string): Likewise. (emit_numeric_character): Likewise. * charset.c (wchar_iterate): Likewise. * cli/cli-cmds.c (complete_command): Likewise. (make_command): Likewise. * cli/cli-dump.c (restore_section_callback): Likewise. (restore_binary_file): Likewise. * cli/cli-interp.c (cli_interpreter_exec): Likewise. * cli/cli-script.c (execute_control_command): Likewise. * cli/cli-setshow.c (do_set_command): Likewise. * coff-pe-read.c (add_pe_forwarded_sym): Likewise. (read_pe_exported_syms): Likewise. * coffread.c (coff_read_struct_type): Likewise. (coff_read_enum_type): Likewise. * common/btrace-common.c (btrace_data_append): Likewise. * common/buffer.c (buffer_grow): Likewise. * common/filestuff.c (gdb_fopen_cloexec): Likewise. * common/format.c (parse_format_string): Likewise. * common/gdb_vecs.c (delim_string_to_char_ptr_vec_append): Likewise. * common/xml-utils.c (xml_escape_text): Likewise. * compile/compile-object-load.c (copy_sections): Likewise. (compile_object_load): Likewise. * compile/compile-object-run.c (compile_object_run): Likewise. * completer.c (filename_completer): Likewise. * corefile.c (read_memory_typed_address): Likewise. (write_memory_unsigned_integer): Likewise. (write_memory_signed_integer): Likewise. (complete_set_gnutarget): Likewise. * corelow.c (get_core_register_section): Likewise. * cp-name-parser.y (d_grab): Likewise. (allocate_info): Likewise. (cp_new_demangle_parse_info): Likewise. * cp-namespace.c (cp_scan_for_anonymous_namespaces): Likewise. (cp_lookup_symbol_in_namespace): Likewise. (lookup_namespace_scope): Likewise. (find_symbol_in_baseclass): Likewise. (cp_lookup_nested_symbol): Likewise. (cp_lookup_transparent_type_loop): Likewise. * cp-support.c (copy_string_to_obstack): Likewise. (make_symbol_overload_list): Likewise. (make_symbol_overload_list_namespace): Likewise. (make_symbol_overload_list_adl_namespace): Likewise. (first_component_command): Likewise. * cp-valprint.c (cp_print_value): Likewise. * ctf.c (ctf_xfer_partial): Likewise. * d-exp.y (StringExp): Likewise. * d-namespace.c (d_lookup_symbol_in_module): Likewise. (lookup_module_scope): Likewise. (find_symbol_in_baseclass): Likewise. (d_lookup_nested_symbol): Likewise. * dbxread.c (find_stab_function_addr): Likewise. (read_dbx_symtab): Likewise. (dbx_end_psymtab): Likewise. (cp_set_block_scope): Likewise. * dcache.c (dcache_alloc): Likewise. * demangle.c (_initialize_demangler): Likewise. * dicos-tdep.c (dicos_load_module_p): Likewise. * dictionary.c (dict_create_hashed_expandable): Likewise. (dict_create_linear_expandable): Likewise. (expand_hashtable): Likewise. (add_symbol_linear_expandable): Likewise. * dwarf2-frame.c (add_cie): Likewise. (add_fde): Likewise. (dwarf2_build_frame_info): Likewise. * dwarf2expr.c (dwarf_expr_grow_stack): Likewise. (dwarf_expr_fetch_address): Likewise. (add_piece): Likewise. (execute_stack_op): Likewise. * dwarf2loc.c (chain_candidate): Likewise. (dwarf_entry_parameter_to_value): Likewise. (read_pieced_value): Likewise. (write_pieced_value): Likewise. * dwarf2read.c (dwarf2_read_section): Likewise. (add_type_unit): Likewise. (read_comp_units_from_section): Likewise. (fixup_go_packaging): Likewise. (dwarf2_compute_name): Likewise. (dwarf2_physname): Likewise. (create_dwo_unit_in_dwp_v1): Likewise. (create_dwo_unit_in_dwp_v2): Likewise. (read_func_scope): Likewise. (read_call_site_scope): Likewise. (dwarf2_attach_fields_to_type): Likewise. (process_structure_scope): Likewise. (mark_common_block_symbol_computed): Likewise. (read_common_block): Likewise. (abbrev_table_read_table): Likewise. (guess_partial_die_structure_name): Likewise. (fixup_partial_die): Likewise. (add_file_name): Likewise. (dwarf2_const_value_data): Likewise. (dwarf2_const_value_attr): Likewise. (build_error_marker_type): Likewise. (guess_full_die_structure_name): Likewise. (anonymous_struct_prefix): Likewise. (typename_concat): Likewise. (dwarf2_canonicalize_name): Likewise. (dwarf2_name): Likewise. (write_constant_as_bytes): Likewise. (dwarf2_fetch_constant_bytes): Likewise. (copy_string): Likewise. (parse_macro_definition): Likewise. * elfread.c (elf_symfile_segments): Likewise. (elf_rel_plt_read): Likewise. (elf_gnu_ifunc_resolve_by_cache): Likewise. (elf_gnu_ifunc_resolve_by_got): Likewise. (elf_read_minimal_symbols): Likewise. (elf_gnu_ifunc_record_cache): Likewise. * event-top.c (top_level_prompt): Likewise. (command_line_handler): Likewise. * exec.c (resize_section_table): Likewise. * expprint.c (print_subexp_standard): Likewise. * fbsd-tdep.c (fbsd_collect_regset_section_cb): Likewise. * findcmd.c (parse_find_args): Likewise. * findvar.c (address_from_register): Likewise. * frame.c (get_prev_frame_always): Likewise. * gdb_bfd.c (gdb_bfd_ref): Likewise. (get_section_descriptor): Likewise. * gdb_obstack.c (obconcat): Likewise. (obstack_strdup): Likewise. * gdbtypes.c (lookup_function_type_with_arguments): Likewise. (create_set_type): Likewise. (lookup_unsigned_typename): Likewise. (lookup_signed_typename): Likewise. (resolve_dynamic_union): Likewise. (resolve_dynamic_struct): Likewise. (add_dyn_prop): Likewise. (copy_dynamic_prop_list): Likewise. (arch_flags_type): Likewise. (append_composite_type_field_raw): Likewise. * gdbtypes.h (INIT_FUNC_SPECIFIC): Likewise. * gnu-v3-abi.c (gnuv3_rtti_type): Likewise. * go-exp.y (string_exp): Likewise. * go-lang.c (go_demangle): Likewise. * guile/guile.c (compute_scheme_string): Likewise. * guile/scm-cmd.c (gdbscm_parse_command_name): Likewise. (gdbscm_canonicalize_command_name): Likewise. * guile/scm-ports.c (ioscm_init_stdio_buffers): Likewise. (ioscm_init_memory_port): Likewise. (ioscm_reinit_memory_port): Likewise. * guile/scm-utils.c (gdbscm_gc_xstrdup): Likewise. (gdbscm_gc_dup_argv): Likewise. * h8300-tdep.c (h8300_push_dummy_call): Likewise. * hppa-tdep.c (internalize_unwinds): Likewise. (read_unwind_info): Likewise. * i386-cygwin-tdep.c (core_process_module_section): Likewise. (windows_core_xfer_shared_libraries): Likewise. * i386-tdep.c (i386_displaced_step_copy_insn): Likewise. (i386_stap_parse_special_token_triplet): Likewise. (i386_stap_parse_special_token_three_arg_disp): Likewise. * i386obsd-tdep.c (i386obsd_sigtramp_p): Likewise. * inf-child.c (inf_child_fileio_readlink): Likewise. * inf-ptrace.c (inf_ptrace_fetch_register): Likewise. (inf_ptrace_store_register): Likewise. * infrun.c (follow_exec): Likewise. (displaced_step_prepare_throw): Likewise. (save_stop_context): Likewise. (save_infcall_suspend_state): Likewise. * jit.c (jit_read_descriptor): Likewise. (jit_read_code_entry): Likewise. (jit_symtab_line_mapping_add_impl): Likewise. (finalize_symtab): Likewise. (jit_unwind_reg_get_impl): Likewise. * jv-exp.y (QualifiedName): Likewise. * jv-lang.c (get_java_utf8_name): Likewise. (type_from_class): Likewise. (java_demangle_type_signature): Likewise. (java_class_name_from_physname): Likewise. * jv-typeprint.c (java_type_print_base): Likewise. * jv-valprint.c (java_value_print): Likewise. * language.c (add_language): Likewise. * linespec.c (add_sal_to_sals_basic): Likewise. (add_sal_to_sals): Likewise. (decode_objc): Likewise. (find_linespec_symbols): Likewise. * linux-fork.c (fork_save_infrun_state): Likewise. * linux-nat.c (linux_nat_detach): Likewise. (linux_nat_fileio_readlink): Likewise. * linux-record.c (record_linux_sockaddr): Likewise. (record_linux_msghdr): Likewise. (Do): Likewise. * linux-tdep.c (linux_core_info_proc_mappings): Likewise. (linux_collect_regset_section_cb): Likewise. (linux_get_siginfo_data): Likewise. * linux-thread-db.c (try_thread_db_load_from_pdir_1): Likewise. (try_thread_db_load_from_dir): Likewise. (thread_db_load_search): Likewise. (info_auto_load_libthread_db): Likewise. * m32c-tdep.c (m32c_m16c_address_to_pointer): Likewise. (m32c_m16c_pointer_to_address): Likewise. * m68hc11-tdep.c (m68hc11_pseudo_register_write): Likewise. * m68k-tdep.c (m68k_get_longjmp_target): Likewise. * machoread.c (macho_check_dsym): Likewise. * macroexp.c (resize_buffer): Likewise. (gather_arguments): Likewise. (maybe_expand): Likewise. * macrotab.c (new_macro_key): Likewise. (new_source_file): Likewise. (new_macro_definition): Likewise. * mdebugread.c (parse_symbol): Likewise. (parse_type): Likewise. (parse_partial_symbols): Likewise. (psymtab_to_symtab_1): Likewise. * mem-break.c (default_memory_insert_breakpoint): Likewise. * mi/mi-cmd-break.c (mi_argv_to_format): Likewise. * mi/mi-main.c (mi_cmd_data_read_memory): Likewise. (mi_cmd_data_read_memory_bytes): Likewise. (mi_cmd_data_write_memory_bytes): Likewise. (mi_cmd_trace_frame_collected): Likewise. * mi/mi-parse.c (mi_parse_argv): Likewise. (mi_parse): Likewise. * minidebug.c (lzma_open): Likewise. (lzma_pread): Likewise. * mips-tdep.c (mips_read_fp_register_single): Likewise. (mips_print_fp_register): Likewise. * mipsnbsd-tdep.c (mipsnbsd_get_longjmp_target): Likewise. * mipsread.c (read_alphacoff_dynamic_symtab): Likewise. * mt-tdep.c (mt_register_name): Likewise. (mt_registers_info): Likewise. (mt_push_dummy_call): Likewise. * namespace.c (add_using_directive): Likewise. * nat/linux-btrace.c (perf_event_read): Likewise. (linux_enable_bts): Likewise. * nat/linux-osdata.c (linux_common_core_of_thread): Likewise. * nat/linux-ptrace.c (linux_ptrace_test_ret_to_nx): Likewise. * nto-tdep.c (nto_find_and_open_solib): Likewise. (nto_parse_redirection): Likewise. * objc-lang.c (objc_demangle): Likewise. (find_methods): Likewise. * objfiles.c (get_objfile_bfd_data): Likewise. (set_objfile_main_name): Likewise. (allocate_objfile): Likewise. (objfile_relocate): Likewise. (update_section_map): Likewise. * osabi.c (generic_elf_osabi_sniff_abi_tag_sections): Likewise. * p-exp.y (exp): Likewise. (yylex): Likewise. * p-valprint.c (pascal_object_print_value): Likewise. * parse.c (initialize_expout): Likewise. (mark_completion_tag): Likewise. (copy_name): Likewise. (parse_float): Likewise. (type_stack_reserve): Likewise. * ppc-linux-tdep.c (ppc_stap_parse_special_token): Likewise. (ppu2spu_prev_register): Likewise. * ppc-ravenscar-thread.c (supply_register_at_address): Likewise. * printcmd.c (printf_wide_c_string): Likewise. (printf_pointer): Likewise. * probe.c (parse_probes): Likewise. * python/py-cmd.c (gdbpy_parse_command_name): Likewise. (cmdpy_init): Likewise. * python/py-gdb-readline.c (gdbpy_readline_wrapper): Likewise. * python/py-symtab.c (set_sal): Likewise. * python/py-unwind.c (pyuw_sniffer): Likewise. * python/python.c (python_interactive_command): Likewise. (compute_python_string): Likewise. * ravenscar-thread.c (get_running_thread_id): Likewise. * record-full.c (record_full_exec_insn): Likewise. (record_full_core_open_1): Likewise. * regcache.c (regcache_raw_read_signed): Likewise. (regcache_raw_read_unsigned): Likewise. (regcache_cooked_read_signed): Likewise. (regcache_cooked_read_unsigned): Likewise. * remote-fileio.c (remote_fileio_func_open): Likewise. (remote_fileio_func_rename): Likewise. (remote_fileio_func_unlink): Likewise. (remote_fileio_func_stat): Likewise. (remote_fileio_func_system): Likewise. * remote-mips.c (mips_xfer_memory): Likewise. (mips_load_srec): Likewise. (pmon_end_download): Likewise. * remote.c (new_remote_state): Likewise. (map_regcache_remote_table): Likewise. (remote_register_number_and_offset): Likewise. (init_remote_state): Likewise. (get_memory_packet_size): Likewise. (remote_pass_signals): Likewise. (remote_program_signals): Likewise. (remote_start_remote): Likewise. (remote_check_symbols): Likewise. (remote_query_supported): Likewise. (extended_remote_attach): Likewise. (process_g_packet): Likewise. (store_registers_using_G): Likewise. (putpkt_binary): Likewise. (read_frame): Likewise. (compare_sections_command): Likewise. (remote_hostio_pread): Likewise. (remote_hostio_readlink): Likewise. (remote_file_put): Likewise. (remote_file_get): Likewise. (remote_pid_to_exec_file): Likewise. (_initialize_remote): Likewise. * rs6000-aix-tdep.c (rs6000_aix_ld_info_to_xml): Likewise. (rs6000_aix_core_xfer_shared_libraries_aix): Likewise. * rs6000-tdep.c (ppc_displaced_step_copy_insn): Likewise. (bfd_uses_spe_extensions): Likewise. * s390-linux-tdep.c (s390_displaced_step_copy_insn): Likewise. * score-tdep.c (score7_malloc_and_get_memblock): Likewise. * solib-dsbt.c (decode_loadmap): Likewise. (fetch_loadmap): Likewise. (scan_dyntag): Likewise. (enable_break): Likewise. (dsbt_relocate_main_executable): Likewise. * solib-frv.c (fetch_loadmap): Likewise. (enable_break2): Likewise. (frv_relocate_main_executable): Likewise. * solib-spu.c (spu_relocate_main_executable): Likewise. (spu_bfd_open): Likewise. * solib-svr4.c (lm_info_read): Likewise. (read_program_header): Likewise. (find_program_interpreter): Likewise. (scan_dyntag): Likewise. (elf_locate_base): Likewise. (open_symbol_file_object): Likewise. (read_program_headers_from_bfd): Likewise. (svr4_relocate_main_executable): Likewise. * solib-target.c (solib_target_relocate_section_addresses): Likewise. * solib.c (solib_find_1): Likewise. (exec_file_find): Likewise. (solib_find): Likewise. * source.c (openp): Likewise. (print_source_lines_base): Likewise. (forward_search_command): Likewise. * sparc-ravenscar-thread.c (supply_register_at_address): Likewise. * spu-tdep.c (spu2ppu_prev_register): Likewise. (spu_get_overlay_table): Likewise. * stabsread.c (patch_block_stabs): Likewise. (define_symbol): Likewise. (again:): Likewise. (read_member_functions): Likewise. (read_one_struct_field): Likewise. (read_enum_type): Likewise. (common_block_start): Likewise. * stack.c (read_frame_arg): Likewise. (backtrace_command): Likewise. * stap-probe.c (stap_parse_register_operand): Likewise. * symfile.c (syms_from_objfile_1): Likewise. (find_separate_debug_file): Likewise. (load_command): Likewise. (load_progress): Likewise. (load_section_callback): Likewise. (reread_symbols): Likewise. (add_filename_language): Likewise. (allocate_compunit_symtab): Likewise. (read_target_long_array): Likewise. (simple_read_overlay_table): Likewise. * symtab.c (symbol_set_names): Likewise. (resize_symbol_cache): Likewise. (rbreak_command): Likewise. (completion_list_add_name): Likewise. (completion_list_objc_symbol): Likewise. (add_filename_to_list): Likewise. * target-descriptions.c (maint_print_c_tdesc_cmd): Likewise. * target-memory.c (target_write_memory_blocks): Likewise. * target.c (target_read_string): Likewise. (read_whatever_is_readable): Likewise. (target_read_alloc_1): Likewise. (simple_search_memory): Likewise. (target_fileio_read_alloc_1): Likewise. * tilegx-tdep.c (tilegx_push_dummy_call): Likewise. * top.c (command_line_input): Likewise. * tracefile-tfile.c (tfile_fetch_registers): Likewise. * tracefile.c (tracefile_fetch_registers): Likewise. * tracepoint.c (add_memrange): Likewise. (init_collection_list): Likewise. (add_aexpr): Likewise. (trace_dump_actions): Likewise. (parse_trace_status): Likewise. (parse_tracepoint_definition): Likewise. (parse_tsv_definition): Likewise. (parse_static_tracepoint_marker_definition): Likewise. * tui/tui-file.c (tui_sfileopen): Likewise. (tui_file_adjust_strbuf): Likewise. * tui/tui-io.c (tui_expand_tabs): Likewise. * tui/tui-source.c (tui_set_source_content): Likewise. * typeprint.c (find_global_typedef): Likewise. * ui-file.c (do_ui_file_xstrdup): Likewise. (ui_file_obsavestring): Likewise. (mem_file_write): Likewise. * utils.c (make_hex_string): Likewise. (get_regcomp_error): Likewise. (puts_filtered_tabular): Likewise. (gdb_realpath_keepfile): Likewise. (ldirname): Likewise. (gdb_bfd_errmsg): Likewise. (substitute_path_component): Likewise. * valops.c (search_struct_method): Likewise. (find_oload_champ_namespace_loop): Likewise. * valprint.c (print_decimal_chars): Likewise. (read_string): Likewise. (generic_emit_char): Likewise. * varobj.c (varobj_delete): Likewise. (varobj_value_get_print_value): Likewise. * vaxobsd-tdep.c (vaxobsd_sigtramp_sniffer): Likewise. * windows-tdep.c (display_one_tib): Likewise. * xcoffread.c (read_xcoff_symtab): Likewise. (process_xcoff_symbol): Likewise. (swap_sym): Likewise. (scan_xcoff_symtab): Likewise. (xcoff_initial_scan): Likewise. * xml-support.c (gdb_xml_end_element): Likewise. (xml_process_xincludes): Likewise. (xml_fetch_content_from_file): Likewise. * xml-syscall.c (xml_list_of_syscalls): Likewise. * xstormy16-tdep.c (xstormy16_push_dummy_call): Likewise. gdb/gdbserver/ChangeLog: * ax.c (gdb_parse_agent_expr): Add cast to allocation result assignment. (gdb_unparse_agent_expr): Likewise. * hostio.c (require_data): Likewise. (handle_pread): Likewise. * linux-low.c (disable_regset): Likewise. (fetch_register): Likewise. (store_register): Likewise. (get_dynamic): Likewise. (linux_qxfer_libraries_svr4): Likewise. * mem-break.c (delete_fast_tracepoint_jump): Likewise. (set_fast_tracepoint_jump): Likewise. (uninsert_fast_tracepoint_jumps_at): Likewise. (reinsert_fast_tracepoint_jumps_at): Likewise. (validate_inserted_breakpoint): Likewise. (clone_agent_expr): Likewise. * regcache.c (init_register_cache): Likewise. * remote-utils.c (putpkt_binary_1): Likewise. (decode_M_packet): Likewise. (decode_X_packet): Likewise. (look_up_one_symbol): Likewise. (relocate_instruction): Likewise. (monitor_output): Likewise. * server.c (handle_search_memory): Likewise. (handle_qxfer_exec_file): Likewise. (handle_qxfer_libraries): Likewise. (handle_qxfer): Likewise. (handle_query): Likewise. (handle_v_cont): Likewise. (handle_v_run): Likewise. (captured_main): Likewise. * target.c (write_inferior_memory): Likewise. * thread-db.c (try_thread_db_load_from_dir): Likewise. * tracepoint.c (init_trace_buffer): Likewise. (add_tracepoint_action): Likewise. (add_traceframe): Likewise. (add_traceframe_block): Likewise. (cmd_qtdpsrc): Likewise. (cmd_qtdv): Likewise. (cmd_qtstatus): Likewise. (response_source): Likewise. (response_tsv): Likewise. (cmd_qtnotes): Likewise. (gdb_collect): Likewise. (initialize_tracepoint): Likewise.
1483 lines
42 KiB
C
1483 lines
42 KiB
C
/* C preprocessor macro expansion for GDB.
|
||
Copyright (C) 2002-2015 Free Software Foundation, Inc.
|
||
Contributed by Red Hat, Inc.
|
||
|
||
This file is part of GDB.
|
||
|
||
This program is free software; you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation; either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
||
|
||
#include "defs.h"
|
||
#include "gdb_obstack.h"
|
||
#include "bcache.h"
|
||
#include "macrotab.h"
|
||
#include "macroexp.h"
|
||
#include "c-lang.h"
|
||
|
||
|
||
|
||
/* A resizeable, substringable string type. */
|
||
|
||
|
||
/* A string type that we can resize, quickly append to, and use to
|
||
refer to substrings of other strings. */
|
||
struct macro_buffer
|
||
{
|
||
/* An array of characters. The first LEN bytes are the real text,
|
||
but there are SIZE bytes allocated to the array. If SIZE is
|
||
zero, then this doesn't point to a malloc'ed block. If SHARED is
|
||
non-zero, then this buffer is actually a pointer into some larger
|
||
string, and we shouldn't append characters to it, etc. Because
|
||
of sharing, we can't assume in general that the text is
|
||
null-terminated. */
|
||
char *text;
|
||
|
||
/* The number of characters in the string. */
|
||
int len;
|
||
|
||
/* The number of characters allocated to the string. If SHARED is
|
||
non-zero, this is meaningless; in this case, we set it to zero so
|
||
that any "do we have room to append something?" tests will fail,
|
||
so we don't always have to check SHARED before using this field. */
|
||
int size;
|
||
|
||
/* Zero if TEXT can be safely realloc'ed (i.e., it's its own malloc
|
||
block). Non-zero if TEXT is actually pointing into the middle of
|
||
some other block, and we shouldn't reallocate it. */
|
||
int shared;
|
||
|
||
/* For detecting token splicing.
|
||
|
||
This is the index in TEXT of the first character of the token
|
||
that abuts the end of TEXT. If TEXT contains no tokens, then we
|
||
set this equal to LEN. If TEXT ends in whitespace, then there is
|
||
no token abutting the end of TEXT (it's just whitespace), and
|
||
again, we set this equal to LEN. We set this to -1 if we don't
|
||
know the nature of TEXT. */
|
||
int last_token;
|
||
|
||
/* If this buffer is holding the result from get_token, then this
|
||
is non-zero if it is an identifier token, zero otherwise. */
|
||
int is_identifier;
|
||
};
|
||
|
||
|
||
/* Set the macro buffer *B to the empty string, guessing that its
|
||
final contents will fit in N bytes. (It'll get resized if it
|
||
doesn't, so the guess doesn't have to be right.) Allocate the
|
||
initial storage with xmalloc. */
|
||
static void
|
||
init_buffer (struct macro_buffer *b, int n)
|
||
{
|
||
b->size = n;
|
||
if (n > 0)
|
||
b->text = (char *) xmalloc (n);
|
||
else
|
||
b->text = NULL;
|
||
b->len = 0;
|
||
b->shared = 0;
|
||
b->last_token = -1;
|
||
}
|
||
|
||
|
||
/* Set the macro buffer *BUF to refer to the LEN bytes at ADDR, as a
|
||
shared substring. */
|
||
static void
|
||
init_shared_buffer (struct macro_buffer *buf, char *addr, int len)
|
||
{
|
||
buf->text = addr;
|
||
buf->len = len;
|
||
buf->shared = 1;
|
||
buf->size = 0;
|
||
buf->last_token = -1;
|
||
}
|
||
|
||
|
||
/* Free the text of the buffer B. Raise an error if B is shared. */
|
||
static void
|
||
free_buffer (struct macro_buffer *b)
|
||
{
|
||
gdb_assert (! b->shared);
|
||
if (b->size)
|
||
xfree (b->text);
|
||
}
|
||
|
||
/* Like free_buffer, but return the text as an xstrdup()d string.
|
||
This only exists to try to make the API relatively clean. */
|
||
|
||
static char *
|
||
free_buffer_return_text (struct macro_buffer *b)
|
||
{
|
||
gdb_assert (! b->shared);
|
||
gdb_assert (b->size);
|
||
/* Nothing to do. */
|
||
return b->text;
|
||
}
|
||
|
||
/* A cleanup function for macro buffers. */
|
||
static void
|
||
cleanup_macro_buffer (void *untyped_buf)
|
||
{
|
||
free_buffer ((struct macro_buffer *) untyped_buf);
|
||
}
|
||
|
||
|
||
/* Resize the buffer B to be at least N bytes long. Raise an error if
|
||
B shouldn't be resized. */
|
||
static void
|
||
resize_buffer (struct macro_buffer *b, int n)
|
||
{
|
||
/* We shouldn't be trying to resize shared strings. */
|
||
gdb_assert (! b->shared);
|
||
|
||
if (b->size == 0)
|
||
b->size = n;
|
||
else
|
||
while (b->size <= n)
|
||
b->size *= 2;
|
||
|
||
b->text = (char *) xrealloc (b->text, b->size);
|
||
}
|
||
|
||
|
||
/* Append the character C to the buffer B. */
|
||
static void
|
||
appendc (struct macro_buffer *b, int c)
|
||
{
|
||
int new_len = b->len + 1;
|
||
|
||
if (new_len > b->size)
|
||
resize_buffer (b, new_len);
|
||
|
||
b->text[b->len] = c;
|
||
b->len = new_len;
|
||
}
|
||
|
||
|
||
/* Append the LEN bytes at ADDR to the buffer B. */
|
||
static void
|
||
appendmem (struct macro_buffer *b, char *addr, int len)
|
||
{
|
||
int new_len = b->len + len;
|
||
|
||
if (new_len > b->size)
|
||
resize_buffer (b, new_len);
|
||
|
||
memcpy (b->text + b->len, addr, len);
|
||
b->len = new_len;
|
||
}
|
||
|
||
|
||
|
||
/* Recognizing preprocessor tokens. */
|
||
|
||
|
||
int
|
||
macro_is_whitespace (int c)
|
||
{
|
||
return (c == ' '
|
||
|| c == '\t'
|
||
|| c == '\n'
|
||
|| c == '\v'
|
||
|| c == '\f');
|
||
}
|
||
|
||
|
||
int
|
||
macro_is_digit (int c)
|
||
{
|
||
return ('0' <= c && c <= '9');
|
||
}
|
||
|
||
|
||
int
|
||
macro_is_identifier_nondigit (int c)
|
||
{
|
||
return (c == '_'
|
||
|| ('a' <= c && c <= 'z')
|
||
|| ('A' <= c && c <= 'Z'));
|
||
}
|
||
|
||
|
||
static void
|
||
set_token (struct macro_buffer *tok, char *start, char *end)
|
||
{
|
||
init_shared_buffer (tok, start, end - start);
|
||
tok->last_token = 0;
|
||
|
||
/* Presumed; get_identifier may overwrite this. */
|
||
tok->is_identifier = 0;
|
||
}
|
||
|
||
|
||
static int
|
||
get_comment (struct macro_buffer *tok, char *p, char *end)
|
||
{
|
||
if (p + 2 > end)
|
||
return 0;
|
||
else if (p[0] == '/'
|
||
&& p[1] == '*')
|
||
{
|
||
char *tok_start = p;
|
||
|
||
p += 2;
|
||
|
||
for (; p < end; p++)
|
||
if (p + 2 <= end
|
||
&& p[0] == '*'
|
||
&& p[1] == '/')
|
||
{
|
||
p += 2;
|
||
set_token (tok, tok_start, p);
|
||
return 1;
|
||
}
|
||
|
||
error (_("Unterminated comment in macro expansion."));
|
||
}
|
||
else if (p[0] == '/'
|
||
&& p[1] == '/')
|
||
{
|
||
char *tok_start = p;
|
||
|
||
p += 2;
|
||
for (; p < end; p++)
|
||
if (*p == '\n')
|
||
break;
|
||
|
||
set_token (tok, tok_start, p);
|
||
return 1;
|
||
}
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
|
||
static int
|
||
get_identifier (struct macro_buffer *tok, char *p, char *end)
|
||
{
|
||
if (p < end
|
||
&& macro_is_identifier_nondigit (*p))
|
||
{
|
||
char *tok_start = p;
|
||
|
||
while (p < end
|
||
&& (macro_is_identifier_nondigit (*p)
|
||
|| macro_is_digit (*p)))
|
||
p++;
|
||
|
||
set_token (tok, tok_start, p);
|
||
tok->is_identifier = 1;
|
||
return 1;
|
||
}
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
|
||
static int
|
||
get_pp_number (struct macro_buffer *tok, char *p, char *end)
|
||
{
|
||
if (p < end
|
||
&& (macro_is_digit (*p)
|
||
|| (*p == '.'
|
||
&& p + 2 <= end
|
||
&& macro_is_digit (p[1]))))
|
||
{
|
||
char *tok_start = p;
|
||
|
||
while (p < end)
|
||
{
|
||
if (p + 2 <= end
|
||
&& strchr ("eEpP", *p)
|
||
&& (p[1] == '+' || p[1] == '-'))
|
||
p += 2;
|
||
else if (macro_is_digit (*p)
|
||
|| macro_is_identifier_nondigit (*p)
|
||
|| *p == '.')
|
||
p++;
|
||
else
|
||
break;
|
||
}
|
||
|
||
set_token (tok, tok_start, p);
|
||
return 1;
|
||
}
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
/* If the text starting at P going up to (but not including) END
|
||
starts with a character constant, set *TOK to point to that
|
||
character constant, and return 1. Otherwise, return zero.
|
||
Signal an error if it contains a malformed or incomplete character
|
||
constant. */
|
||
static int
|
||
get_character_constant (struct macro_buffer *tok, char *p, char *end)
|
||
{
|
||
/* ISO/IEC 9899:1999 (E) Section 6.4.4.4 paragraph 1
|
||
But of course, what really matters is that we handle it the same
|
||
way GDB's C/C++ lexer does. So we call parse_escape in utils.c
|
||
to handle escape sequences. */
|
||
if ((p + 1 <= end && *p == '\'')
|
||
|| (p + 2 <= end
|
||
&& (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
|
||
&& p[1] == '\''))
|
||
{
|
||
char *tok_start = p;
|
||
int char_count = 0;
|
||
|
||
if (*p == '\'')
|
||
p++;
|
||
else if (*p == 'L' || *p == 'u' || *p == 'U')
|
||
p += 2;
|
||
else
|
||
gdb_assert_not_reached ("unexpected character constant");
|
||
|
||
for (;;)
|
||
{
|
||
if (p >= end)
|
||
error (_("Unmatched single quote."));
|
||
else if (*p == '\'')
|
||
{
|
||
if (!char_count)
|
||
error (_("A character constant must contain at least one "
|
||
"character."));
|
||
p++;
|
||
break;
|
||
}
|
||
else if (*p == '\\')
|
||
{
|
||
const char *s, *o;
|
||
|
||
s = o = ++p;
|
||
char_count += c_parse_escape (&s, NULL);
|
||
p += s - o;
|
||
}
|
||
else
|
||
{
|
||
p++;
|
||
char_count++;
|
||
}
|
||
}
|
||
|
||
set_token (tok, tok_start, p);
|
||
return 1;
|
||
}
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* If the text starting at P going up to (but not including) END
|
||
starts with a string literal, set *TOK to point to that string
|
||
literal, and return 1. Otherwise, return zero. Signal an error if
|
||
it contains a malformed or incomplete string literal. */
|
||
static int
|
||
get_string_literal (struct macro_buffer *tok, char *p, char *end)
|
||
{
|
||
if ((p + 1 <= end
|
||
&& *p == '"')
|
||
|| (p + 2 <= end
|
||
&& (p[0] == 'L' || p[0] == 'u' || p[0] == 'U')
|
||
&& p[1] == '"'))
|
||
{
|
||
char *tok_start = p;
|
||
|
||
if (*p == '"')
|
||
p++;
|
||
else if (*p == 'L' || *p == 'u' || *p == 'U')
|
||
p += 2;
|
||
else
|
||
gdb_assert_not_reached ("unexpected string literal");
|
||
|
||
for (;;)
|
||
{
|
||
if (p >= end)
|
||
error (_("Unterminated string in expression."));
|
||
else if (*p == '"')
|
||
{
|
||
p++;
|
||
break;
|
||
}
|
||
else if (*p == '\n')
|
||
error (_("Newline characters may not appear in string "
|
||
"constants."));
|
||
else if (*p == '\\')
|
||
{
|
||
const char *s, *o;
|
||
|
||
s = o = ++p;
|
||
c_parse_escape (&s, NULL);
|
||
p += s - o;
|
||
}
|
||
else
|
||
p++;
|
||
}
|
||
|
||
set_token (tok, tok_start, p);
|
||
return 1;
|
||
}
|
||
else
|
||
return 0;
|
||
}
|
||
|
||
|
||
static int
|
||
get_punctuator (struct macro_buffer *tok, char *p, char *end)
|
||
{
|
||
/* Here, speed is much less important than correctness and clarity. */
|
||
|
||
/* ISO/IEC 9899:1999 (E) Section 6.4.6 Paragraph 1.
|
||
Note that this table is ordered in a special way. A punctuator
|
||
which is a prefix of another punctuator must appear after its
|
||
"extension". Otherwise, the wrong token will be returned. */
|
||
static const char * const punctuators[] = {
|
||
"[", "]", "(", ")", "{", "}", "?", ";", ",", "~",
|
||
"...", ".",
|
||
"->", "--", "-=", "-",
|
||
"++", "+=", "+",
|
||
"*=", "*",
|
||
"!=", "!",
|
||
"&&", "&=", "&",
|
||
"/=", "/",
|
||
"%>", "%:%:", "%:", "%=", "%",
|
||
"^=", "^",
|
||
"##", "#",
|
||
":>", ":",
|
||
"||", "|=", "|",
|
||
"<<=", "<<", "<=", "<:", "<%", "<",
|
||
">>=", ">>", ">=", ">",
|
||
"==", "=",
|
||
0
|
||
};
|
||
|
||
int i;
|
||
|
||
if (p + 1 <= end)
|
||
{
|
||
for (i = 0; punctuators[i]; i++)
|
||
{
|
||
const char *punctuator = punctuators[i];
|
||
|
||
if (p[0] == punctuator[0])
|
||
{
|
||
int len = strlen (punctuator);
|
||
|
||
if (p + len <= end
|
||
&& ! memcmp (p, punctuator, len))
|
||
{
|
||
set_token (tok, p, p + len);
|
||
return 1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Peel the next preprocessor token off of SRC, and put it in TOK.
|
||
Mutate TOK to refer to the first token in SRC, and mutate SRC to
|
||
refer to the text after that token. SRC must be a shared buffer;
|
||
the resulting TOK will be shared, pointing into the same string SRC
|
||
does. Initialize TOK's last_token field. Return non-zero if we
|
||
succeed, or 0 if we didn't find any more tokens in SRC. */
|
||
static int
|
||
get_token (struct macro_buffer *tok,
|
||
struct macro_buffer *src)
|
||
{
|
||
char *p = src->text;
|
||
char *end = p + src->len;
|
||
|
||
gdb_assert (src->shared);
|
||
|
||
/* From the ISO C standard, ISO/IEC 9899:1999 (E), section 6.4:
|
||
|
||
preprocessing-token:
|
||
header-name
|
||
identifier
|
||
pp-number
|
||
character-constant
|
||
string-literal
|
||
punctuator
|
||
each non-white-space character that cannot be one of the above
|
||
|
||
We don't have to deal with header-name tokens, since those can
|
||
only occur after a #include, which we will never see. */
|
||
|
||
while (p < end)
|
||
if (macro_is_whitespace (*p))
|
||
p++;
|
||
else if (get_comment (tok, p, end))
|
||
p += tok->len;
|
||
else if (get_pp_number (tok, p, end)
|
||
|| get_character_constant (tok, p, end)
|
||
|| get_string_literal (tok, p, end)
|
||
/* Note: the grammar in the standard seems to be
|
||
ambiguous: L'x' can be either a wide character
|
||
constant, or an identifier followed by a normal
|
||
character constant. By trying `get_identifier' after
|
||
we try get_character_constant and get_string_literal,
|
||
we give the wide character syntax precedence. Now,
|
||
since GDB doesn't handle wide character constants
|
||
anyway, is this the right thing to do? */
|
||
|| get_identifier (tok, p, end)
|
||
|| get_punctuator (tok, p, end))
|
||
{
|
||
/* How many characters did we consume, including whitespace? */
|
||
int consumed = p - src->text + tok->len;
|
||
|
||
src->text += consumed;
|
||
src->len -= consumed;
|
||
return 1;
|
||
}
|
||
else
|
||
{
|
||
/* We have found a "non-whitespace character that cannot be
|
||
one of the above." Make a token out of it. */
|
||
int consumed;
|
||
|
||
set_token (tok, p, p + 1);
|
||
consumed = p - src->text + tok->len;
|
||
src->text += consumed;
|
||
src->len -= consumed;
|
||
return 1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
/* Appending token strings, with and without splicing */
|
||
|
||
|
||
/* Append the macro buffer SRC to the end of DEST, and ensure that
|
||
doing so doesn't splice the token at the end of SRC with the token
|
||
at the beginning of DEST. SRC and DEST must have their last_token
|
||
fields set. Upon return, DEST's last_token field is set correctly.
|
||
|
||
For example:
|
||
|
||
If DEST is "(" and SRC is "y", then we can return with
|
||
DEST set to "(y" --- we've simply appended the two buffers.
|
||
|
||
However, if DEST is "x" and SRC is "y", then we must not return
|
||
with DEST set to "xy" --- that would splice the two tokens "x" and
|
||
"y" together to make a single token "xy". However, it would be
|
||
fine to return with DEST set to "x y". Similarly, "<" and "<" must
|
||
yield "< <", not "<<", etc. */
|
||
static void
|
||
append_tokens_without_splicing (struct macro_buffer *dest,
|
||
struct macro_buffer *src)
|
||
{
|
||
int original_dest_len = dest->len;
|
||
struct macro_buffer dest_tail, new_token;
|
||
|
||
gdb_assert (src->last_token != -1);
|
||
gdb_assert (dest->last_token != -1);
|
||
|
||
/* First, just try appending the two, and call get_token to see if
|
||
we got a splice. */
|
||
appendmem (dest, src->text, src->len);
|
||
|
||
/* If DEST originally had no token abutting its end, then we can't
|
||
have spliced anything, so we're done. */
|
||
if (dest->last_token == original_dest_len)
|
||
{
|
||
dest->last_token = original_dest_len + src->last_token;
|
||
return;
|
||
}
|
||
|
||
/* Set DEST_TAIL to point to the last token in DEST, followed by
|
||
all the stuff we just appended. */
|
||
init_shared_buffer (&dest_tail,
|
||
dest->text + dest->last_token,
|
||
dest->len - dest->last_token);
|
||
|
||
/* Re-parse DEST's last token. We know that DEST used to contain
|
||
at least one token, so if it doesn't contain any after the
|
||
append, then we must have spliced "/" and "*" or "/" and "/" to
|
||
make a comment start. (Just for the record, I got this right
|
||
the first time. This is not a bug fix.) */
|
||
if (get_token (&new_token, &dest_tail)
|
||
&& (new_token.text + new_token.len
|
||
== dest->text + original_dest_len))
|
||
{
|
||
/* No splice, so we're done. */
|
||
dest->last_token = original_dest_len + src->last_token;
|
||
return;
|
||
}
|
||
|
||
/* Okay, a simple append caused a splice. Let's chop dest back to
|
||
its original length and try again, but separate the texts with a
|
||
space. */
|
||
dest->len = original_dest_len;
|
||
appendc (dest, ' ');
|
||
appendmem (dest, src->text, src->len);
|
||
|
||
init_shared_buffer (&dest_tail,
|
||
dest->text + dest->last_token,
|
||
dest->len - dest->last_token);
|
||
|
||
/* Try to re-parse DEST's last token, as above. */
|
||
if (get_token (&new_token, &dest_tail)
|
||
&& (new_token.text + new_token.len
|
||
== dest->text + original_dest_len))
|
||
{
|
||
/* No splice, so we're done. */
|
||
dest->last_token = original_dest_len + 1 + src->last_token;
|
||
return;
|
||
}
|
||
|
||
/* As far as I know, there's no case where inserting a space isn't
|
||
enough to prevent a splice. */
|
||
internal_error (__FILE__, __LINE__,
|
||
_("unable to avoid splicing tokens during macro expansion"));
|
||
}
|
||
|
||
/* Stringify an argument, and insert it into DEST. ARG is the text to
|
||
stringify; it is LEN bytes long. */
|
||
|
||
static void
|
||
stringify (struct macro_buffer *dest, const char *arg, int len)
|
||
{
|
||
/* Trim initial whitespace from ARG. */
|
||
while (len > 0 && macro_is_whitespace (*arg))
|
||
{
|
||
++arg;
|
||
--len;
|
||
}
|
||
|
||
/* Trim trailing whitespace from ARG. */
|
||
while (len > 0 && macro_is_whitespace (arg[len - 1]))
|
||
--len;
|
||
|
||
/* Insert the string. */
|
||
appendc (dest, '"');
|
||
while (len > 0)
|
||
{
|
||
/* We could try to handle strange cases here, like control
|
||
characters, but there doesn't seem to be much point. */
|
||
if (macro_is_whitespace (*arg))
|
||
{
|
||
/* Replace a sequence of whitespace with a single space. */
|
||
appendc (dest, ' ');
|
||
while (len > 1 && macro_is_whitespace (arg[1]))
|
||
{
|
||
++arg;
|
||
--len;
|
||
}
|
||
}
|
||
else if (*arg == '\\' || *arg == '"')
|
||
{
|
||
appendc (dest, '\\');
|
||
appendc (dest, *arg);
|
||
}
|
||
else
|
||
appendc (dest, *arg);
|
||
++arg;
|
||
--len;
|
||
}
|
||
appendc (dest, '"');
|
||
dest->last_token = dest->len;
|
||
}
|
||
|
||
/* See macroexp.h. */
|
||
|
||
char *
|
||
macro_stringify (const char *str)
|
||
{
|
||
struct macro_buffer buffer;
|
||
int len = strlen (str);
|
||
|
||
init_buffer (&buffer, len);
|
||
stringify (&buffer, str, len);
|
||
appendc (&buffer, '\0');
|
||
|
||
return free_buffer_return_text (&buffer);
|
||
}
|
||
|
||
|
||
/* Expanding macros! */
|
||
|
||
|
||
/* A singly-linked list of the names of the macros we are currently
|
||
expanding --- for detecting expansion loops. */
|
||
struct macro_name_list {
|
||
const char *name;
|
||
struct macro_name_list *next;
|
||
};
|
||
|
||
|
||
/* Return non-zero if we are currently expanding the macro named NAME,
|
||
according to LIST; otherwise, return zero.
|
||
|
||
You know, it would be possible to get rid of all the NO_LOOP
|
||
arguments to these functions by simply generating a new lookup
|
||
function and baton which refuses to find the definition for a
|
||
particular macro, and otherwise delegates the decision to another
|
||
function/baton pair. But that makes the linked list of excluded
|
||
macros chained through untyped baton pointers, which will make it
|
||
harder to debug. :( */
|
||
static int
|
||
currently_rescanning (struct macro_name_list *list, const char *name)
|
||
{
|
||
for (; list; list = list->next)
|
||
if (strcmp (name, list->name) == 0)
|
||
return 1;
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Gather the arguments to a macro expansion.
|
||
|
||
NAME is the name of the macro being invoked. (It's only used for
|
||
printing error messages.)
|
||
|
||
Assume that SRC is the text of the macro invocation immediately
|
||
following the macro name. For example, if we're processing the
|
||
text foo(bar, baz), then NAME would be foo and SRC will be (bar,
|
||
baz).
|
||
|
||
If SRC doesn't start with an open paren ( token at all, return
|
||
zero, leave SRC unchanged, and don't set *ARGC_P to anything.
|
||
|
||
If SRC doesn't contain a properly terminated argument list, then
|
||
raise an error.
|
||
|
||
For a variadic macro, NARGS holds the number of formal arguments to
|
||
the macro. For a GNU-style variadic macro, this should be the
|
||
number of named arguments. For a non-variadic macro, NARGS should
|
||
be -1.
|
||
|
||
Otherwise, return a pointer to the first element of an array of
|
||
macro buffers referring to the argument texts, and set *ARGC_P to
|
||
the number of arguments we found --- the number of elements in the
|
||
array. The macro buffers share their text with SRC, and their
|
||
last_token fields are initialized. The array is allocated with
|
||
xmalloc, and the caller is responsible for freeing it.
|
||
|
||
NOTE WELL: if SRC starts with a open paren ( token followed
|
||
immediately by a close paren ) token (e.g., the invocation looks
|
||
like "foo()"), we treat that as one argument, which happens to be
|
||
the empty list of tokens. The caller should keep in mind that such
|
||
a sequence of tokens is a valid way to invoke one-parameter
|
||
function-like macros, but also a valid way to invoke zero-parameter
|
||
function-like macros. Eeew.
|
||
|
||
Consume the tokens from SRC; after this call, SRC contains the text
|
||
following the invocation. */
|
||
|
||
static struct macro_buffer *
|
||
gather_arguments (const char *name, struct macro_buffer *src,
|
||
int nargs, int *argc_p)
|
||
{
|
||
struct macro_buffer tok;
|
||
int args_len, args_size;
|
||
struct macro_buffer *args = NULL;
|
||
struct cleanup *back_to = make_cleanup (free_current_contents, &args);
|
||
|
||
/* Does SRC start with an opening paren token? Read from a copy of
|
||
SRC, so SRC itself is unaffected if we don't find an opening
|
||
paren. */
|
||
{
|
||
struct macro_buffer temp;
|
||
|
||
init_shared_buffer (&temp, src->text, src->len);
|
||
|
||
if (! get_token (&tok, &temp)
|
||
|| tok.len != 1
|
||
|| tok.text[0] != '(')
|
||
{
|
||
discard_cleanups (back_to);
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
/* Consume SRC's opening paren. */
|
||
get_token (&tok, src);
|
||
|
||
args_len = 0;
|
||
args_size = 6;
|
||
args = XNEWVEC (struct macro_buffer, args_size);
|
||
|
||
for (;;)
|
||
{
|
||
struct macro_buffer *arg;
|
||
int depth;
|
||
|
||
/* Make sure we have room for the next argument. */
|
||
if (args_len >= args_size)
|
||
{
|
||
args_size *= 2;
|
||
args = XRESIZEVEC (struct macro_buffer, args, args_size);
|
||
}
|
||
|
||
/* Initialize the next argument. */
|
||
arg = &args[args_len++];
|
||
set_token (arg, src->text, src->text);
|
||
|
||
/* Gather the argument's tokens. */
|
||
depth = 0;
|
||
for (;;)
|
||
{
|
||
if (! get_token (&tok, src))
|
||
error (_("Malformed argument list for macro `%s'."), name);
|
||
|
||
/* Is tok an opening paren? */
|
||
if (tok.len == 1 && tok.text[0] == '(')
|
||
depth++;
|
||
|
||
/* Is tok is a closing paren? */
|
||
else if (tok.len == 1 && tok.text[0] == ')')
|
||
{
|
||
/* If it's a closing paren at the top level, then that's
|
||
the end of the argument list. */
|
||
if (depth == 0)
|
||
{
|
||
/* In the varargs case, the last argument may be
|
||
missing. Add an empty argument in this case. */
|
||
if (nargs != -1 && args_len == nargs - 1)
|
||
{
|
||
/* Make sure we have room for the argument. */
|
||
if (args_len >= args_size)
|
||
{
|
||
args_size++;
|
||
args = XRESIZEVEC (struct macro_buffer, args,
|
||
args_size);
|
||
}
|
||
arg = &args[args_len++];
|
||
set_token (arg, src->text, src->text);
|
||
}
|
||
|
||
discard_cleanups (back_to);
|
||
*argc_p = args_len;
|
||
return args;
|
||
}
|
||
|
||
depth--;
|
||
}
|
||
|
||
/* If tok is a comma at top level, then that's the end of
|
||
the current argument. However, if we are handling a
|
||
variadic macro and we are computing the last argument, we
|
||
want to include the comma and remaining tokens. */
|
||
else if (tok.len == 1 && tok.text[0] == ',' && depth == 0
|
||
&& (nargs == -1 || args_len < nargs))
|
||
break;
|
||
|
||
/* Extend the current argument to enclose this token. If
|
||
this is the current argument's first token, leave out any
|
||
leading whitespace, just for aesthetics. */
|
||
if (arg->len == 0)
|
||
{
|
||
arg->text = tok.text;
|
||
arg->len = tok.len;
|
||
arg->last_token = 0;
|
||
}
|
||
else
|
||
{
|
||
arg->len = (tok.text + tok.len) - arg->text;
|
||
arg->last_token = tok.text - arg->text;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
/* The `expand' and `substitute_args' functions both invoke `scan'
|
||
recursively, so we need a forward declaration somewhere. */
|
||
static void scan (struct macro_buffer *dest,
|
||
struct macro_buffer *src,
|
||
struct macro_name_list *no_loop,
|
||
macro_lookup_ftype *lookup_func,
|
||
void *lookup_baton);
|
||
|
||
|
||
/* A helper function for substitute_args.
|
||
|
||
ARGV is a vector of all the arguments; ARGC is the number of
|
||
arguments. IS_VARARGS is true if the macro being substituted is a
|
||
varargs macro; in this case VA_ARG_NAME is the name of the
|
||
"variable" argument. VA_ARG_NAME is ignored if IS_VARARGS is
|
||
false.
|
||
|
||
If the token TOK is the name of a parameter, return the parameter's
|
||
index. If TOK is not an argument, return -1. */
|
||
|
||
static int
|
||
find_parameter (const struct macro_buffer *tok,
|
||
int is_varargs, const struct macro_buffer *va_arg_name,
|
||
int argc, const char * const *argv)
|
||
{
|
||
int i;
|
||
|
||
if (! tok->is_identifier)
|
||
return -1;
|
||
|
||
for (i = 0; i < argc; ++i)
|
||
if (tok->len == strlen (argv[i])
|
||
&& !memcmp (tok->text, argv[i], tok->len))
|
||
return i;
|
||
|
||
if (is_varargs && tok->len == va_arg_name->len
|
||
&& ! memcmp (tok->text, va_arg_name->text, tok->len))
|
||
return argc - 1;
|
||
|
||
return -1;
|
||
}
|
||
|
||
/* Given the macro definition DEF, being invoked with the actual
|
||
arguments given by ARGC and ARGV, substitute the arguments into the
|
||
replacement list, and store the result in DEST.
|
||
|
||
IS_VARARGS should be true if DEF is a varargs macro. In this case,
|
||
VA_ARG_NAME should be the name of the "variable" argument -- either
|
||
__VA_ARGS__ for c99-style varargs, or the final argument name, for
|
||
GNU-style varargs. If IS_VARARGS is false, this parameter is
|
||
ignored.
|
||
|
||
If it is necessary to expand macro invocations in one of the
|
||
arguments, use LOOKUP_FUNC and LOOKUP_BATON to find the macro
|
||
definitions, and don't expand invocations of the macros listed in
|
||
NO_LOOP. */
|
||
|
||
static void
|
||
substitute_args (struct macro_buffer *dest,
|
||
struct macro_definition *def,
|
||
int is_varargs, const struct macro_buffer *va_arg_name,
|
||
int argc, struct macro_buffer *argv,
|
||
struct macro_name_list *no_loop,
|
||
macro_lookup_ftype *lookup_func,
|
||
void *lookup_baton)
|
||
{
|
||
/* A macro buffer for the macro's replacement list. */
|
||
struct macro_buffer replacement_list;
|
||
/* The token we are currently considering. */
|
||
struct macro_buffer tok;
|
||
/* The replacement list's pointer from just before TOK was lexed. */
|
||
char *original_rl_start;
|
||
/* We have a single lookahead token to handle token splicing. */
|
||
struct macro_buffer lookahead;
|
||
/* The lookahead token might not be valid. */
|
||
int lookahead_valid;
|
||
/* The replacement list's pointer from just before LOOKAHEAD was
|
||
lexed. */
|
||
char *lookahead_rl_start;
|
||
|
||
init_shared_buffer (&replacement_list, (char *) def->replacement,
|
||
strlen (def->replacement));
|
||
|
||
gdb_assert (dest->len == 0);
|
||
dest->last_token = 0;
|
||
|
||
original_rl_start = replacement_list.text;
|
||
if (! get_token (&tok, &replacement_list))
|
||
return;
|
||
lookahead_rl_start = replacement_list.text;
|
||
lookahead_valid = get_token (&lookahead, &replacement_list);
|
||
|
||
for (;;)
|
||
{
|
||
/* Just for aesthetics. If we skipped some whitespace, copy
|
||
that to DEST. */
|
||
if (tok.text > original_rl_start)
|
||
{
|
||
appendmem (dest, original_rl_start, tok.text - original_rl_start);
|
||
dest->last_token = dest->len;
|
||
}
|
||
|
||
/* Is this token the stringification operator? */
|
||
if (tok.len == 1
|
||
&& tok.text[0] == '#')
|
||
{
|
||
int arg;
|
||
|
||
if (!lookahead_valid)
|
||
error (_("Stringification operator requires an argument."));
|
||
|
||
arg = find_parameter (&lookahead, is_varargs, va_arg_name,
|
||
def->argc, def->argv);
|
||
if (arg == -1)
|
||
error (_("Argument to stringification operator must name "
|
||
"a macro parameter."));
|
||
|
||
stringify (dest, argv[arg].text, argv[arg].len);
|
||
|
||
/* Read one token and let the loop iteration code handle the
|
||
rest. */
|
||
lookahead_rl_start = replacement_list.text;
|
||
lookahead_valid = get_token (&lookahead, &replacement_list);
|
||
}
|
||
/* Is this token the splicing operator? */
|
||
else if (tok.len == 2
|
||
&& tok.text[0] == '#'
|
||
&& tok.text[1] == '#')
|
||
error (_("Stray splicing operator"));
|
||
/* Is the next token the splicing operator? */
|
||
else if (lookahead_valid
|
||
&& lookahead.len == 2
|
||
&& lookahead.text[0] == '#'
|
||
&& lookahead.text[1] == '#')
|
||
{
|
||
int finished = 0;
|
||
int prev_was_comma = 0;
|
||
|
||
/* Note that GCC warns if the result of splicing is not a
|
||
token. In the debugger there doesn't seem to be much
|
||
benefit from doing this. */
|
||
|
||
/* Insert the first token. */
|
||
if (tok.len == 1 && tok.text[0] == ',')
|
||
prev_was_comma = 1;
|
||
else
|
||
{
|
||
int arg = find_parameter (&tok, is_varargs, va_arg_name,
|
||
def->argc, def->argv);
|
||
|
||
if (arg != -1)
|
||
appendmem (dest, argv[arg].text, argv[arg].len);
|
||
else
|
||
appendmem (dest, tok.text, tok.len);
|
||
}
|
||
|
||
/* Apply a possible sequence of ## operators. */
|
||
for (;;)
|
||
{
|
||
if (! get_token (&tok, &replacement_list))
|
||
error (_("Splicing operator at end of macro"));
|
||
|
||
/* Handle a comma before a ##. If we are handling
|
||
varargs, and the token on the right hand side is the
|
||
varargs marker, and the final argument is empty or
|
||
missing, then drop the comma. This is a GNU
|
||
extension. There is one ambiguous case here,
|
||
involving pedantic behavior with an empty argument,
|
||
but we settle that in favor of GNU-style (GCC uses an
|
||
option). If we aren't dealing with varargs, we
|
||
simply insert the comma. */
|
||
if (prev_was_comma)
|
||
{
|
||
if (! (is_varargs
|
||
&& tok.len == va_arg_name->len
|
||
&& !memcmp (tok.text, va_arg_name->text, tok.len)
|
||
&& argv[argc - 1].len == 0))
|
||
appendmem (dest, ",", 1);
|
||
prev_was_comma = 0;
|
||
}
|
||
|
||
/* Insert the token. If it is a parameter, insert the
|
||
argument. If it is a comma, treat it specially. */
|
||
if (tok.len == 1 && tok.text[0] == ',')
|
||
prev_was_comma = 1;
|
||
else
|
||
{
|
||
int arg = find_parameter (&tok, is_varargs, va_arg_name,
|
||
def->argc, def->argv);
|
||
|
||
if (arg != -1)
|
||
appendmem (dest, argv[arg].text, argv[arg].len);
|
||
else
|
||
appendmem (dest, tok.text, tok.len);
|
||
}
|
||
|
||
/* Now read another token. If it is another splice, we
|
||
loop. */
|
||
original_rl_start = replacement_list.text;
|
||
if (! get_token (&tok, &replacement_list))
|
||
{
|
||
finished = 1;
|
||
break;
|
||
}
|
||
|
||
if (! (tok.len == 2
|
||
&& tok.text[0] == '#'
|
||
&& tok.text[1] == '#'))
|
||
break;
|
||
}
|
||
|
||
if (prev_was_comma)
|
||
{
|
||
/* We saw a comma. Insert it now. */
|
||
appendmem (dest, ",", 1);
|
||
}
|
||
|
||
dest->last_token = dest->len;
|
||
if (finished)
|
||
lookahead_valid = 0;
|
||
else
|
||
{
|
||
/* Set up for the loop iterator. */
|
||
lookahead = tok;
|
||
lookahead_rl_start = original_rl_start;
|
||
lookahead_valid = 1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
/* Is this token an identifier? */
|
||
int substituted = 0;
|
||
int arg = find_parameter (&tok, is_varargs, va_arg_name,
|
||
def->argc, def->argv);
|
||
|
||
if (arg != -1)
|
||
{
|
||
struct macro_buffer arg_src;
|
||
|
||
/* Expand any macro invocations in the argument text,
|
||
and append the result to dest. Remember that scan
|
||
mutates its source, so we need to scan a new buffer
|
||
referring to the argument's text, not the argument
|
||
itself. */
|
||
init_shared_buffer (&arg_src, argv[arg].text, argv[arg].len);
|
||
scan (dest, &arg_src, no_loop, lookup_func, lookup_baton);
|
||
substituted = 1;
|
||
}
|
||
|
||
/* If it wasn't a parameter, then just copy it across. */
|
||
if (! substituted)
|
||
append_tokens_without_splicing (dest, &tok);
|
||
}
|
||
|
||
if (! lookahead_valid)
|
||
break;
|
||
|
||
tok = lookahead;
|
||
original_rl_start = lookahead_rl_start;
|
||
|
||
lookahead_rl_start = replacement_list.text;
|
||
lookahead_valid = get_token (&lookahead, &replacement_list);
|
||
}
|
||
}
|
||
|
||
|
||
/* Expand a call to a macro named ID, whose definition is DEF. Append
|
||
its expansion to DEST. SRC is the input text following the ID
|
||
token. We are currently rescanning the expansions of the macros
|
||
named in NO_LOOP; don't re-expand them. Use LOOKUP_FUNC and
|
||
LOOKUP_BATON to find definitions for any nested macro references.
|
||
|
||
Return 1 if we decided to expand it, zero otherwise. (If it's a
|
||
function-like macro name that isn't followed by an argument list,
|
||
we don't expand it.) If we return zero, leave SRC unchanged. */
|
||
static int
|
||
expand (const char *id,
|
||
struct macro_definition *def,
|
||
struct macro_buffer *dest,
|
||
struct macro_buffer *src,
|
||
struct macro_name_list *no_loop,
|
||
macro_lookup_ftype *lookup_func,
|
||
void *lookup_baton)
|
||
{
|
||
struct macro_name_list new_no_loop;
|
||
|
||
/* Create a new node to be added to the front of the no-expand list.
|
||
This list is appropriate for re-scanning replacement lists, but
|
||
it is *not* appropriate for scanning macro arguments; invocations
|
||
of the macro whose arguments we are gathering *do* get expanded
|
||
there. */
|
||
new_no_loop.name = id;
|
||
new_no_loop.next = no_loop;
|
||
|
||
/* What kind of macro are we expanding? */
|
||
if (def->kind == macro_object_like)
|
||
{
|
||
struct macro_buffer replacement_list;
|
||
|
||
init_shared_buffer (&replacement_list, (char *) def->replacement,
|
||
strlen (def->replacement));
|
||
|
||
scan (dest, &replacement_list, &new_no_loop, lookup_func, lookup_baton);
|
||
return 1;
|
||
}
|
||
else if (def->kind == macro_function_like)
|
||
{
|
||
struct cleanup *back_to = make_cleanup (null_cleanup, 0);
|
||
int argc = 0;
|
||
struct macro_buffer *argv = NULL;
|
||
struct macro_buffer substituted;
|
||
struct macro_buffer substituted_src;
|
||
struct macro_buffer va_arg_name = {0};
|
||
int is_varargs = 0;
|
||
|
||
if (def->argc >= 1)
|
||
{
|
||
if (strcmp (def->argv[def->argc - 1], "...") == 0)
|
||
{
|
||
/* In C99-style varargs, substitution is done using
|
||
__VA_ARGS__. */
|
||
init_shared_buffer (&va_arg_name, "__VA_ARGS__",
|
||
strlen ("__VA_ARGS__"));
|
||
is_varargs = 1;
|
||
}
|
||
else
|
||
{
|
||
int len = strlen (def->argv[def->argc - 1]);
|
||
|
||
if (len > 3
|
||
&& strcmp (def->argv[def->argc - 1] + len - 3, "...") == 0)
|
||
{
|
||
/* In GNU-style varargs, the name of the
|
||
substitution parameter is the name of the formal
|
||
argument without the "...". */
|
||
init_shared_buffer (&va_arg_name,
|
||
(char *) def->argv[def->argc - 1],
|
||
len - 3);
|
||
is_varargs = 1;
|
||
}
|
||
}
|
||
}
|
||
|
||
make_cleanup (free_current_contents, &argv);
|
||
argv = gather_arguments (id, src, is_varargs ? def->argc : -1,
|
||
&argc);
|
||
|
||
/* If we couldn't find any argument list, then we don't expand
|
||
this macro. */
|
||
if (! argv)
|
||
{
|
||
do_cleanups (back_to);
|
||
return 0;
|
||
}
|
||
|
||
/* Check that we're passing an acceptable number of arguments for
|
||
this macro. */
|
||
if (argc != def->argc)
|
||
{
|
||
if (is_varargs && argc >= def->argc - 1)
|
||
{
|
||
/* Ok. */
|
||
}
|
||
/* Remember that a sequence of tokens like "foo()" is a
|
||
valid invocation of a macro expecting either zero or one
|
||
arguments. */
|
||
else if (! (argc == 1
|
||
&& argv[0].len == 0
|
||
&& def->argc == 0))
|
||
error (_("Wrong number of arguments to macro `%s' "
|
||
"(expected %d, got %d)."),
|
||
id, def->argc, argc);
|
||
}
|
||
|
||
/* Note that we don't expand macro invocations in the arguments
|
||
yet --- we let subst_args take care of that. Parameters that
|
||
appear as operands of the stringifying operator "#" or the
|
||
splicing operator "##" don't get macro references expanded,
|
||
so we can't really tell whether it's appropriate to macro-
|
||
expand an argument until we see how it's being used. */
|
||
init_buffer (&substituted, 0);
|
||
make_cleanup (cleanup_macro_buffer, &substituted);
|
||
substitute_args (&substituted, def, is_varargs, &va_arg_name,
|
||
argc, argv, no_loop, lookup_func, lookup_baton);
|
||
|
||
/* Now `substituted' is the macro's replacement list, with all
|
||
argument values substituted into it properly. Re-scan it for
|
||
macro references, but don't expand invocations of this macro.
|
||
|
||
We create a new buffer, `substituted_src', which points into
|
||
`substituted', and scan that. We can't scan `substituted'
|
||
itself, since the tokenization process moves the buffer's
|
||
text pointer around, and we still need to be able to find
|
||
`substituted's original text buffer after scanning it so we
|
||
can free it. */
|
||
init_shared_buffer (&substituted_src, substituted.text, substituted.len);
|
||
scan (dest, &substituted_src, &new_no_loop, lookup_func, lookup_baton);
|
||
|
||
do_cleanups (back_to);
|
||
|
||
return 1;
|
||
}
|
||
else
|
||
internal_error (__FILE__, __LINE__, _("bad macro definition kind"));
|
||
}
|
||
|
||
|
||
/* If the single token in SRC_FIRST followed by the tokens in SRC_REST
|
||
constitute a macro invokation not forbidden in NO_LOOP, append its
|
||
expansion to DEST and return non-zero. Otherwise, return zero, and
|
||
leave DEST unchanged.
|
||
|
||
SRC_FIRST and SRC_REST must be shared buffers; DEST must not be one.
|
||
SRC_FIRST must be a string built by get_token. */
|
||
static int
|
||
maybe_expand (struct macro_buffer *dest,
|
||
struct macro_buffer *src_first,
|
||
struct macro_buffer *src_rest,
|
||
struct macro_name_list *no_loop,
|
||
macro_lookup_ftype *lookup_func,
|
||
void *lookup_baton)
|
||
{
|
||
gdb_assert (src_first->shared);
|
||
gdb_assert (src_rest->shared);
|
||
gdb_assert (! dest->shared);
|
||
|
||
/* Is this token an identifier? */
|
||
if (src_first->is_identifier)
|
||
{
|
||
/* Make a null-terminated copy of it, since that's what our
|
||
lookup function expects. */
|
||
char *id = (char *) xmalloc (src_first->len + 1);
|
||
struct cleanup *back_to = make_cleanup (xfree, id);
|
||
|
||
memcpy (id, src_first->text, src_first->len);
|
||
id[src_first->len] = 0;
|
||
|
||
/* If we're currently re-scanning the result of expanding
|
||
this macro, don't expand it again. */
|
||
if (! currently_rescanning (no_loop, id))
|
||
{
|
||
/* Does this identifier have a macro definition in scope? */
|
||
struct macro_definition *def = lookup_func (id, lookup_baton);
|
||
|
||
if (def && expand (id, def, dest, src_rest, no_loop,
|
||
lookup_func, lookup_baton))
|
||
{
|
||
do_cleanups (back_to);
|
||
return 1;
|
||
}
|
||
}
|
||
|
||
do_cleanups (back_to);
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* Expand macro references in SRC, appending the results to DEST.
|
||
Assume we are re-scanning the result of expanding the macros named
|
||
in NO_LOOP, and don't try to re-expand references to them.
|
||
|
||
SRC must be a shared buffer; DEST must not be one. */
|
||
static void
|
||
scan (struct macro_buffer *dest,
|
||
struct macro_buffer *src,
|
||
struct macro_name_list *no_loop,
|
||
macro_lookup_ftype *lookup_func,
|
||
void *lookup_baton)
|
||
{
|
||
gdb_assert (src->shared);
|
||
gdb_assert (! dest->shared);
|
||
|
||
for (;;)
|
||
{
|
||
struct macro_buffer tok;
|
||
char *original_src_start = src->text;
|
||
|
||
/* Find the next token in SRC. */
|
||
if (! get_token (&tok, src))
|
||
break;
|
||
|
||
/* Just for aesthetics. If we skipped some whitespace, copy
|
||
that to DEST. */
|
||
if (tok.text > original_src_start)
|
||
{
|
||
appendmem (dest, original_src_start, tok.text - original_src_start);
|
||
dest->last_token = dest->len;
|
||
}
|
||
|
||
if (! maybe_expand (dest, &tok, src, no_loop, lookup_func, lookup_baton))
|
||
/* We didn't end up expanding tok as a macro reference, so
|
||
simply append it to dest. */
|
||
append_tokens_without_splicing (dest, &tok);
|
||
}
|
||
|
||
/* Just for aesthetics. If there was any trailing whitespace in
|
||
src, copy it to dest. */
|
||
if (src->len)
|
||
{
|
||
appendmem (dest, src->text, src->len);
|
||
dest->last_token = dest->len;
|
||
}
|
||
}
|
||
|
||
|
||
char *
|
||
macro_expand (const char *source,
|
||
macro_lookup_ftype *lookup_func,
|
||
void *lookup_func_baton)
|
||
{
|
||
struct macro_buffer src, dest;
|
||
struct cleanup *back_to;
|
||
|
||
init_shared_buffer (&src, (char *) source, strlen (source));
|
||
|
||
init_buffer (&dest, 0);
|
||
dest.last_token = 0;
|
||
back_to = make_cleanup (cleanup_macro_buffer, &dest);
|
||
|
||
scan (&dest, &src, 0, lookup_func, lookup_func_baton);
|
||
|
||
appendc (&dest, '\0');
|
||
|
||
discard_cleanups (back_to);
|
||
return dest.text;
|
||
}
|
||
|
||
|
||
char *
|
||
macro_expand_once (const char *source,
|
||
macro_lookup_ftype *lookup_func,
|
||
void *lookup_func_baton)
|
||
{
|
||
error (_("Expand-once not implemented yet."));
|
||
}
|
||
|
||
|
||
char *
|
||
macro_expand_next (const char **lexptr,
|
||
macro_lookup_ftype *lookup_func,
|
||
void *lookup_baton)
|
||
{
|
||
struct macro_buffer src, dest, tok;
|
||
struct cleanup *back_to;
|
||
|
||
/* Set up SRC to refer to the input text, pointed to by *lexptr. */
|
||
init_shared_buffer (&src, (char *) *lexptr, strlen (*lexptr));
|
||
|
||
/* Set up DEST to receive the expansion, if there is one. */
|
||
init_buffer (&dest, 0);
|
||
dest.last_token = 0;
|
||
back_to = make_cleanup (cleanup_macro_buffer, &dest);
|
||
|
||
/* Get the text's first preprocessing token. */
|
||
if (! get_token (&tok, &src))
|
||
{
|
||
do_cleanups (back_to);
|
||
return 0;
|
||
}
|
||
|
||
/* If it's a macro invocation, expand it. */
|
||
if (maybe_expand (&dest, &tok, &src, 0, lookup_func, lookup_baton))
|
||
{
|
||
/* It was a macro invocation! Package up the expansion as a
|
||
null-terminated string and return it. Set *lexptr to the
|
||
start of the next token in the input. */
|
||
appendc (&dest, '\0');
|
||
discard_cleanups (back_to);
|
||
*lexptr = src.text;
|
||
return dest.text;
|
||
}
|
||
else
|
||
{
|
||
/* It wasn't a macro invocation. */
|
||
do_cleanups (back_to);
|
||
return 0;
|
||
}
|
||
}
|