From d311d28c3f8a3c43e6ef33d68b852c5ea7f13239 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Wed, 21 Sep 2011 10:41:20 -0700 Subject: * alloc.c (pure_bytes_used_lisp, pure_bytes_used_non_lisp): (allocate_vectorlike, buffer_memory_full, struct sdata, SDATA_SIZE) (string_bytes, check_sblock, allocate_string_data): (compact_small_strings, Fmake_bool_vector, make_string) (make_unibyte_string, make_multibyte_string) (make_string_from_bytes, make_specified_string) (allocate_vectorlike, Fmake_vector, find_string_data_in_pure) (make_pure_string, make_pure_c_string, make_pure_vector, Fpurecopy) (mark_vectorlike): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (allocate_pseudovector): Use int, not EMACS_INT, where int is wide enough. (inhibit_garbage_collection, Fgarbage_collect): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * bidi.c (bidi_mirror_char): Use EMACS_INT, not int, where int might not be wide enough. (bidi_cache_search, bidi_cache_find, bidi_init_it) (bidi_count_bytes, bidi_char_at_pos, bidi_fetch_char) (bidi_at_paragraph_end, bidi_find_paragraph_start) (bidi_paragraph_init, bidi_resolve_explicit, bidi_resolve_weak) (bidi_level_of_next_char, bidi_move_to_visually_next): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * buffer.c (copy_overlays, Fgenerate_new_buffer_name) (Fkill_buffer, Fset_buffer_major_mode) (advance_to_char_boundary, Fbuffer_swap_text) (Fset_buffer_multibyte, overlays_at, overlays_in) (overlay_touches_p, struct sortvec, record_overlay_string) (overlay_strings, recenter_overlay_lists) (adjust_overlays_for_insert, adjust_overlays_for_delete) (fix_start_end_in_overlays, fix_overlays_before, modify_overlay) (Fmove_overlay, Fnext_overlay_change, Fprevious_overlay_change) (Foverlay_recenter, last_overlay_modification_hooks_used) (report_overlay_modification, evaporate_overlays, enlarge_buffer_text): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (validate_region): Omit unnecessary test for b <= e, since that's guaranteed by the previous test. (adjust_overlays_for_delete): Avoid pos + length overflow. (Fmove_overlay, Fdelete_overlay, add_overlay_mod_hooklist) (report_overlay_modification): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Foverlays_at, Fnext_overlay_change, Fprevious_overlay_change): Omit pointer cast, which isn't needed anyway, and doesn't work after the EMACS_INT -> ptrdiff_t change. * buffer.h: Adjust decls to match defn changes elsewhere. (struct buffer_text, struct buffer): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. Use EMACS_INT, not int, where int might not be wide enough. * bytecode.c (exec_byte_code): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. Remove unnecessary memory-full test. Use EMACS_INT, not ptrdiff_t or int, where ptrdiff_t or int might not be wide enough. * callint.c (Fcall_interactively): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * callproc.c (call_process_kill, Fcall_process): Don't assume pid_t fits into an Emacs fixnum. (call_process_cleanup, Fcall_process, child_setup): Don't assume pid_t fits into int. (call_process_cleanup, Fcall_process, delete_temp_file) (Fcall_process_region): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Fcall_process): Simplify handling of volatile integers. Use int, not EMACS_INT, where int will do. * casefiddle.c (casify_object, casify_region, operate_on_word) (Fupcase_word, Fdowncase_word, Fcapitalize_word): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (casify_object): Avoid integer overflow when overallocating buffer. * casetab.c (set_identity, shuffle): Prefer int to unsigned when either works. * category.c (Fchar_category_set): Don't assume fixnum fits in int. * category.h (CATEGORYP): Don't assume arg is nonnegative. * ccl.c (GET_CCL_INT): Remove; no longer needed, since the integers are now checked earlier. All uses replaced with XINT. (ccl_driver): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. For CCL_MapSingle, check that content and value are in int range. (resolve_symbol_ccl_program): Check that vector header is in range. Always copy the vector, so that we can check its contents reliably now rather than having to recheck each instruction as it's being executed. Check that vector words fit in 'int'. (ccl_get_compiled_code, Fregister_ccl_program) (Fregister_code_conversion_map): Use ptrdiff_t, not int, for program indexes, to avoid needless 32-bit limit on 64-bit hosts. (Fccl_execute, Fccl_execute_on_string): Check that initial reg contents are in range. (Fccl_execute_on_string): Check that status is in range. * ccl.h (struct ccl_program.idx): Now ptrdiff_t, not int. * character.c (char_resolve_modifier_mask, Fchar_resolve_modifiers): Accept and return EMACS_INT, not int, because callers can pass values out of 'int' range. (c_string_width, strwidth, lisp_string_width, chars_in_text) (multibyte_chars_in_text, parse_str_as_multibyte) (str_as_multibyte, count_size_as_multibyte, str_to_multibyte) (str_as_unibyte, str_to_unibyte, string_count_byte8) (string_escape_byte8, Fget_byte): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Funibyte_string): Use CHECK_CHARACTER, not CHECK_NATNUM, to avoid mishandling large integers. * character.h: Adjust decls to match defn changes elsewhere. * charset.c (load_charset_map_from_file, find_charsets_in_text) (Ffind_charset_region): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (load_charset_map_from_file): Redo idx calculation to avoid overflow. (load_charset_map_from_vector, Fdefine_charset_internal): Don't assume fixnum fits in int or unsigned int. (load_charset_map_from_vector, Fmap_charset_chars): Remove now-unnecessary CHECK_NATNUMs. (Fdefine_charset_internal): Check ranges here, more carefully. * chartab.c (Fmake_char_table, Fset_char_table_range) (uniprop_get_decoder, uniprop_get_encoder): Don't assume fixnum fits in int. * cmds.c (move_point): New function, that does the gist of Fforward_char and Fbackward_char, but does so while checking for integer overflow more accurately. (Fforward_char, Fbackward_char, internal_self_insert): Use it. (Fforward_line, Fend_of_line, internal_self_insert) (internal_self_insert): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. Fix a FIXME, by checking for integer overflow when calculating target_clm and actual_clm. * coding.c (detect_coding_XXX, encode_coding_XXX, CODING_DECODE_CHAR) (ASSURE_DESTINATION, coding_alloc_by_realloc) (coding_alloc_by_making_gap, alloc_destination) (detect_coding_utf_8, encode_coding_utf_8, decode_coding_utf_16) (encode_coding_utf_16, detect_coding_emacs_mule) (decode_coding_emacs_mule, encode_coding_emacs_mule) (detect_coding_iso_2022, decode_coding_iso_2022) (encode_invocation_designation, encode_designation_at_bol) (encode_coding_iso_2022, detect_coding_sjis, detect_coding_big5) (decode_coding_sjis, decode_coding_big5, encode_coding_sjis) (encode_coding_big5, detect_coding_ccl, decode_coding_ccl) (encode_coding_ccl, encode_coding_raw_text) (detect_coding_charset, decode_coding_charset) (encode_coding_charset, detect_eol, decode_eol, produce_chars) (produce_composition, produce_charset, produce_annotation) (decode_coding, handle_composition_annotation) (handle_charset_annotation, consume_chars, decode_coding_gap) (decode_coding_object, encode_coding_object, detect_coding_system) (Ffind_coding_systems_region_internal, Fcheck_coding_systems_region) (code_convert_region, code_convert_string) (Fdefine_coding_system_internal): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (setup_iso_safe_charsets, consume_chars, Funencodable_char_position) (Fdefine_coding_system_internal): Don't assume fixnums fit in int. (decode_coding_gap, decode_coding_object, encode_coding_object) (Fread_coding_system, Fdetect_coding_region, Funencodable_char_position) (Fcheck_coding_systems_region): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Ffind_operation_coding_system): NATNUMP can eval its arg twice. (Fdefine_coding_system_internal): Check for charset-id overflow. * coding.h: Adjust decls to match defn changes elsewhere. (struct coding_system): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * composite.c (get_composition_id, find_composition) (run_composition_function, update_compositions) (compose_text, composition_gstring_put_cache) (composition_gstring_p, composition_gstring_width) (fill_gstring_header, fill_gstring_body, autocmp_chars) (composition_compute_stop_pos, composition_reseat_it) (composition_update_it, struct position_record) (find_automatic_composition, composition_adjust_point) (Fcomposition_get_gstring, Ffind_composition_internal): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (update_compositions): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * composite.h: Adjust decls to match defn changes elsewhere. (struct composition): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * data.c (let_shadows_buffer_binding_p, let_shadows_global_binding_p): Do not attempt to compute the address of the object just before a buffer; this is not portable. (Faref, Faset): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Faset): Use int, not EMACS_INT, where int is wide enough. (Fstring_to_number): Don't assume fixnums fit in int. (Frem): Don't assume arg is nonnegative. * dbusbind.c (xd_append_arg): Check for integers out of range. (Fdbus_call_method): Don't overflow the timeout int. * dired.c (directory_files_internal, file_name_completion, scmp) (file_name_completion_stat): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (file_name_completion): Don't overflow matchcount. (file_name_completion_stat): Use SAFE_ALLOCA, not alloca. * dispextern.h: Adjust decls to match defn changes elsewhere. (struct text_pos, struct glyph, struct bidi_saved_info) (struct bidi_string_data, struct bidi_it, struct composition_it) (struct it): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (struct display_pos, struct composition_it, struct it): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * dispnew.c (increment_matrix_positions) (increment_row_positions, mode_line_string) (marginal_area_string): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (change_frame_size_1, Fredisplay): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (duration_to_sec_usec): New function, to check for overflow better. (Fsleep_for, sit_for): Use it. * doc.c (get_doc_string, store_function_docstring): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (get_doc_string, Fsnarf_documentation): Use int, not EMACS_INT, where int is wide enough. (get_doc_string): Use SAFE_ALLOCA, not alloca. Check for overflow when converting EMACS_INT to off_t. * doprnt.c (doprnt): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * editfns.c (init_editfns, Fuser_uid, Fuser_real_uid): Don't assume uid_t fits into fixnum. (buildmark, Fgoto_char, overlays_around, find_field, Fdelete_field) (Ffield_string, Ffield_string_no_properties, Ffield_beginning) (Ffield_end, Fconstrain_to_field, Fline_beginning_position) (Fline_end_position, Fprevious_char, Fchar_after, Fchar_before) (general_insert_function) (Finsert_char, make_buffer_string, make_buffer_string_both) (update_buffer_properties, Fbuffer_substring) (Fbuffer_substring_no_properties, Fcompare_buffer_substrings) (Fsubst_char_in_region, check_translation) (Ftranslate_region_internal, save_restriction_restore, Fformat) (transpose_markers, Ftranspose_regions): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (clip_to_bounds): Move to lisp.h as an inline function). (Fconstrain_to_field): Don't assume integers are nonnegative. (Fline_beginning_position, Fsave_excursion, Fsave_current_buffer): (Fsubst_char_in_region, Fsave_restriction): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Femacs_pid): Don't assume pid_t fits into fixnum. (lo_time): Use int, not EMACS_INT, when int suffices. (lisp_time_argument): Check for usec out of range. (Fencode_time): Don't assume fixnum fits in int. * emacs.c (gdb_valbits, gdb_gctypebits): Now int, not EMACS_INT. (gdb_data_seg_bits): Now uintptr_t, not EMACS_INT. (PVEC_FLAG, gdb_array_mark_flag): Now ptrdiff_t, not EMACS_INT. (init_cmdargs, Fdump_emacs): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Fkill_emacs): Don't assume fixnum fits in int; instead, take just the bottom (typically) 32 bits of the fixnum. * eval.c (specpdl_size, call_debugger): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (when_entered_debugger, Fbacktrace_debug): Don't assume fixnum can fit in int. (Fdefvaralias, Fdefvar): Do not attempt to compute the address of the object just before a buffer; this is not portable. (FletX, Flet, Funwind_protect, do_autoload, Feval, funcall_lambda) (grow_specpdl, unbind_to): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Fapply, apply_lambda): Don't assume ptrdiff_t can hold fixnum. (grow_specpdl): Simplify allocation by using xpalloc. * fileio.c (Ffind_file_name_handler, Fcopy_file, Frename_file) (Finsert_file_contents, Fwrite_region, Fdo_auto_save): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Ffind_file_name_handler, non_regular_inserted, Finsert_file_contents) (a_write, e_write): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fcopy_file, non_regular_nbytes, read_non_regular) (Finsert_file_contents): Use int, not EMACS_INT, where int is wide enough. (READ_BUF_SIZE): Verify that it fits in int. (Finsert_file_contents): Check that counts are in proper range, rather than assuming fixnums fit into ptrdiff_t etc. Don't assume fixnums fit into int. (Fdo_auto_save, Fset_buffer_auto_saved) (Fclear_buffer_auto_save_failure): Don't assume time_t is signed, or that it fits in int. * fns.c (Fcompare_strings, Fstring_lessp, struct textprop_rec) (concat, string_char_byte_cache_charpos, string_char_byte_cache_bytepos) (string_char_to_byte, string_byte_to_char) (string_make_multibyte, string_to_multibyte) (string_make_unibyte, Fstring_as_unibyte, Fstring_as_multibyte) (Fstring_to_unibyte, Fsubstring, Fsubstring_no_properties) (substring_both, Fdelete, internal_equal, Ffillarray) (Fclear_string, mapcar1) (Fbase64_encode_region, Fbase64_encode_string, base64_encode_1) (Fbase64_decode_region, Fbase64_decode_string, base64_decode_1) (larger_vector, make_hash_table, maybe_resize_hash_table) (hash_lookup, hash_remove_from_table, hash_clear, sweep_weak_table) (Fmaphash, secure_hash): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (concat): Check for string index and length overflow. (Fmapconcat): Don't assume fixnums fit into ptrdiff_t. (Frequire): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (larger_vector): New API (vec, incr_min, size_max) replaces old one (vec, new_size, init). This catches size overflow. INIT was removed because it was always Qnil. All callers changed. (INDEX_SIZE_BOUND): New macro, which calculates more precisely the upper bound on a hash table index size. (make_hash_table, maybe_resize_hash_table): Use it. (secure_hash): Computer start_byte and end_byte only after they're known to be in ptrdiff_t range. * font.c (font_intern_prop, font_at, font_range, Ffont_shape_gstring) (Ffont_get_glyphs, Ffont_at): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (font_style_to_value, font_prop_validate_style, font_expand_wildcards) (Flist_fonts, Fopen_font): Don't assume fixnum can fit in int. (check_gstring): Don't assume index can fit in int. (font_match_p): Check that fixnum is a character, not a nonnegative fixnum, since the later code needs to stuff it into an int. (font_find_for_lface): Use SAFE_ALLOCA_LISP, not alloca. (font_fill_lglyph_metrics): Use unsigned, not EMACS_INT, to avoid conversion overflow issues. (Fopen_font): Check for integer out of range. (Ffont_get_glyphs): Don't assume index can fit in int. * font.h: Adjust decls to match defn changes elsewhere. * fontset.c (reorder_font_vector): Redo score calculation to avoid integer overflow. (num_auto_fontsets, fontset_from_font): Use ptrdiff_t, not printmax_t, where ptrdiff_t is wide enough. (Finternal_char_font): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * frame.c (Fset_mouse_position, Fset_mouse_pixel_position) (Fset_frame_height, Fset_frame_width, Fset_frame_size) (Fset_frame_position, x_set_frame_parameters) (x_set_line_spacing, x_set_border_width) (x_set_internal_border_width, x_set_alpha, x_figure_window_size): Check that fixnums are in proper range for system types. (frame_name_fnn_p, Fframe_parameter, Fmodify_frame_parameters): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fmodify_frame_parameters): Don't assume fixnum fits in int. Use SAFE_ALLOCA_LISP, not alloca. * frame.h (struct frame): Use intptr_t, not EMACS_INT, where intptr_t is wide enough. * fringe.c (lookup_fringe_bitmap, get_logical_fringe_bitmap) (Fdefine_fringe_bitmap): Don't assume fixnum fits in int. (Ffringe_bitmaps_at_pos): Don't assume index fits in int. Check for fixnum out of range. * ftfont.c (ftfont_list): Don't assume index fits in int. Check that fixnums are in proper range for system types. (ftfont_shape_by_flt): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. Remove no-longer-needed lint_assume. * gnutls.c (emacs_gnutls_write, emacs_gnutls_read): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fgnutls_error_fatalp, Fgnutls_error_string, Fgnutls_boot): Check that fixnums are in proper range for system types. * gnutls.h: Adjust decls to match defn changes elsewhere. * gtkutil.c (xg_dialog_run): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (update_frame_tool_bar): Check that fixnums are in proper range for system types. * image.c (parse_image_spec): Redo count calculation to avoid overflow. (lookup_image): Check that fixnums are in proper range for system types. * indent.c (last_known_column, last_known_column_point): (current_column_bol_cache): (skip_invisible, current_column, check_display_width): (check_display_width, scan_for_column, current_column_1) (Findent_to, Fcurrent_indentation, position_indentation) (indented_beyond_p, Fmove_to_column, compute_motion): (Fcompute_motion, Fvertical_motion): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (last_known_column_modified): Use EMACS_INT, not int. (check_display_width): (Fcompute_motion): Check that fixnums and floats are in proper range for system types. (compute_motion): Don't assume index or fixnum fits in int. (compute_motion, Fcompute_motion): Use int, not EMACS_INT, when it is wide enough. (vmotion): Omit local var start_hpos that is always 0; that way we don't need to worry about overflow in expressions involving it. * indent.h: Adjust decls to match defn changes elsewhere. (struct position): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. Use int, not EMACS_INT, where int is wide enough. Remove unused members ovstring_chars_done and tab_offset; all uses removed. * insdel.c (move_gap, move_gap_both, gap_left, gap_right) (adjust_markers_for_delete, adjust_markers_for_insert, adjust_point) (adjust_markers_for_replace, make_gap_larger, make_gap_smaller) (make_gap, copy_text, insert, insert_and_inherit) (insert_before_markers, insert_before_markers_and_inherit) (insert_1, count_combining_before, count_combining_after) (insert_1_both, insert_from_string) (insert_from_string_before_markers, insert_from_string_1) (insert_from_gap, insert_from_buffer, insert_from_buffer_1) (adjust_after_replace, adjust_after_insert, replace_range) (replace_range_2, del_range, del_range_1, del_range_byte) (del_range_both, del_range_2, modify_region) (prepare_to_modify_buffer, signal_before_change) (signal_after_change, Fcombine_after_change_execute): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * intervals.c (traverse_intervals, rotate_right, rotate_left) (balance_an_interval, split_interval_right, split_interval_left) (find_interval, next_interval, update_interval) (adjust_intervals_for_insertion, delete_node, delete_interval) (interval_deletion_adjustment, adjust_intervals_for_deletion) (static_offset_intervals, offset_intervals) (merge_interval_right, merge_interval_left, make_new_interval) (graft_intervals_into_buffer, temp_set_point_both) (temp_set_point, set_point, adjust_for_invis_intang) (set_point_both, move_if_not_intangible, get_property_and_range) (get_local_map, copy_intervals, copy_intervals_to_string) (compare_string_intervals, set_intervals_multibyte_1): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * intervals.h: Adjust decls to match defn changes elsewhere. (struct interval): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * keyboard.c (this_command_key_count, this_single_command_key_start) (before_command_key_count, before_command_echo_length, echo_now) (echo_length, recursive_edit_1, Frecursive_edit, Ftrack_mouse) (command_loop_1, safe_run_hooks, read_char, timer_check_2) (menu_item_eval_property, read_key_sequence, Fread_key_sequence) (Fread_key_sequence_vector, Fexecute_extended_command, Fsuspend_emacs): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (last_non_minibuf_size, last_point_position, echo_truncate) (command_loop_1, adjust_point_for_property, read_char, gen_help_event) (make_lispy_position, make_lispy_event, parse_modifiers_uncached) (parse_modifiers, modify_event_symbol, Fexecute_extended_command) (stuff_buffered_input): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (last_auto_save, command_loop_1, read_char): Use EMACS_INT, not int, to avoid integer overflow. (record_char): Avoid overflow in total_keys computation. (parse_modifiers_uncached): Redo index calculation to avoid overflow. * keyboard.h: Adjust decls to match defn changes elsewhere. * keymap.c (Fdefine_key, Fcurrent_active_maps, accessible_keymaps_1) (Fkey_description, Fdescribe_vector, Flookup_key): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (click_position): New function, to check that positions are in range. (Fcurrent_active_maps): (describe_command): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Faccessible_keymaps, Fkey_description): (preferred_sequence_p): Don't assume fixnum can fit into int. (Fkey_description): Use SAFE_ALLOCA_LISP, not alloca. Check for integer overflow in size calculations. (Ftext_char_description): Use CHECK_CHARACTER, not CHECK_NUMBER, to avoid mishandling large integers. * lisp.h: Adjust decls to match defn changes elsewhere. (ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG, struct Lisp_String) (struct vectorlike_header, struct Lisp_Subr, struct Lisp_Hash_Table) (struct Lisp_Marker): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (clip_to_bounds): Now an inline function, moved here from editfns.c. (XSETSUBR): Use size of 0 since the actual size doesn't matter, and using 0 avoids overflow. (GLYPH_CODE_P): Check for overflow in system types, subsuming the need for GLYPH_CODE_CHAR_VALID_P and doing proper checking ourselves. All callers changed. (GLYPH_CODE_CHAR, GLYPH_CODE_FACE): Assume the arg has valid form, since it always does. (TYPE_RANGED_INTEGERP): Avoid bug when checking against a wide unsigned integer system type. (CHECK_RANGED_INTEGER, CHECK_TYPE_RANGED_INTEGER): New macros. (struct catchtag, specpdl_size, SPECPDL_INDEX, USE_SAFE_ALLOCA): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (struct catchtag): Use EMACS_INT, not int, since it may be a fixnum. (duration_to_sec_usec): New decl. * lread.c (read_from_string_index, read_from_string_index_byte) (read_from_string_limit, readchar, unreadchar, openp) (read_internal_start, read1, oblookup): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fload, readevalloop, Feval_buffer, Feval_region): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (openp): Check for out-of-range argument to 'access'. (read1): Use int, not EMACS_INT, where int is wide enough. Don't assume fixnum fits into int. * macros.c (Fstart_kbd_macro): Use xpalloc to check for overflow in size calculation. (Fexecute_kbd_macro): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * marker.c (cached_charpos, cached_bytepos, CONSIDER) (byte_char_debug_check, buf_charpos_to_bytepos, verify_bytepos) (buf_bytepos_to_charpos, Fset_marker, set_marker_restricted) (set_marker_both, set_marker_restricted_both, marker_position) (marker_byte_position, Fbuffer_has_markers_at): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fset_marker, set_marker_restricted): Don't assume fixnum fits in int. * menu.c (ensure_menu_items): Renamed from grow_menu_items. It now merely ensures that the menu is large enough, without necessarily growing it, as this avoids some integer overflow issues. All callers changed. (keymap_panes, parse_single_submenu, Fx_popup_menu): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (parse_single_submenu, Fx_popup_menu): Don't assume fixnum fits in int. Use SAFE_ALLOCA_LISP, not alloca. (find_and_return_menu_selection): Avoid unnecessary casts of pointers to EMACS_INT. Check that fixnums are in proper range for system types. * minibuf.c (minibuf_prompt_width, string_to_object) (Fminibuffer_contents, Fminibuffer_contents_no_properties) (Fminibuffer_completion_contents, Ftry_completion, Fall_completions): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (get_minibuffer, read_minibuf_unwind): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (read_minibuf): Omit unnecessary arg BACKUP_N, which is always nil; this simplifies overflow checking. All callers changed. (read_minibuf, Fread_buffer, Ftry_completion, Fall_completions) (Ftest_completion): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * nsfns.m (check_ns_display_info): Don't assume fixnum fits in long. (x_set_menu_bar_lines, x_set_tool_bar_lines, Fx_create_frame): Check that fixnums are in proper range for system types. (Fx_create_frame, Fx_show_tip): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * nsfont.m (ns_findfonts, nsfont_list_family): Don't assume fixnum fits in long. * nsmenu.m (ns_update_menubar, ns_menu_show, ns_popup_dialog): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (ns_update_menubar): Use intptr_t, not EMACS_INT, when intptr_t is wide enough. * nsselect.m (ns_get_local_selection): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * print.c (print_buffer_size, print_buffer_pos, print_buffer_pos_byte) (PRINTDECLARE, PRINTPREPARE): (strout, print_string): (print, print_preprocess, print_check_string_charset_prop) (print_object): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (PRINTDECLARE): (temp_output_buffer_setup, Fprin1_to_string, print_object): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (PRINTPREPARE): Use int, not ptrdiff_t, where int is wide enough. (PRINTFINISH): Use SAFE_ALLOCA, not alloca. (printchar, strout): Use xpalloc to catch size calculation overflow. (Fexternal_debugging_output): Use CHECK_CHARACTER, not CHECK_NUMBER, to avoid mishandling large integers. (print_error_message): Use SAFE_ALLOCA, not alloca. (print_object): Use int, not EMACS_INT, where int is wide enough. * process.c (Fdelete_process): Don't assume pid fits into EMACS_INT. (Fset_process_window_size, Fformat_network_address) (get_lisp_to_sockaddr_size, set_socket_option, Fmake_network_process) (Fsignal_process, sigchld_handler): Check that fixnums are in proper range for system types. (Fformat_network_address, read_process_output, send_process) (Fprocess_send_region, status_notify): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fformat_network_address, Fmake_serial_process, Fmake_network_process) (wait_reading_process_output, read_process_output, exec_sentinel): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (conv_lisp_to_sockaddr): Don't assume fixnums fit into int. (Faccept_process_output): Use duration_to_sec_usec to do proper overflow checking on durations. * scroll.c (calculate_scrolling, calculate_direct_scrolling) (line_ins_del): Use int, not EMACS_INT, where int is wide enough. * search.c (looking_at_1, string_match_1): (fast_string_match, fast_c_string_match_ignore_case) (fast_string_match_ignore_case, fast_looking_at, scan_buffer) (scan_newline, find_before_next_newline, search_command) (trivial_regexp_p, search_buffer, simple_search, boyer_moore) (set_search_regs, wordify): (Freplace_match): (Fmatch_data): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (string_match_1, search_buffer, set_search_regs): (Fmatch_data): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (wordify): Check for overflow in size calculation. (Freplace_match): Avoid potential buffer overflow in search_regs.start. (Fset_match_data): Don't assume fixnum fits in ptrdiff_t. Check that fixnums are in proper range for system types. * sound.c (struct sound_device) (wav_play, au_play, vox_write, alsa_period_size, alsa_write): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fplay_sound_internal): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * syntax.c (ST_COMMENT_STYLE, ST_STRING_STYLE): In definitions, make it clearer that these values must be out of range for the respective integer ranges. This fixes a bug with ST_STRING_STYLE and non-ASCII characters. (struct lisp_parse_state, find_start_modiff) (Finternal_describe_syntax_value, scan_lists, scan_sexps_forward): (Fparse_partial_sexp): Don't assume fixnums can fit in int. (struct lisp_parse_state, find_start_pos, find_start_value) (find_start_value_byte, find_start_begv) (update_syntax_table, char_quoted, dec_bytepos) (find_defun_start, prev_char_comend_first, back_comment): (scan_words, skip_chars, skip_syntaxes, forw_comment, Fforward_comment) (scan_lists, Fbackward_prefix_chars, scan_sexps_forward): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Finternal_describe_syntax_value): Check that match_lisp is a character, not an integer, since the code stuffs it into int. (scan_words, scan_sexps_forward): Check that fixnums are in proper range for system types. (Fforward_word): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (scan_sexps_forward): Use CHARACTERP, not INTEGERP, since the value must fit into int. (Fparse_partial_sexp): Fix doc; element 8 is not ignored. * syntax.h: Adjust decls to match defn changes elsewhere. (struct gl_state_s): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * sysdep.c (wait_for_termination_1, wait_for_termination) (interruptible_wait_for_termination, mkdir): Don't assume pid_t fits in int; on 64-bit AIX pid_t is 64-bit. (emacs_read, emacs_write): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (system_process_attributes): Don't assume uid_t, gid_t, and double all fit in int or even EMACS_INT. * term.c (set_tty_color_mode): Check that fixnums are in proper range for system types. * termhooks.h (struct input_event): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * textprop.c (validate_interval_range, interval_of) (Fadd_text_properties, set_text_properties_1) (Fremove_text_properties, Fremove_list_of_text_properties) (Ftext_property_any, Ftext_property_not_all) (copy_text_properties, text_property_list, extend_property_ranges) (verify_interval_modification): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fnext_single_char_property_change) (Fprevious_single_char_property_change): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (copy_text_properties): Check for integer overflow in index calculation. * undo.c (last_boundary_position, record_point, record_insert) (record_delete, record_marker_adjustment, record_change) (record_property_change): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (truncate_undo_list, Fprimitive_undo): Don't assume fixnum fits in int. Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * w32fns.c (Fx_create_frame, x_create_tip_frame, Fx_show_tip) (Fx_hide_tip, Fx_file_dialog): * w32menu.c (set_frame_menubar): Use ptrdiff_t, not int, for consistency with rest of code. * window.c (window_scroll_preserve_hpos, window_scroll_preserve_vpos) (select_window, Fdelete_other_windows_internal) (window_scroll_pixel_based, window_scroll_line_based) (Frecenter, Fset_window_configuration): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (Fset_window_hscroll, run_window_configuration_change_hook) (set_window_buffer, temp_output_buffer_show, scroll_command) (Fscroll_other_window): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Fwindow_line_height, window_scroll, Fscroll_left, Fscroll_right): Don't assume fixnum fits in int. (Fset_window_scroll_bars): Check that fixnums are in proper range for system types. * xdisp.c (help_echo_pos, pos_visible_p, string_pos_nchars_ahead) (string_pos, c_string_pos, number_of_chars, init_iterator) (in_ellipses_for_invisible_text_p, init_from_display_pos) (compute_stop_pos, next_overlay_change, compute_display_string_pos) (compute_display_string_end, handle_face_prop) (face_before_or_after_it_pos, handle_invisible_prop, handle_display_prop) (handle_display_spec, handle_single_display_spec) (display_prop_intangible_p, string_buffer_position_lim) (string_buffer_position, handle_composition_prop, load_overlay_strings) (get_overlay_strings_1, get_overlay_strings) (iterate_out_of_display_property, forward_to_next_line_start) (back_to_previous_visible_line_start, reseat, reseat_to_string) (get_next_display_element, set_iterator_to_next) (get_visually_first_element, compute_stop_pos_backwards) (handle_stop_backwards, next_element_from_buffer) (move_it_in_display_line_to, move_it_in_display_line) (move_it_to, move_it_vertically_backward, move_it_by_lines) (add_to_log, message_dolog, message_log_check_duplicate) (message2, message2_nolog, message3, message3_nolog (with_echo_area_buffer, display_echo_area_1, resize_mini_window_1) (current_message_1, truncate_echo_area, truncate_message_1) (set_message, set_message_1, store_mode_line_noprop) (hscroll_window_tree, debug_delta, debug_delta_bytes, debug_end_vpos) (text_outside_line_unchanged_p, check_point_in_composition) (reconsider_clip_changes) (redisplay_internal, set_cursor_from_row, try_scrolling) (try_cursor_movement, set_vertical_scroll_bar, redisplay_window) (redisplay_window, find_last_unchanged_at_beg_row) (find_first_unchanged_at_end_row, row_containing_pos, try_window_id) (trailing_whitespace_p, find_row_edges, display_line) (RECORD_MAX_MIN_POS, Fcurrent_bidi_paragraph_direction) (display_mode_element, store_mode_line_string) (pint2str, pint2hrstr, decode_mode_spec) (display_count_lines, display_string, draw_glyphs) (x_produce_glyphs, x_insert_glyphs) (rows_from_pos_range, mouse_face_from_buffer_pos) (fast_find_string_pos, mouse_face_from_string_pos) (note_mode_line_or_margin_highlight, note_mouse_highlight): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (safe_call, init_from_display_pos, handle_fontified_prop) (handle_single_display_spec, load_overlay_strings) (with_echo_area_buffer, setup_echo_area_for_printing) (display_echo_area, echo_area_display) (x_consider_frame_title, prepare_menu_bars, update_menu_bar) (update_tool_bar, hscroll_window_tree, redisplay_internal) (redisplay_window, dump_glyph_row, display_mode_line, Fformat_mode_line) (decode_mode_spec, on_hot_spot_p): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (handle_single_display_spec, build_desired_tool_bar_string) (redisplay_tool_bar, scroll_window_tree, Fdump_glyph_matrix) (get_specified_cursor_type): Check that fixnums are in proper range for system types. (struct overlay_entry, resize_mini_window, Fdump_glyph_row) (Flookup_image_map): Don't assume fixnums fit in int. (compare_overlay_entries): Avoid mishandling comparisons due to subtraction overflow. (load_overlay_strings): Use SAFE_NALLOCA, not alloca. (last_escape_glyph_face_id, last_glyphless_glyph_face_id): (handle_tool_bar_click): Use int, not unsigned, since we prefer signed and the signedness doesn't matter here. (get_next_display_element, next_element_from_display_vector): Use int, not EMACS_INT, when int is wide enough. (start_hourglass): Use duration_to_sec_usec to do proper overflow checking on durations. * xfaces.c (Fbitmap_spec_p): Check that fixnums are in proper range for system types. (compare_fonts_by_sort_order): Avoid mishandling comparisons due to subtraction overflow. (Fx_family_fonts, realize_basic_faces): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Fx_family_fonts): Don't assume fixnum fits in int. Use SAFE_ALLOCA_LISP, not alloca. (merge_face_heights): Remove unnecessary cast to EMACS_INT. (Finternal_make_lisp_face): Don't allocate more than MAX_FACE_ID. (face_at_buffer_position, face_for_overlay_string) (face_at_string_position): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. (merge_faces): Use int, not EMACS_INT, where int is wide enough. * xfns.c (x_set_menu_bar_lines, x_set_tool_bar_lines, x_icon_verify) (Fx_show_tip): Check that fixnums are in proper range for system types. (Fx_create_frame, x_create_tip_frame, Fx_show_tip) (Fx_hide_tip, Fx_file_dialog, Fx_select_font): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (Fx_change_window_property): Don't assume fixnums fit in int. * xfont.c (xfont_chars_supported): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * xmenu.c (Fx_popup_dialog, set_frame_menubar) (create_and_show_popup_menu, create_and_show_dialog, xmenu_show): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * xml.c (parse_region): * xrdb.c (magic_file_p): Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough. * xselect.c (TRACE1): Don't assume pid_t promotes to int. (x_get_local_selection, x_reply_selection_request) (x_handle_selection_request, wait_for_property_change): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (selection_data_to_lisp_data): Use short, not EMACS_INT, where short is wide enough. (x_send_client_event): Don't assume fixnum fits in int. * xterm.c (x_x_to_emacs_modifiers): Don't assume EMACS_INT overflows nicely into int. (x_emacs_to_x_modifiers): Use EMACS_INT, not int, because values may come from Lisp. (handle_one_xevent): NATNUMP can eval its arg twice. (x_connection_closed): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. * xterm.h: Adjust decls to match defn changes elsewhere. (struct scroll_bar): Use struct vectorlike_header rather than rolling our own approximation. (SCROLL_BAR_VEC_SIZE): Remove; not used. --- src/coding.c | 268 ++++++++++++++++++++++++++++++----------------------------- 1 file changed, 136 insertions(+), 132 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 5fd59d394d9..704d26f3f9b 100644 --- a/src/coding.c +++ b/src/coding.c @@ -159,7 +159,7 @@ detect_coding_XXX (struct coding_system *coding, const unsigned char *src = coding->source; const unsigned char *src_end = coding->source + coding->src_bytes; int multibytep = coding->src_multibyte; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; int found = 0; ...; @@ -266,7 +266,7 @@ encode_coding_XXX (struct coding_system *coding) unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; unsigned char *adjusted_dst_end = dst_end - _MAX_BYTES_PRODUCED_IN_LOOP_; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; for (; charbuf < charbuf_end && dst < adjusted_dst_end; charbuf++) { @@ -849,31 +849,31 @@ static int encode_coding_raw_text (struct coding_system *); static void coding_set_source (struct coding_system *); static void coding_set_destination (struct coding_system *); -static void coding_alloc_by_realloc (struct coding_system *, EMACS_INT); +static void coding_alloc_by_realloc (struct coding_system *, ptrdiff_t); static void coding_alloc_by_making_gap (struct coding_system *, - EMACS_INT, EMACS_INT); + ptrdiff_t, ptrdiff_t); static unsigned char *alloc_destination (struct coding_system *, - EMACS_INT, unsigned char *); + ptrdiff_t, unsigned char *); static void setup_iso_safe_charsets (Lisp_Object); static unsigned char *encode_designation_at_bol (struct coding_system *, int *, unsigned char *); static int detect_eol (const unsigned char *, - EMACS_INT, enum coding_category); + ptrdiff_t, enum coding_category); static Lisp_Object adjust_coding_eol_type (struct coding_system *, int); static void decode_eol (struct coding_system *); static Lisp_Object get_translation_table (Lisp_Object, int, int *); static Lisp_Object get_translation (Lisp_Object, int *, int *); static int produce_chars (struct coding_system *, Lisp_Object, int); static inline void produce_charset (struct coding_system *, int *, - EMACS_INT); -static void produce_annotation (struct coding_system *, EMACS_INT); + ptrdiff_t); +static void produce_annotation (struct coding_system *, ptrdiff_t); static int decode_coding (struct coding_system *); -static inline int *handle_composition_annotation (EMACS_INT, EMACS_INT, +static inline int *handle_composition_annotation (ptrdiff_t, ptrdiff_t, struct coding_system *, - int *, EMACS_INT *); -static inline int *handle_charset_annotation (EMACS_INT, EMACS_INT, + int *, ptrdiff_t *); +static inline int *handle_charset_annotation (ptrdiff_t, ptrdiff_t, struct coding_system *, - int *, EMACS_INT *); + int *, ptrdiff_t *); static void consume_chars (struct coding_system *, Lisp_Object, int); static int encode_coding (struct coding_system *); static Lisp_Object make_conversion_work_buffer (int); @@ -926,7 +926,7 @@ record_conversion_result (struct coding_system *coding, if (charset_map_loaded) \ { \ const unsigned char *orig = coding->source; \ - EMACS_INT offset; \ + ptrdiff_t offset; \ \ coding_set_source (coding); \ offset = coding->source - orig; \ @@ -946,7 +946,7 @@ record_conversion_result (struct coding_system *coding, do { \ if (dst + (bytes) >= dst_end) \ { \ - EMACS_INT more_bytes = charbuf_end - charbuf + (bytes); \ + ptrdiff_t more_bytes = charbuf_end - charbuf + (bytes); \ \ dst = alloc_destination (coding, more_bytes, dst); \ dst_end = coding->destination + coding->dst_bytes; \ @@ -1069,7 +1069,7 @@ coding_set_destination (struct coding_system *coding) static void -coding_alloc_by_realloc (struct coding_system *coding, EMACS_INT bytes) +coding_alloc_by_realloc (struct coding_system *coding, ptrdiff_t bytes) { if (STRING_BYTES_BOUND - coding->dst_bytes < bytes) string_overflow (); @@ -1080,7 +1080,7 @@ coding_alloc_by_realloc (struct coding_system *coding, EMACS_INT bytes) static void coding_alloc_by_making_gap (struct coding_system *coding, - EMACS_INT gap_head_used, EMACS_INT bytes) + ptrdiff_t gap_head_used, ptrdiff_t bytes) { if (EQ (coding->src_object, coding->dst_object)) { @@ -1088,7 +1088,7 @@ coding_alloc_by_making_gap (struct coding_system *coding, consumed data at the tail. To preserve those data, we at first make the gap size to zero, then increase the gap size. */ - EMACS_INT add = GAP_SIZE; + ptrdiff_t add = GAP_SIZE; GPT += gap_head_used, GPT_BYTE += gap_head_used; GAP_SIZE = 0; ZV += add; Z += add; ZV_BYTE += add; Z_BYTE += add; @@ -1109,10 +1109,10 @@ coding_alloc_by_making_gap (struct coding_system *coding, static unsigned char * -alloc_destination (struct coding_system *coding, EMACS_INT nbytes, +alloc_destination (struct coding_system *coding, ptrdiff_t nbytes, unsigned char *dst) { - EMACS_INT offset = dst - coding->destination; + ptrdiff_t offset = dst - coding->destination; if (BUFFERP (coding->dst_object)) { @@ -1213,7 +1213,7 @@ detect_coding_utf_8 (struct coding_system *coding, const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; int multibytep = coding->src_multibyte; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; int bom_found = 0; int found = 0; @@ -1298,7 +1298,7 @@ decode_coding_utf_8 (struct coding_system *coding) const unsigned char *src_base; int *charbuf = coding->charbuf + coding->charbuf_used; int *charbuf_end = coding->charbuf + coding->charbuf_size; - EMACS_INT consumed_chars = 0, consumed_chars_base = 0; + ptrdiff_t consumed_chars = 0, consumed_chars_base = 0; int multibytep = coding->src_multibyte; enum utf_bom_type bom = CODING_UTF_8_BOM (coding); int eol_dos = @@ -1449,7 +1449,7 @@ encode_coding_utf_8 (struct coding_system *coding) int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; int c; if (CODING_UTF_8_BOM (coding) == utf_with_bom) @@ -1607,7 +1607,7 @@ decode_coding_utf_16 (struct coding_system *coding) int *charbuf = coding->charbuf + coding->charbuf_used; /* We may produces at most 3 chars in one loop. */ int *charbuf_end = coding->charbuf + coding->charbuf_size - 2; - EMACS_INT consumed_chars = 0, consumed_chars_base = 0; + ptrdiff_t consumed_chars = 0, consumed_chars_base = 0; int multibytep = coding->src_multibyte; enum utf_bom_type bom = CODING_UTF_16_BOM (coding); enum utf_16_endian_type endian = CODING_UTF_16_ENDIAN (coding); @@ -1734,7 +1734,7 @@ encode_coding_utf_16 (struct coding_system *coding) int safe_room = 8; enum utf_bom_type bom = CODING_UTF_16_BOM (coding); int big_endian = CODING_UTF_16_ENDIAN (coding) == utf_16_big_endian; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; int c; if (bom != utf_without_bom) @@ -1868,7 +1868,7 @@ detect_coding_emacs_mule (struct coding_system *coding, const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; int multibytep = coding->src_multibyte; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; int c; int found = 0; @@ -2338,10 +2338,10 @@ decode_coding_emacs_mule (struct coding_system *coding) = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3) /* We can produce up to 2 characters in a loop. */ - 1; - EMACS_INT consumed_chars = 0, consumed_chars_base; + ptrdiff_t consumed_chars = 0, consumed_chars_base; int multibytep = coding->src_multibyte; - EMACS_INT char_offset = coding->produced_char; - EMACS_INT last_offset = char_offset; + ptrdiff_t char_offset = coding->produced_char; + ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; int eol_dos = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); @@ -2413,7 +2413,7 @@ decode_coding_emacs_mule (struct coding_system *coding) original pointer to buffer text, and fix up all related pointers after the call. */ const unsigned char *orig = coding->source; - EMACS_INT offset; + ptrdiff_t offset; c = emacs_mule_char (coding, src_base, &nbytes, &nchars, &id, cmp_status); @@ -2594,7 +2594,7 @@ encode_coding_emacs_mule (struct coding_system *coding) unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; int safe_room = 8; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; Lisp_Object attrs, charset_list; int c; int preferred_charset_id = -1; @@ -2881,7 +2881,7 @@ setup_iso_safe_charsets (Lisp_Object attrs) Lisp_Object request; Lisp_Object reg_usage; Lisp_Object tail; - int reg94, reg96; + EMACS_INT reg94, reg96; int flags = XINT (AREF (attrs, coding_attr_iso_flags)); int max_charset_id; @@ -2952,7 +2952,7 @@ detect_coding_iso_2022 (struct coding_system *coding, int single_shifting = 0; int id; int c, c1; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; int i; int rejected = 0; int found = 0; @@ -3462,7 +3462,7 @@ decode_coding_iso_2022 (struct coding_system *coding) loop and one more charset annotation at the end. */ int *charbuf_end = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3); - EMACS_INT consumed_chars = 0, consumed_chars_base; + ptrdiff_t consumed_chars = 0, consumed_chars_base; int multibytep = coding->src_multibyte; /* Charsets invoked to graphic plane 0 and 1 respectively. */ int charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0); @@ -3472,8 +3472,8 @@ decode_coding_iso_2022 (struct coding_system *coding) int c; struct composition_status *cmp_status = CODING_ISO_CMP_STATUS (coding); Lisp_Object attrs = CODING_ID_ATTRS (coding->id); - EMACS_INT char_offset = coding->produced_char; - EMACS_INT last_offset = char_offset; + ptrdiff_t char_offset = coding->produced_char; + ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; int eol_dos = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); @@ -4201,10 +4201,10 @@ decode_coding_iso_2022 (struct coding_system *coding) static unsigned char * encode_invocation_designation (struct charset *charset, struct coding_system *coding, - unsigned char *dst, EMACS_INT *p_nchars) + unsigned char *dst, ptrdiff_t *p_nchars) { int multibytep = coding->dst_multibyte; - EMACS_INT produced_chars = *p_nchars; + ptrdiff_t produced_chars = *p_nchars; int reg; /* graphic register number */ int id = CHARSET_ID (charset); @@ -4296,7 +4296,7 @@ encode_designation_at_bol (struct coding_system *coding, int *charbuf, /* Table of charsets to be designated to each graphic register. */ int r[4]; int c, found = 0, reg; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; int multibytep = coding->dst_multibyte; Lisp_Object attrs; Lisp_Object charset_list; @@ -4351,7 +4351,7 @@ encode_coding_iso_2022 (struct coding_system *coding) int bol_designation = (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATE_AT_BOL && CODING_ISO_BOL (coding)); - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; Lisp_Object attrs, eol_type, charset_list; int ascii_compatible; int c; @@ -4539,7 +4539,7 @@ detect_coding_sjis (struct coding_system *coding, const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; int multibytep = coding->src_multibyte; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; int found = 0; int c; Lisp_Object attrs, charset_list; @@ -4596,7 +4596,7 @@ detect_coding_big5 (struct coding_system *coding, const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; int multibytep = coding->src_multibyte; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; int found = 0; int c; @@ -4647,13 +4647,13 @@ decode_coding_sjis (struct coding_system *coding) the end. */ int *charbuf_end = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2); - EMACS_INT consumed_chars = 0, consumed_chars_base; + ptrdiff_t consumed_chars = 0, consumed_chars_base; int multibytep = coding->src_multibyte; struct charset *charset_roman, *charset_kanji, *charset_kana; struct charset *charset_kanji2; Lisp_Object attrs, charset_list, val; - EMACS_INT char_offset = coding->produced_char; - EMACS_INT last_offset = char_offset; + ptrdiff_t char_offset = coding->produced_char; + ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; int eol_dos = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); @@ -4765,12 +4765,12 @@ decode_coding_big5 (struct coding_system *coding) the end. */ int *charbuf_end = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2); - EMACS_INT consumed_chars = 0, consumed_chars_base; + ptrdiff_t consumed_chars = 0, consumed_chars_base; int multibytep = coding->src_multibyte; struct charset *charset_roman, *charset_big5; Lisp_Object attrs, charset_list, val; - EMACS_INT char_offset = coding->produced_char; - EMACS_INT last_offset = char_offset; + ptrdiff_t char_offset = coding->produced_char; + ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; int eol_dos = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); @@ -4867,7 +4867,7 @@ encode_coding_sjis (struct coding_system *coding) unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; int safe_room = 4; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; Lisp_Object attrs, charset_list, val; int ascii_compatible; struct charset *charset_kanji, *charset_kana; @@ -4958,7 +4958,7 @@ encode_coding_big5 (struct coding_system *coding) unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; int safe_room = 4; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; Lisp_Object attrs, charset_list, val; int ascii_compatible; struct charset *charset_big5; @@ -5033,10 +5033,10 @@ detect_coding_ccl (struct coding_system *coding, const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; int multibytep = coding->src_multibyte; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; int found = 0; unsigned char *valids; - EMACS_INT head_ascii = coding->head_ascii; + ptrdiff_t head_ascii = coding->head_ascii; Lisp_Object attrs; detect_info->checked |= CATEGORY_MASK_CCL; @@ -5073,7 +5073,7 @@ decode_coding_ccl (struct coding_system *coding) const unsigned char *src_end = coding->source + coding->src_bytes; int *charbuf = coding->charbuf + coding->charbuf_used; int *charbuf_end = coding->charbuf + coding->charbuf_size; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; int multibytep = coding->src_multibyte; struct ccl_program *ccl = &coding->spec.ccl->ccl; int source_charbuf[1024]; @@ -5145,7 +5145,7 @@ encode_coding_ccl (struct coding_system *coding) unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; int destination_charbuf[1024]; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; int i; Lisp_Object attrs, charset_list; @@ -5232,7 +5232,7 @@ encode_coding_raw_text (struct coding_system *coding) int *charbuf_end = coding->charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; int c; if (multibytep) @@ -5315,10 +5315,10 @@ detect_coding_charset (struct coding_system *coding, const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; int multibytep = coding->src_multibyte; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; Lisp_Object attrs, valids, name; int found = 0; - EMACS_INT head_ascii = coding->head_ascii; + ptrdiff_t head_ascii = coding->head_ascii; int check_latin_extra = 0; detect_info->checked |= CATEGORY_MASK_CHARSET; @@ -5422,12 +5422,12 @@ decode_coding_charset (struct coding_system *coding) the end. */ int *charbuf_end = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2); - EMACS_INT consumed_chars = 0, consumed_chars_base; + ptrdiff_t consumed_chars = 0, consumed_chars_base; int multibytep = coding->src_multibyte; Lisp_Object attrs = CODING_ID_ATTRS (coding->id); Lisp_Object valids; - EMACS_INT char_offset = coding->produced_char; - EMACS_INT last_offset = char_offset; + ptrdiff_t char_offset = coding->produced_char; + ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; int eol_dos = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); @@ -5548,7 +5548,7 @@ encode_coding_charset (struct coding_system *coding) unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; int safe_room = MAX_MULTIBYTE_LENGTH; - EMACS_INT produced_chars = 0; + ptrdiff_t produced_chars = 0; Lisp_Object attrs, charset_list; int ascii_compatible; int c; @@ -6095,7 +6095,7 @@ complement_process_encoding_system (Lisp_Object coding_system) #define MAX_EOL_CHECK_COUNT 3 static int -detect_eol (const unsigned char *source, EMACS_INT src_bytes, +detect_eol (const unsigned char *source, ptrdiff_t src_bytes, enum coding_category category) { const unsigned char *src = source, *src_end = src + src_bytes; @@ -6456,7 +6456,7 @@ decode_eol (struct coding_system *coding) } else if (EQ (eol_type, Qdos)) { - EMACS_INT n = 0; + ptrdiff_t n = 0; if (NILP (coding->dst_object)) { @@ -6471,9 +6471,9 @@ decode_eol (struct coding_system *coding) } else { - EMACS_INT pos_byte = coding->dst_pos_byte; - EMACS_INT pos = coding->dst_pos; - EMACS_INT pos_end = pos + coding->produced_char - 1; + ptrdiff_t pos_byte = coding->dst_pos_byte; + ptrdiff_t pos = coding->dst_pos; + ptrdiff_t pos_end = pos + coding->produced_char - 1; while (pos < pos_end) { @@ -6636,8 +6636,8 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, { unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; - EMACS_INT produced; - EMACS_INT produced_chars = 0; + ptrdiff_t produced; + ptrdiff_t produced_chars = 0; int carryover = 0; if (! coding->chars_at_source) @@ -6658,7 +6658,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, if (c >= 0) { - EMACS_INT from_nchars = 1, to_nchars = 1; + ptrdiff_t from_nchars = 1, to_nchars = 1; Lisp_Object trans = Qnil; LOOKUP_TRANSLATION_TABLE (translation_table, c, trans); @@ -6735,7 +6735,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, if (coding->src_multibyte) { int multibytep = 1; - EMACS_INT consumed_chars = 0; + ptrdiff_t consumed_chars = 0; while (1) { @@ -6749,7 +6749,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, dst_end = (unsigned char *) src; if (dst == dst_end) { - EMACS_INT offset = src - coding->source; + ptrdiff_t offset = src - coding->source; dst = alloc_destination (coding, src_end - src + 1, dst); @@ -6779,8 +6779,8 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, dst_end = (unsigned char *) src; if (dst >= dst_end - 1) { - EMACS_INT offset = src - coding->source; - EMACS_INT more_bytes; + ptrdiff_t offset = src - coding->source; + ptrdiff_t more_bytes; if (EQ (coding->src_object, coding->dst_object)) more_bytes = ((src_end - src) / 2) + 2; @@ -6802,11 +6802,11 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, { if (!EQ (coding->src_object, coding->dst_object)) { - EMACS_INT require = coding->src_bytes - coding->dst_bytes; + ptrdiff_t require = coding->src_bytes - coding->dst_bytes; if (require > 0) { - EMACS_INT offset = src - coding->source; + ptrdiff_t offset = src - coding->source; dst = alloc_destination (coding, require, dst); coding_set_source (coding); @@ -6834,10 +6834,10 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, */ static inline void -produce_composition (struct coding_system *coding, int *charbuf, EMACS_INT pos) +produce_composition (struct coding_system *coding, int *charbuf, ptrdiff_t pos) { int len; - EMACS_INT to; + ptrdiff_t to; enum composition_method method; Lisp_Object components; @@ -6878,9 +6878,9 @@ produce_composition (struct coding_system *coding, int *charbuf, EMACS_INT pos) */ static inline void -produce_charset (struct coding_system *coding, int *charbuf, EMACS_INT pos) +produce_charset (struct coding_system *coding, int *charbuf, ptrdiff_t pos) { - EMACS_INT from = pos - charbuf[2]; + ptrdiff_t from = pos - charbuf[2]; struct charset *charset = CHARSET_FROM_ID (charbuf[3]); Fput_text_property (make_number (from), make_number (pos), @@ -6913,7 +6913,7 @@ produce_charset (struct coding_system *coding, int *charbuf, EMACS_INT pos) static void -produce_annotation (struct coding_system *coding, EMACS_INT pos) +produce_annotation (struct coding_system *coding, ptrdiff_t pos) { int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; @@ -7013,7 +7013,7 @@ decode_coding (struct coding_system *coding) } do { - EMACS_INT pos = coding->dst_pos + coding->produced_char; + ptrdiff_t pos = coding->dst_pos + coding->produced_char; coding_set_source (coding); coding->annotated = 0; @@ -7106,11 +7106,11 @@ decode_coding (struct coding_system *coding) return BUF. */ static inline int * -handle_composition_annotation (EMACS_INT pos, EMACS_INT limit, +handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit, struct coding_system *coding, int *buf, - EMACS_INT *stop) + ptrdiff_t *stop) { - EMACS_INT start, end; + ptrdiff_t start, end; Lisp_Object prop; if (! find_composition (pos, limit, &start, &end, &prop, coding->src_object) @@ -7189,9 +7189,9 @@ handle_composition_annotation (EMACS_INT pos, EMACS_INT limit, property value is non-nil (limiting by LIMIT), and return BUF. */ static inline int * -handle_charset_annotation (EMACS_INT pos, EMACS_INT limit, +handle_charset_annotation (ptrdiff_t pos, ptrdiff_t limit, struct coding_system *coding, int *buf, - EMACS_INT *stop) + ptrdiff_t *stop) { Lisp_Object val, next; int id; @@ -7218,12 +7218,12 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table, int *buf_end = coding->charbuf + coding->charbuf_size; const unsigned char *src = coding->source + coding->consumed; const unsigned char *src_end = coding->source + coding->src_bytes; - EMACS_INT pos = coding->src_pos + coding->consumed_char; - EMACS_INT end_pos = coding->src_pos + coding->src_chars; + ptrdiff_t pos = coding->src_pos + coding->consumed_char; + ptrdiff_t end_pos = coding->src_pos + coding->src_chars; int multibytep = coding->src_multibyte; Lisp_Object eol_type; int c; - EMACS_INT stop, stop_composition, stop_charset; + ptrdiff_t stop, stop_composition, stop_charset; int *lookup_buf = NULL; if (! NILP (translation_table)) @@ -7272,7 +7272,7 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table, if (! multibytep) { - EMACS_INT bytes; + int bytes; if (coding->encoder == encode_coding_raw_text || coding->encoder == encode_coding_ccl) @@ -7498,9 +7498,9 @@ code_conversion_save (int with_work_buf, int multibyte) int decode_coding_gap (struct coding_system *coding, - EMACS_INT chars, EMACS_INT bytes) + ptrdiff_t chars, ptrdiff_t bytes) { - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); Lisp_Object attrs; code_conversion_save (0, 0); @@ -7527,7 +7527,7 @@ decode_coding_gap (struct coding_system *coding, attrs = CODING_ID_ATTRS (coding->id); if (! NILP (CODING_ATTR_POST_READ (attrs))) { - EMACS_INT prev_Z = Z, prev_Z_BYTE = Z_BYTE; + ptrdiff_t prev_Z = Z, prev_Z_BYTE = Z_BYTE; Lisp_Object val; TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte); @@ -7575,15 +7575,15 @@ decode_coding_gap (struct coding_system *coding, void decode_coding_object (struct coding_system *coding, Lisp_Object src_object, - EMACS_INT from, EMACS_INT from_byte, - EMACS_INT to, EMACS_INT to_byte, + ptrdiff_t from, ptrdiff_t from_byte, + ptrdiff_t to, ptrdiff_t to_byte, Lisp_Object dst_object) { - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); unsigned char *destination IF_LINT (= NULL); - EMACS_INT dst_bytes IF_LINT (= 0); - EMACS_INT chars = to - from; - EMACS_INT bytes = to_byte - from_byte; + ptrdiff_t dst_bytes IF_LINT (= 0); + ptrdiff_t chars = to - from; + ptrdiff_t bytes = to_byte - from_byte; Lisp_Object attrs; int saved_pt = -1, saved_pt_byte IF_LINT (= 0); int need_marker_adjustment = 0; @@ -7676,7 +7676,7 @@ decode_coding_object (struct coding_system *coding, if (! NILP (CODING_ATTR_POST_READ (attrs))) { struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5; - EMACS_INT prev_Z = Z, prev_Z_BYTE = Z_BYTE; + ptrdiff_t prev_Z = Z, prev_Z_BYTE = Z_BYTE; Lisp_Object val; TEMP_SET_PT_BOTH (coding->dst_pos, coding->dst_pos_byte); @@ -7765,13 +7765,13 @@ decode_coding_object (struct coding_system *coding, void encode_coding_object (struct coding_system *coding, Lisp_Object src_object, - EMACS_INT from, EMACS_INT from_byte, - EMACS_INT to, EMACS_INT to_byte, + ptrdiff_t from, ptrdiff_t from_byte, + ptrdiff_t to, ptrdiff_t to_byte, Lisp_Object dst_object) { - int count = SPECPDL_INDEX (); - EMACS_INT chars = to - from; - EMACS_INT bytes = to_byte - from_byte; + ptrdiff_t count = SPECPDL_INDEX (); + ptrdiff_t chars = to - from; + ptrdiff_t bytes = to_byte - from_byte; Lisp_Object attrs; int saved_pt = -1, saved_pt_byte IF_LINT (= 0); int need_marker_adjustment = 0; @@ -8019,7 +8019,7 @@ are lower-case). */) (Lisp_Object prompt, Lisp_Object default_coding_system) { Lisp_Object val; - int count = SPECPDL_INDEX (); + ptrdiff_t count = SPECPDL_INDEX (); if (SYMBOLP (default_coding_system)) default_coding_system = SYMBOL_NAME (default_coding_system); @@ -8071,7 +8071,7 @@ function `define-coding-system'. */) Lisp_Object detect_coding_system (const unsigned char *src, - EMACS_INT src_chars, EMACS_INT src_bytes, + ptrdiff_t src_chars, ptrdiff_t src_bytes, int highest, int multibytep, Lisp_Object coding_system) { @@ -8391,8 +8391,8 @@ If optional argument HIGHEST is non-nil, return the coding system of highest priority. */) (Lisp_Object start, Lisp_Object end, Lisp_Object highest) { - int from, to; - int from_byte, to_byte; + ptrdiff_t from, to; + ptrdiff_t from_byte, to_byte; CHECK_NUMBER_COERCE_MARKER (start); CHECK_NUMBER_COERCE_MARKER (end); @@ -8472,7 +8472,7 @@ DEFUN ("find-coding-systems-region-internal", (Lisp_Object start, Lisp_Object end, Lisp_Object exclude) { Lisp_Object coding_attrs_list, safe_codings; - EMACS_INT start_byte, end_byte; + ptrdiff_t start_byte, end_byte; const unsigned char *p, *pbeg, *pend; int c; Lisp_Object tail, elt, work_table; @@ -8566,7 +8566,7 @@ DEFUN ("find-coding-systems-region-internal", } if (charset_map_loaded) { - EMACS_INT p_offset = p - pbeg, pend_offset = pend - pbeg; + ptrdiff_t p_offset = p - pbeg, pend_offset = pend - pbeg; if (STRINGP (start)) pbeg = SDATA (start); @@ -8604,11 +8604,11 @@ for un-encodable characters. In that case, START and END are indexes to the string. */) (Lisp_Object start, Lisp_Object end, Lisp_Object coding_system, Lisp_Object count, Lisp_Object string) { - int n; + EMACS_INT n; struct coding_system coding; Lisp_Object attrs, charset_list, translation_table; Lisp_Object positions; - int from, to; + ptrdiff_t from, to; const unsigned char *p, *stop, *pend; int ascii_compatible; @@ -8641,11 +8641,10 @@ to the string. */) CHECK_STRING (string); CHECK_NATNUM (start); CHECK_NATNUM (end); + if (! (XINT (start) <= XINT (end) && XINT (end) <= SCHARS (string))) + args_out_of_range_3 (string, start, end); from = XINT (start); to = XINT (end); - if (from > to - || to > SCHARS (string)) - args_out_of_range_3 (string, start, end); if (! STRING_MULTIBYTE (string)) return Qnil; p = SDATA (string) + string_char_to_byte (string, from); @@ -8720,8 +8719,8 @@ is nil. */) (Lisp_Object start, Lisp_Object end, Lisp_Object coding_system_list) { Lisp_Object list; - EMACS_INT start_byte, end_byte; - int pos; + ptrdiff_t start_byte, end_byte; + ptrdiff_t pos; const unsigned char *p, *pbeg, *pend; int c; Lisp_Object tail, elt, attrs; @@ -8794,7 +8793,7 @@ is nil. */) } if (charset_map_loaded) { - EMACS_INT p_offset = p - pbeg, pend_offset = pend - pbeg; + ptrdiff_t p_offset = p - pbeg, pend_offset = pend - pbeg; if (STRINGP (start)) pbeg = SDATA (start); @@ -8827,7 +8826,7 @@ code_convert_region (Lisp_Object start, Lisp_Object end, int encodep, int norecord) { struct coding_system coding; - EMACS_INT from, from_byte, to, to_byte; + ptrdiff_t from, from_byte, to, to_byte; Lisp_Object src_object; CHECK_NUMBER_COERCE_MARKER (start); @@ -8915,7 +8914,7 @@ code_convert_string (Lisp_Object string, Lisp_Object coding_system, Lisp_Object dst_object, int encodep, int nocopy, int norecord) { struct coding_system coding; - EMACS_INT chars, bytes; + ptrdiff_t chars, bytes; CHECK_STRING (string); if (NILP (coding_system)) @@ -9290,7 +9289,7 @@ usage: (find-operation-coding-system OPERATION ARGUMENTS...) */) error ("Too few arguments"); operation = args[0]; if (!SYMBOLP (operation) - || !NATNUMP (target_idx = Fget (operation, Qtarget_idx))) + || (target_idx = Fget (operation, Qtarget_idx), !NATNUMP (target_idx))) error ("Invalid first argument"); if (nargs < 1 + XFASTINT (target_idx)) error ("Too few arguments for operation `%s'", @@ -9511,8 +9510,12 @@ usage: (define-coding-system-internal ...) */) charset_list = Vemacs_mule_charset_list; } for (tail = charset_list; CONSP (tail); tail = XCDR (tail)) - if (max_charset_id < XFASTINT (XCAR (tail))) - max_charset_id = XFASTINT (XCAR (tail)); + { + if (! RANGED_INTEGERP (0, XCAR (tail), INT_MAX - 1)) + error ("Invalid charset-list"); + if (max_charset_id < XFASTINT (XCAR (tail))) + max_charset_id = XFASTINT (XCAR (tail)); + } } else { @@ -9672,23 +9675,23 @@ usage: (define-coding-system-internal ...) */) val = Fcar (tail); if (INTEGERP (val)) { - from = to = XINT (val); - if (from < 0 || from > 255) + if (! (0 <= XINT (val) && XINT (val) <= 255)) args_out_of_range_3 (val, make_number (0), make_number (255)); + from = to = XINT (val); } else { CHECK_CONS (val); CHECK_NATNUM_CAR (val); - CHECK_NATNUM_CDR (val); - from = XINT (XCAR (val)); - if (from > 255) + CHECK_NUMBER_CDR (val); + if (XINT (XCAR (val)) > 255) args_out_of_range_3 (XCAR (val), make_number (0), make_number (255)); - to = XINT (XCDR (val)); - if (to < from || to > 255) + from = XINT (XCAR (val)); + if (! (from <= XINT (XCDR (val)) && XINT (XCDR (val)) <= 255)) args_out_of_range_3 (XCDR (val), XCAR (val), make_number (255)); + to = XINT (XCDR (val)); } for (i = from; i <= to; i++) SSET (valids, i, 1); @@ -9783,9 +9786,10 @@ usage: (define-coding-system-internal ...) */) flags = args[coding_arg_iso2022_flags]; CHECK_NATNUM (flags); - i = XINT (flags); + i = XINT (flags) & INT_MAX; if (EQ (args[coding_arg_charset_list], Qiso_2022)) - flags = make_number (i | CODING_ISO_FLAG_FULL_SUPPORT); + i |= CODING_ISO_FLAG_FULL_SUPPORT; + flags = make_number (i); ASET (attrs, coding_attr_iso_initial, initial); ASET (attrs, coding_attr_iso_usage, reg_usage); -- cgit v1.2.1 From 47664caabe10c081360a1dcf58492163e9f5b43c Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 24 Sep 2011 18:28:59 -0700 Subject: * coding.c (ENCODE_ISO_CHARACTER): Use unsigned, not int, to store the unsigned result of ENCODE_CHAR. --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 704d26f3f9b..44506476794 100644 --- a/src/coding.c +++ b/src/coding.c @@ -4185,7 +4185,7 @@ decode_coding_iso_2022 (struct coding_system *coding) #define ENCODE_ISO_CHARACTER(charset, c) \ do { \ - int code = ENCODE_CHAR ((charset), (c)); \ + unsigned code = ENCODE_CHAR ((charset), (c)); \ \ if (CHARSET_DIMENSION (charset) == 1) \ ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \ -- cgit v1.2.1 From 2c6a9faaaebb2fca42c4f020865c7c077864cad8 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 27 Sep 2011 08:58:20 -0700 Subject: * coding.c: Integer and buffer overflow fixes. (Funencodable_char_position, Fcheck_coding_systems_region) (get_translation, handle_composition_annotation, consume_chars): Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts. (consume_chars): Rewrite to avoid calculating an address outside buffer. --- src/coding.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 44506476794..25ac0e9764c 100644 --- a/src/coding.c +++ b/src/coding.c @@ -6613,8 +6613,8 @@ get_translation (Lisp_Object trans, int *buf, int *buf_end) { Lisp_Object val = XCAR (trans); Lisp_Object from = XCAR (val); - int len = ASIZE (from); - int i; + ptrdiff_t len = ASIZE (from); + ptrdiff_t i; for (i = 0; i < len; i++) { @@ -7132,7 +7132,7 @@ handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit, if (method != COMPOSITION_RELATIVE) { Lisp_Object components; - int len, i, i_byte; + ptrdiff_t i, len, i_byte; components = COMPOSITION_COMPONENTS (prop); if (VECTORP (components)) @@ -7303,7 +7303,7 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table, *buf++ = c; else { - int from_nchars = 1, to_nchars = 1; + ptrdiff_t from_nchars = 1, to_nchars = 1; int *lookup_buf_end; const unsigned char *p = src; int i; @@ -7324,7 +7324,7 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table, else { to_nchars = ASIZE (trans); - if (buf + to_nchars > buf_end) + if (buf_end - buf < to_nchars) break; c = XINT (AREF (trans, 0)); } -- cgit v1.2.1 From 7b09a37a895ab2d428d1ab0786aa262ef82efba2 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 27 Sep 2011 09:31:12 -0700 Subject: * coding.c (Ffind_operation_coding_system): Avoid subscript error. --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 25ac0e9764c..e8765aea96d 100644 --- a/src/coding.c +++ b/src/coding.c @@ -9291,7 +9291,7 @@ usage: (find-operation-coding-system OPERATION ARGUMENTS...) */) if (!SYMBOLP (operation) || (target_idx = Fget (operation, Qtarget_idx), !NATNUMP (target_idx))) error ("Invalid first argument"); - if (nargs < 1 + XFASTINT (target_idx)) + if (nargs <= 1 + XFASTINT (target_idx)) error ("Too few arguments for operation `%s'", SDATA (SYMBOL_NAME (operation))); target = args[XFASTINT (target_idx) + 1]; -- cgit v1.2.1 From 0e5317f7e42c1008c40305a94afcdff509a475be Mon Sep 17 00:00:00 2001 From: Kenichi Handa Date: Wed, 28 Dec 2011 16:55:49 +0900 Subject: coding.c: (Fdefine_coding_system_internal): Make an utf-8 base coding-system ASCII compatible only when it does not produce BOM on encoding (Bug#10383). --- src/coding.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index e15d725af3a..2db5385c932 100644 --- a/src/coding.c +++ b/src/coding.c @@ -9999,8 +9999,6 @@ usage: (define-coding-system-internal ...) */) { Lisp_Object bom; - CODING_ATTR_ASCII_COMPAT (attrs) = Qt; - if (nargs < coding_arg_utf8_max) goto short_args; @@ -10014,6 +10012,8 @@ usage: (define-coding-system-internal ...) */) CHECK_CODING_SYSTEM (val); } ASET (attrs, coding_attr_utf_bom, bom); + if (NILP (bom)) + CODING_ATTR_ASCII_COMPAT (attrs) = Qt; category = (CONSP (bom) ? coding_category_utf_8_auto : NILP (bom) ? coding_category_utf_8_nosig -- cgit v1.2.1 From acaf905b1130aae80fa59d2c861ffd4c8eb75486 Mon Sep 17 00:00:00 2001 From: Glenn Morris Date: Thu, 5 Jan 2012 01:46:05 -0800 Subject: Add 2012 to FSF copyright years for Emacs files --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 2db5385c932..5c3048f95e8 100644 --- a/src/coding.c +++ b/src/coding.c @@ -1,5 +1,5 @@ /* Coding system handler (conversion, detection, etc). - Copyright (C) 2001-2011 Free Software Foundation, Inc. + Copyright (C) 2001-2012 Free Software Foundation, Inc. Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 National Institute of Advanced Industrial Science and Technology (AIST) -- cgit v1.2.1 From 49f70d46ea38ceb7a501594db7f6ea35e19681aa Mon Sep 17 00:00:00 2001 From: Glenn Morris Date: Tue, 10 Jan 2012 23:52:35 -0800 Subject: Add 2012 to FSF copyright years for Emacs files (do not merge to trunk) --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 555e6623383..fbb028f658c 100644 --- a/src/coding.c +++ b/src/coding.c @@ -1,6 +1,6 @@ /* Coding system handler (conversion, detection, etc). Copyright (C) 2001, 2002, 2003, 2004, 2005, - 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc. + 2006, 2007, 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc. Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 National Institute of Advanced Industrial Science and Technology (AIST) -- cgit v1.2.1 From a32a7dc7214bf5f618d50d0143fe5f8159445d2d Mon Sep 17 00:00:00 2001 From: Kenichi Handa Date: Thu, 19 Jan 2012 22:19:21 +0800 Subject: Pay attention to buffer relocation on encoding (Bug#9318; backport from trunk). Backport of 2011-12-05T06:39:26Z!handa@m17n.org from trunk. --- src/coding.c | 171 +++++++++++++++++++++++++++++++++++++++++++++-------------- 1 file changed, 131 insertions(+), 40 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index fbb028f658c..9a2c1f9c3f2 100644 --- a/src/coding.c +++ b/src/coding.c @@ -936,17 +936,16 @@ static int encode_coding_ccl P_ ((struct coding_system *)); static void decode_coding_raw_text P_ ((struct coding_system *)); static int encode_coding_raw_text P_ ((struct coding_system *)); -static void coding_set_source P_ ((struct coding_system *)); -static void coding_set_destination P_ ((struct coding_system *)); +static EMACS_INT coding_set_source P_ ((struct coding_system *)); +static EMACS_INT coding_set_destination P_ ((struct coding_system *)); static void coding_alloc_by_realloc P_ ((struct coding_system *, EMACS_INT)); static void coding_alloc_by_making_gap P_ ((struct coding_system *, EMACS_INT, EMACS_INT)); static unsigned char *alloc_destination P_ ((struct coding_system *, EMACS_INT, unsigned char *)); static void setup_iso_safe_charsets P_ ((Lisp_Object)); -static unsigned char *encode_designation_at_bol P_ ((struct coding_system *, - int *, int *, - unsigned char *)); +static int encode_designation_at_bol P_ ((struct coding_system *, + int *, int *, unsigned char *)); static int detect_eol P_ ((const unsigned char *, EMACS_INT, enum coding_category)); static Lisp_Object adjust_coding_eol_type P_ ((struct coding_system *, int)); @@ -1005,27 +1004,68 @@ record_conversion_result (struct coding_system *coding, } } -/* This wrapper macro is used to preserve validity of pointers into - buffer text across calls to decode_char, which could cause - relocation of buffers if it loads a charset map, because loading a - charset map allocates large structures. */ +/* These wrapper macros are used to preserve validity of pointers into + buffer text across calls to decode_char, encode_char, etc, which + could cause relocation of buffers if it loads a charset map, + because loading a charset map allocates large structures. */ + #define CODING_DECODE_CHAR(coding, src, src_base, src_end, charset, code, c) \ do { \ + EMACS_INT offset; \ + \ charset_map_loaded = 0; \ c = DECODE_CHAR (charset, code); \ - if (charset_map_loaded) \ + if (charset_map_loaded \ + && (offset = coding_set_source (coding))) \ { \ - const unsigned char *orig = coding->source; \ - EMACS_INT offset; \ - \ - coding_set_source (coding); \ - offset = coding->source - orig; \ src += offset; \ src_base += offset; \ src_end += offset; \ } \ } while (0) +#define CODING_ENCODE_CHAR(coding, dst, dst_end, charset, c, code) \ + do { \ + EMACS_INT offset; \ + \ + charset_map_loaded = 0; \ + code = ENCODE_CHAR (charset, c); \ + if (charset_map_loaded \ + && (offset = coding_set_destination (coding))) \ + { \ + dst += offset; \ + dst_end += offset; \ + } \ + } while (0) + +#define CODING_CHAR_CHARSET(coding, dst, dst_end, c, charset_list, code_return, charset) \ + do { \ + EMACS_INT offset; \ + \ + charset_map_loaded = 0; \ + charset = char_charset (c, charset_list, code_return); \ + if (charset_map_loaded \ + && (offset = coding_set_destination (coding))) \ + { \ + dst += offset; \ + dst_end += offset; \ + } \ + } while (0) + +#define CODING_CHAR_CHARSET_P(coding, dst, dst_end, c, charset, result) \ + do { \ + EMACS_INT offset; \ + \ + charset_map_loaded = 0; \ + result = CHAR_CHARSET_P (c, charset); \ + if (charset_map_loaded \ + && (offset = coding_set_destination (coding))) \ + { \ + dst += offset; \ + dst_end += offset; \ + } \ + } while (0) + /* If there are at least BYTES length of room at dst, allocate memory for coding->destination and update dst and dst_end. We don't have @@ -1105,10 +1145,15 @@ record_conversion_result (struct coding_system *coding, | ((p)[-1] & 0x3F)))) -static void +/* Update coding->source from coding->src_object, and return how many + bytes coding->source was changed. */ + +static EMACS_INT coding_set_source (coding) struct coding_system *coding; { + const unsigned char *orig = coding->source; + if (BUFFERP (coding->src_object)) { struct buffer *buf = XBUFFER (coding->src_object); @@ -1126,12 +1171,19 @@ coding_set_source (coding) /* Otherwise, the source is C string and is never relocated automatically. Thus we don't have to update anything. */ ; + + return coding->source - orig; } -static void +/* Update coding->destination from coding->dst_object, and return how + many bytes coding->destination was changed. */ + +static EMACS_INT coding_set_destination (coding) struct coding_system *coding; { + const unsigned char *orig = coding->destination; + if (BUFFERP (coding->dst_object)) { if (coding->src_pos < 0) @@ -1155,6 +1207,8 @@ coding_set_destination (coding) /* Otherwise, the destination is C string and is never relocated automatically. Thus we don't have to update anything. */ ; + + return coding->destination - orig; } @@ -2778,14 +2832,19 @@ encode_coding_emacs_mule (coding) if (preferred_charset_id >= 0) { + int result; + charset = CHARSET_FROM_ID (preferred_charset_id); - if (CHAR_CHARSET_P (c, charset)) + CODING_CHAR_CHARSET_P (coding, dst, dst_end, c, charset, result); + if (result) code = ENCODE_CHAR (charset, c); else - charset = char_charset (c, charset_list, &code); + CODING_CHAR_CHARSET (coding, dst, dst_end, c, charset_list, + &code, charset); } else - charset = char_charset (c, charset_list, &code); + CODING_CHAR_CHARSET (coding, dst, dst_end, c, charset_list, + &code, charset); if (! charset) { c = coding->default_char; @@ -2794,7 +2853,8 @@ encode_coding_emacs_mule (coding) EMIT_ONE_ASCII_BYTE (c); continue; } - charset = char_charset (c, charset_list, &code); + CODING_CHAR_CHARSET (coding, dst, dst_end, c, charset_list, + &code, charset); } dimension = CHARSET_DIMENSION (charset); emacs_mule_id = CHARSET_EMACS_MULE_ID (charset); @@ -4317,7 +4377,8 @@ decode_coding_iso_2022 (coding) #define ENCODE_ISO_CHARACTER(charset, c) \ do { \ - int code = ENCODE_CHAR ((charset),(c)); \ + int code; \ + CODING_ENCODE_CHAR (coding, dst, dst_end, (charset), (c), code); \ \ if (CHARSET_DIMENSION (charset) == 1) \ ENCODE_ISO_CHARACTER_DIMENSION1 ((charset), code); \ @@ -4441,17 +4502,20 @@ encode_invocation_designation (charset, coding, dst, p_nchars) /* Produce designation sequences of charsets in the line started from - SRC to a place pointed by DST, and return updated DST. + CHARBUF to a place pointed by DST, and return the number of + produced bytes. DST should not directly point a buffer text area + which may be relocated by char_charset call. If the current block ends before any end-of-line, we may fail to find all the necessary designations. */ -static unsigned char * +static int encode_designation_at_bol (coding, charbuf, charbuf_end, dst) struct coding_system *coding; int *charbuf, *charbuf_end; unsigned char *dst; { + unsigned char *orig; struct charset *charset; /* Table of charsets to be designated to each graphic register. */ int r[4]; @@ -4469,7 +4533,7 @@ encode_designation_at_bol (coding, charbuf, charbuf_end, dst) for (reg = 0; reg < 4; reg++) r[reg] = -1; - while (found < 4) + while (charbuf < charbuf_end && found < 4) { int id; @@ -4494,7 +4558,7 @@ encode_designation_at_bol (coding, charbuf, charbuf_end, dst) ENCODE_DESIGNATION (CHARSET_FROM_ID (r[reg]), reg, coding); } - return dst; + return dst - orig; } /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */ @@ -4539,13 +4603,26 @@ encode_coding_iso_2022 (coding) if (bol_designation) { - unsigned char *dst_prev = dst; - /* We have to produce designation sequences if any now. */ - dst = encode_designation_at_bol (coding, charbuf, charbuf_end, dst); - bol_designation = 0; + unsigned char desig_buf[16]; + int nbytes; + EMACS_INT offset; + + charset_map_loaded = 0; + nbytes = encode_designation_at_bol (coding, charbuf, charbuf_end, + desig_buf); + if (charset_map_loaded + && (offset = coding_set_destination (coding))) + { + dst += offset; + dst_end += offset; + } + memcpy (dst, desig_buf, nbytes); + dst += nbytes; /* We are sure that designation sequences are all ASCII bytes. */ - produced_chars += dst - dst_prev; + produced_chars += nbytes; + bol_designation = 0; + ASSURE_DESTINATION (safe_room); } c = *charbuf++; @@ -4616,12 +4693,17 @@ encode_coding_iso_2022 (coding) if (preferred_charset_id >= 0) { + int result; + charset = CHARSET_FROM_ID (preferred_charset_id); - if (! CHAR_CHARSET_P (c, charset)) - charset = char_charset (c, charset_list, NULL); + CODING_CHAR_CHARSET_P (coding, dst, dst_end, c, charset, result); + if (! result) + CODING_CHAR_CHARSET (coding, dst, dst_end, c, charset_list, + NULL, charset); } else - charset = char_charset (c, charset_list, NULL); + CODING_CHAR_CHARSET (coding, dst, dst_end, c, charset_list, + NULL, charset); if (!charset) { if (coding->mode & CODING_MODE_SAFE_ENCODING) @@ -4632,7 +4714,8 @@ encode_coding_iso_2022 (coding) else { c = coding->default_char; - charset = char_charset (c, charset_list, NULL); + CODING_CHAR_CHARSET (coding, dst, dst_end, c, + charset_list, NULL, charset); } } ENCODE_ISO_CHARACTER (charset, c); @@ -5064,7 +5147,9 @@ encode_coding_sjis (coding) else { unsigned code; - struct charset *charset = char_charset (c, charset_list, &code); + struct charset *charset; + CODING_CHAR_CHARSET (coding, dst, dst_end, c, charset_list, + &code, charset); if (!charset) { @@ -5076,7 +5161,8 @@ encode_coding_sjis (coding) else { c = coding->default_char; - charset = char_charset (c, charset_list, &code); + CODING_CHAR_CHARSET (coding, dst, dst_end, c, + charset_list, &code, charset); } } if (code == CHARSET_INVALID_CODE (charset)) @@ -5153,7 +5239,9 @@ encode_coding_big5 (coding) else { unsigned code; - struct charset *charset = char_charset (c, charset_list, &code); + struct charset *charset; + CODING_CHAR_CHARSET (coding, dst, dst_end, c, charset_list, + &code, charset); if (! charset) { @@ -5165,7 +5253,8 @@ encode_coding_big5 (coding) else { c = coding->default_char; - charset = char_charset (c, charset_list, &code); + CODING_CHAR_CHARSET (coding, dst, dst_end, c, + charset_list, &code, charset); } } if (code == CHARSET_INVALID_CODE (charset)) @@ -5747,7 +5836,9 @@ encode_coding_charset (coding) } else { - charset = char_charset (c, charset_list, &code); + CODING_CHAR_CHARSET (coding, dst, dst_end, c, charset_list, + &code, charset); + if (charset) { if (CHARSET_DIMENSION (charset) == 1) -- cgit v1.2.1 From 76774ec8c5284dd327c13e468293a99c04103720 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Thu, 19 Jan 2012 22:35:41 +0800 Subject: Fix usage of unitialized local var (backport from trunk) * src/coding.c (encode_designation_at_bol): Don't use uninitialized local variable (Bug#9318). --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 9a2c1f9c3f2..898bfd71f43 100644 --- a/src/coding.c +++ b/src/coding.c @@ -4515,7 +4515,7 @@ encode_designation_at_bol (coding, charbuf, charbuf_end, dst) int *charbuf, *charbuf_end; unsigned char *dst; { - unsigned char *orig; + unsigned char *orig = dst; struct charset *charset; /* Table of charsets to be designated to each graphic register. */ int r[4]; -- cgit v1.2.1 From 5f53d2441abf6eafe8e14f29d73e14afe8bec35f Mon Sep 17 00:00:00 2001 From: HIROSHI OOTA Date: Wed, 25 Jan 2012 13:35:05 +0800 Subject: * src/coding.c (encode_designation_at_bol): Change return value to EMACS_INT. --- src/coding.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 898bfd71f43..8e96db1f521 100644 --- a/src/coding.c +++ b/src/coding.c @@ -944,7 +944,7 @@ static void coding_alloc_by_making_gap P_ ((struct coding_system *, static unsigned char *alloc_destination P_ ((struct coding_system *, EMACS_INT, unsigned char *)); static void setup_iso_safe_charsets P_ ((Lisp_Object)); -static int encode_designation_at_bol P_ ((struct coding_system *, +static EMACS_INT encode_designation_at_bol P_ ((struct coding_system *, int *, int *, unsigned char *)); static int detect_eol P_ ((const unsigned char *, EMACS_INT, enum coding_category)); @@ -4509,7 +4509,7 @@ encode_invocation_designation (charset, coding, dst, p_nchars) If the current block ends before any end-of-line, we may fail to find all the necessary designations. */ -static int +static EMACS_INT encode_designation_at_bol (coding, charbuf, charbuf_end, dst) struct coding_system *coding; int *charbuf, *charbuf_end; -- cgit v1.2.1 From 14af5f7fc4d7557ee712d3b6a8b46d9034c2ff39 Mon Sep 17 00:00:00 2001 From: Chong Yidong Date: Wed, 25 Jan 2012 13:55:01 +0800 Subject: Merge from emacs-23 branch --- src/coding.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 5c3048f95e8..15e8572edb3 100644 --- a/src/coding.c +++ b/src/coding.c @@ -855,7 +855,7 @@ static void coding_alloc_by_making_gap (struct coding_system *, static unsigned char *alloc_destination (struct coding_system *, EMACS_INT, unsigned char *); static void setup_iso_safe_charsets (Lisp_Object); -static int encode_designation_at_bol (struct coding_system *, +static EMACS_INT encode_designation_at_bol (struct coding_system *, int *, int *, unsigned char *); static int detect_eol (const unsigned char *, EMACS_INT, enum coding_category); @@ -4351,7 +4351,7 @@ encode_invocation_designation (struct charset *charset, If the current block ends before any end-of-line, we may fail to find all the necessary designations. */ -static int +static EMACS_INT encode_designation_at_bol (struct coding_system *coding, int *charbuf, int *charbuf_end, unsigned char *dst) -- cgit v1.2.1 From c1892f1145dd05df037fc580acc5616f6d164238 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 26 May 2012 15:27:21 -0700 Subject: Fix coding-related core dumps with gcc -ftrapv. The code was computing A - B, where A and B are pointers, and B is random garbage. This can lead to core dumps on platforms that have special pointer registers, and it also leads to core dumps on x86-64 when compiled with gcc -ftrapv. The fix is to compute A - B only when B is initialized properly. * coding.c (coding_set_source, coding_set_destination): Return void. (coding_change_source, coding_change_destinations): New functions, with the old behaviors of coding_set_source and coding_set_destination. All callers that need an offset changed to use these new functions. --- src/coding.c | 52 +++++++++++++++++++++++++++++++++++----------------- 1 file changed, 35 insertions(+), 17 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 42f342c390f..17e342298b9 100644 --- a/src/coding.c +++ b/src/coding.c @@ -847,8 +847,10 @@ static int encode_coding_ccl (struct coding_system *); static void decode_coding_raw_text (struct coding_system *); static int encode_coding_raw_text (struct coding_system *); -static ptrdiff_t coding_set_source (struct coding_system *); -static ptrdiff_t coding_set_destination (struct coding_system *); +static void coding_set_source (struct coding_system *); +static ptrdiff_t coding_change_source (struct coding_system *); +static void coding_set_destination (struct coding_system *); +static ptrdiff_t coding_change_destination (struct coding_system *); static void coding_alloc_by_realloc (struct coding_system *, ptrdiff_t); static void coding_alloc_by_making_gap (struct coding_system *, ptrdiff_t, ptrdiff_t); @@ -927,7 +929,7 @@ record_conversion_result (struct coding_system *coding, charset_map_loaded = 0; \ c = DECODE_CHAR (charset, code); \ if (charset_map_loaded \ - && (offset = coding_set_source (coding))) \ + && (offset = coding_change_source (coding))) \ { \ src += offset; \ src_base += offset; \ @@ -942,7 +944,7 @@ record_conversion_result (struct coding_system *coding, charset_map_loaded = 0; \ code = ENCODE_CHAR (charset, c); \ if (charset_map_loaded \ - && (offset = coding_set_destination (coding))) \ + && (offset = coding_change_destination (coding))) \ { \ dst += offset; \ dst_end += offset; \ @@ -956,7 +958,7 @@ record_conversion_result (struct coding_system *coding, charset_map_loaded = 0; \ charset = char_charset (c, charset_list, code_return); \ if (charset_map_loaded \ - && (offset = coding_set_destination (coding))) \ + && (offset = coding_change_destination (coding))) \ { \ dst += offset; \ dst_end += offset; \ @@ -970,7 +972,7 @@ record_conversion_result (struct coding_system *coding, charset_map_loaded = 0; \ result = CHAR_CHARSET_P (c, charset); \ if (charset_map_loaded \ - && (offset = coding_set_destination (coding))) \ + && (offset = coding_change_destination (coding))) \ { \ dst += offset; \ dst_end += offset; \ @@ -1056,14 +1058,11 @@ record_conversion_result (struct coding_system *coding, | ((p)[-1] & 0x3F)))) -/* Update coding->source from coding->src_object, and return how many - bytes coding->source was changed. */ +/* Set coding->source from coding->src_object. */ -static ptrdiff_t +static void coding_set_source (struct coding_system *coding) { - const unsigned char *orig = coding->source; - if (BUFFERP (coding->src_object)) { struct buffer *buf = XBUFFER (coding->src_object); @@ -1082,18 +1081,26 @@ coding_set_source (struct coding_system *coding) /* Otherwise, the source is C string and is never relocated automatically. Thus we don't have to update anything. */ } - return coding->source - orig; } -/* Update coding->destination from coding->dst_object, and return how - many bytes coding->destination was changed. */ +/* Set coding->source from coding->src_object, and return how many + bytes coding->source was changed. */ static ptrdiff_t -coding_set_destination (struct coding_system *coding) +coding_change_source (struct coding_system *coding) { - const unsigned char *orig = coding->destination; + const unsigned char *orig = coding->source; + coding_set_source (coding); + return coding->source - orig; +} + +/* Set coding->destination from coding->dst_object. */ + +static void +coding_set_destination (struct coding_system *coding) +{ if (BUFFERP (coding->dst_object)) { if (BUFFERP (coding->src_object) && coding->src_pos < 0) @@ -1118,6 +1125,17 @@ coding_set_destination (struct coding_system *coding) /* Otherwise, the destination is C string and is never relocated automatically. Thus we don't have to update anything. */ } +} + + +/* Set coding->destination from coding->dst_object, and return how + many bytes coding->destination was changed. */ + +static ptrdiff_t +coding_change_destination (struct coding_system *coding) +{ + const unsigned char *orig = coding->destination; + coding_set_destination (coding); return coding->destination - orig; } @@ -4452,7 +4470,7 @@ encode_coding_iso_2022 (struct coding_system *coding) nbytes = encode_designation_at_bol (coding, charbuf, charbuf_end, desig_buf); if (charset_map_loaded - && (offset = coding_set_destination (coding))) + && (offset = coding_change_destination (coding))) { dst += offset; dst_end += offset; -- cgit v1.2.1 From e5560ff7d28c684003ed598a9390e17f9fb92d34 Mon Sep 17 00:00:00 2001 From: Andreas Schwab Date: Sat, 16 Jun 2012 14:24:15 +0200 Subject: * buffer.h (FETCH_MULTIBYTE_CHAR): Define as inline. (BUF_FETCH_MULTIBYTE_CHAR): Likewise. * character.c (_fetch_multibyte_char_p): Remove. * alloc.c: Include "character.h" before "buffer.h". * bidi.c: Likewise. * buffer.c: Likewise. * bytecode.c: Likewise. * callint.c: Likewise. * callproc.c: Likewise. * casefiddle.c: Likewise. * casetab.c: Likewise. * category.c: Likewise. * cmds.c: Likewise. * coding.c: Likewise. * composite.c: Likewise. * dired.c: Likewise. * dispnew.c: Likewise. * doc.c: Likewise. * dosfns.c: Likewise. * editfns.c: Likewise. * emacs.c: Likewise. * fileio.c: Likewise. * filelock.c: Likewise. * font.c: Likewise. * fontset.c: Likewise. * fringe.c: Likewise. * indent.c: Likewise. * insdel.c: Likewise. * intervals.c: Likewise. * keyboard.c: Likewise. * keymap.c: Likewise. * lread.c: Likewise. * macros.c: Likewise. * marker.c: Likewise. * minibuf.c: Likewise. * nsfns.m: Likewise. * nsmenu.m: Likewise. * print.c: Likewise. * process.c: Likewise. * regex.c: Likewise. * region-cache.c: Likewise. * search.c: Likewise. * syntax.c: Likewise. * term.c: Likewise. * textprop.c: Likewise. * undo.c: Likewise. * unexsol.c: Likewise. * w16select.c: Likewise. * w32fns.c: Likewise. * w32menu.c: Likewise. * window.c: Likewise. * xdisp.c: Likewise. * xfns.c: Likewise. * xmenu.c: Likewise. * xml.c: Likewise. * xselect.c: Likewise. --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 17e342298b9..ab13f0311c0 100644 --- a/src/coding.c +++ b/src/coding.c @@ -288,8 +288,8 @@ encode_coding_XXX (struct coding_system *coding) #include #include "lisp.h" -#include "buffer.h" #include "character.h" +#include "buffer.h" #include "charset.h" #include "ccl.h" #include "composite.h" -- cgit v1.2.1 From 27bb1ca4b00cb47153db3016ced27c0327932fce Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sun, 17 Jun 2012 00:57:28 -0700 Subject: * coding.c (produce_chars): Use ptrdiff_t, not int. --- src/coding.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index ab13f0311c0..64826ae16b9 100644 --- a/src/coding.c +++ b/src/coding.c @@ -6765,7 +6765,8 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, while (buf < buf_end) { - int c = *buf, i; + int c = *buf; + ptrdiff_t i; if (c >= 0) { -- cgit v1.2.1 From 28be1ada0fb9a4b51cf361dc45208e764bd34143 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Tue, 19 Jun 2012 20:56:28 +0400 Subject: * alloc.c, bytecode.c, ccl.c, coding.c, composite.c, data.c, dosfns.c: * font.c, image.c, keyboard.c, lread.c, menu.c, minibuf.c, msdos.c: * print.c, syntax.c, window.c, xmenu.c, xselect.c: Replace direct access to `contents' member of Lisp_Vector objects with AREF and ASET where appropriate. --- src/coding.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 64826ae16b9..b0359b89cb5 100644 --- a/src/coding.c +++ b/src/coding.c @@ -3189,7 +3189,7 @@ detect_coding_iso_2022 (struct coding_system *coding, break; check_extra_latin: if (! VECTORP (Vlatin_extra_code_table) - || NILP (XVECTOR (Vlatin_extra_code_table)->contents[c])) + || NILP (AREF (Vlatin_extra_code_table, c))) { rejected = CATEGORY_MASK_ISO; break; @@ -5464,7 +5464,7 @@ detect_coding_charset (struct coding_system *coding, if (c < 0xA0 && check_latin_extra && (!VECTORP (Vlatin_extra_code_table) - || NILP (XVECTOR (Vlatin_extra_code_table)->contents[c]))) + || NILP (AREF (Vlatin_extra_code_table, c)))) break; found = CATEGORY_MASK_CHARSET; } @@ -10560,7 +10560,7 @@ Don't modify this variable directly, but use `set-coding-system-priority'. */); Vcoding_category_list = Qnil; for (i = coding_category_max - 1; i >= 0; i--) Vcoding_category_list - = Fcons (XVECTOR (Vcoding_category_table)->contents[i], + = Fcons (AREF (Vcoding_category_table, i), Vcoding_category_list); } -- cgit v1.2.1 From 23f86fce48e1cc8118f0ea5cce49d1acfd4364c4 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Thu, 5 Jul 2012 10:32:41 +0400 Subject: Cleanup xmalloc. * admin/coccinelle/xzalloc.cocci: Semantic patch to convert calls to xmalloc with following memset to xzalloc. * src/lisp.h (xzalloc): New prototype. Omit needless casts. * src/alloc.c (xzalloc): New function. Omit needless casts. * src/charset.c: Omit needless casts. Convert all calls to malloc with following memset to xzalloc. * src/dispnew.c: Likewise. * src/fringe.c: Likewise. * src/image.c: Likewise. * src/sound.c: Likewise. * src/term.c: Likewise. * src/w32fns.c: Likewise. * src/w32font.c: Likewise. * src/w32term.c: Likewise. * src/xfaces.c: Likewise. * src/xfns.c: Likewise. * src/xterm.c: Likewise. * src/atimer.c: Omit needless casts. * src/buffer.c: Likewise. * src/callproc.c: Likewise. * src/ccl.c: Likewise. * src/coding.c: Likewise. * src/composite.c: Likewise. * src/doc.c: Likewise. * src/doprnt.c: Likewise. * src/editfns.c: Likewise. * src/emacs.c: Likewise. * src/eval.c: Likewise. * src/filelock.c: Likewise. * src/fns.c: Likewise. * src/gtkutil.c: Likewise. * src/keyboard.c: Likewise. * src/lisp.h: Likewise. * src/lread.c: Likewise. * src/minibuf.c: Likewise. * src/msdos.c: Likewise. * src/print.c: Likewise. * src/process.c: Likewise. * src/region-cache.c: Likewise. * src/search.c: Likewise. * src/sysdep.c: Likewise. * src/termcap.c: Likewise. * src/terminal.c: Likewise. * src/tparam.c: Likewise. * src/w16select.c: Likewise. * src/w32.c: Likewise. * src/w32reg.c: Likewise. * src/w32select.c: Likewise. * src/w32uniscribe.c: Likewise. * src/widget.c: Likewise. * src/xdisp.c: Likewise. * src/xmenu.c: Likewise. * src/xrdb.c: Likewise. * src/xselect.c: Likewise. --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index b0359b89cb5..891fea09abf 100644 --- a/src/coding.c +++ b/src/coding.c @@ -8006,7 +8006,7 @@ encode_coding_object (struct coding_system *coding, { ptrdiff_t dst_bytes = max (1, coding->src_chars); coding->dst_object = Qnil; - coding->destination = (unsigned char *) xmalloc (dst_bytes); + coding->destination = xmalloc (dst_bytes); coding->dst_bytes = dst_bytes; coding->dst_multibyte = 0; } -- cgit v1.2.1 From 38182d901d030c7d65f4aa7a49b583afb30eb9b7 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Thu, 5 Jul 2012 11:35:48 -0700 Subject: More xmalloc and related cleanup. * alloc.c, bidi.c, buffer.c, buffer.h, bytecode.c, callint.c: * callproc.c, charset.c, coding.c, composite.c, data.c, dispnew.c: * doc.c, editfns.c, emacs.c, eval.c, fileio.c, filelock.c, fns.c: * font.c, fontset.c, frame.c, fringe.c, ftfont.c, ftxfont.c, gmalloc.c: * gtkutil.c, image.c, keyboard.c, keymap.c, lread.c, macros.c, menu.c: * nsfns.m, nsfont.m, nsmenu.m, nsterm.m, print.c, process.c, ralloc.c: * regex.c, region-cache.c, scroll.c, search.c, sound.c, syntax.c: * sysdep.c, term.c, termcap.c, unexmacosx.c, window.c, xdisp.c: * xfaces.c, xfns.c, xftfont.c, xgselect.c, xmenu.c, xrdb.c, xselect.c: * xterm.c: Omit needless casts involving void * pointers and allocation. Prefer "P = xmalloc (sizeof *P)" to "P = xmalloc (sizeof (TYPE_OF_P))", as the former is more robust if P's type is changed. Prefer xzalloc to xmalloc + memset 0. Simplify malloc-or-realloc to realloc. Don't worry about xmalloc returning a null pointer. Prefer xstrdup to xmalloc + strcpy. * editfns.c (Fmessage_box): Grow message_text by at least 80 when growing it. * keyboard.c (apply_modifiers_uncached): Prefer local array to alloca of a constant. --- src/coding.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 891fea09abf..4b2a9740121 100644 --- a/src/coding.c +++ b/src/coding.c @@ -1145,8 +1145,8 @@ coding_alloc_by_realloc (struct coding_system *coding, ptrdiff_t bytes) { if (STRING_BYTES_BOUND - coding->dst_bytes < bytes) string_overflow (); - coding->destination = (unsigned char *) xrealloc (coding->destination, - coding->dst_bytes + bytes); + coding->destination = xrealloc (coding->destination, + coding->dst_bytes + bytes); coding->dst_bytes += bytes; } @@ -7010,7 +7010,7 @@ produce_charset (struct coding_system *coding, int *charbuf, ptrdiff_t pos) coding->charbuf = NULL; \ while (size > 1024) \ { \ - coding->charbuf = (int *) alloca (sizeof (int) * size); \ + coding->charbuf = alloca (sizeof (int) * size); \ if (coding->charbuf) \ break; \ size >>= 1; \ @@ -9568,7 +9568,7 @@ make_subsidiaries (Lisp_Object base) { Lisp_Object subsidiaries; ptrdiff_t base_name_len = SBYTES (SYMBOL_NAME (base)); - char *buf = (char *) alloca (base_name_len + 6); + char *buf = alloca (base_name_len + 6); int i; memcpy (buf, SDATA (SYMBOL_NAME (base)), base_name_len); -- cgit v1.2.1 From 2a0213a6d0a9e36a388994445837e051d0bbe5f9 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Tue, 10 Jul 2012 12:43:46 +0400 Subject: Optimize pure C strings initialization. * lisp.h (make_pure_string): Fix prototype. (build_pure_c_string): New function, defined as static inline. This provides a better opportunity to optimize away calls to strlen when the function is called with compile-time constant argument. * alloc.c (make_pure_c_string): Fix comment. Change to add nchars argument, adjust users accordingly. Use build_pure_c_string where appropriate. * buffer.c, coding.c, data.c, dbusbind.c, fileio.c, fontset.c, frame.c, * keyboard.c, keymap.c, lread.c, search.c, syntax.c, w32fns.c, xdisp.c, * xfaces.c, xfns.c, xterm.c: Use build_pure_c_string where appropriate. --- src/coding.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 4b2a9740121..8210cacc4d8 100644 --- a/src/coding.c +++ b/src/coding.c @@ -10350,7 +10350,7 @@ syms_of_coding (void) Vcode_conversion_reused_workbuf = Qnil; staticpro (&Vcode_conversion_workbuf_name); - Vcode_conversion_workbuf_name = make_pure_c_string (" *code-conversion-work*"); + Vcode_conversion_workbuf_name = build_pure_c_string (" *code-conversion-work*"); reused_workbuf_in_use = 0; @@ -10413,7 +10413,7 @@ syms_of_coding (void) Fput (Qcoding_system_error, Qerror_conditions, pure_cons (Qcoding_system_error, pure_cons (Qerror, Qnil))); Fput (Qcoding_system_error, Qerror_message, - make_pure_c_string ("Invalid coding system")); + build_pure_c_string ("Invalid coding system")); /* Intern this now in case it isn't already done. Setting this variable twice is harmless. @@ -10686,22 +10686,22 @@ Also used for decoding keyboard input on X Window system. */); DEFVAR_LISP ("eol-mnemonic-unix", eol_mnemonic_unix, doc: /* *String displayed in mode line for UNIX-like (LF) end-of-line format. */); - eol_mnemonic_unix = make_pure_c_string (":"); + eol_mnemonic_unix = build_pure_c_string (":"); DEFVAR_LISP ("eol-mnemonic-dos", eol_mnemonic_dos, doc: /* *String displayed in mode line for DOS-like (CRLF) end-of-line format. */); - eol_mnemonic_dos = make_pure_c_string ("\\"); + eol_mnemonic_dos = build_pure_c_string ("\\"); DEFVAR_LISP ("eol-mnemonic-mac", eol_mnemonic_mac, doc: /* *String displayed in mode line for MAC-like (CR) end-of-line format. */); - eol_mnemonic_mac = make_pure_c_string ("/"); + eol_mnemonic_mac = build_pure_c_string ("/"); DEFVAR_LISP ("eol-mnemonic-undecided", eol_mnemonic_undecided, doc: /* *String displayed in mode line when end-of-line format is not yet determined. */); - eol_mnemonic_undecided = make_pure_c_string (":"); + eol_mnemonic_undecided = build_pure_c_string (":"); DEFVAR_LISP ("enable-character-translation", Venable_character_translation, doc: /* @@ -10839,7 +10839,7 @@ internal character representation. */); plist[10] = intern_c_string (":for-unibyte"); plist[11] = args[coding_arg_for_unibyte] = Qt; plist[12] = intern_c_string (":docstring"); - plist[13] = make_pure_c_string ("Do no conversion.\n\ + plist[13] = build_pure_c_string ("Do no conversion.\n\ \n\ When you visit a file with this coding, the file is read into a\n\ unibyte buffer as is, thus each byte of a file is treated as a\n\ @@ -10857,7 +10857,7 @@ character."); plist[8] = intern_c_string (":charset-list"); plist[9] = args[coding_arg_charset_list] = Fcons (Qascii, Qnil); plist[11] = args[coding_arg_for_unibyte] = Qnil; - plist[13] = make_pure_c_string ("No conversion on encoding, automatic conversion on decoding."); + plist[13] = build_pure_c_string ("No conversion on encoding, automatic conversion on decoding."); plist[15] = args[coding_arg_eol_type] = Qnil; args[coding_arg_plist] = Flist (16, plist); Fdefine_coding_system_internal (coding_arg_max, args); -- cgit v1.2.1 From 7d7bbefd049fc22cf3bf333592abf57a3bde8766 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Tue, 10 Jul 2012 20:53:26 +0400 Subject: Use XCAR and XCDR instead of Fcar and Fcdr where possible. * admin/coccinelle/list_loop.cocci: Semantic patch to convert from Fcdr to XCDR and consistently use CONSP in the list iteration loops. * admin/coccinelle/vector_contents.cocci: Fix indentation. * src/callint.c, src/coding.c, src/doc.c, src/editfns.c, src/eval.c, * src/font.c, src/fontset.c, src/frame.c, src/gnutls.c, src/minibuf.c, * src/msdos.c, src/textprop.c, src/w32fns.c, src/w32menu.c, src/window.c, * src/xmenu.c: Changed to use XCAR and XCDR where argument type is known to be a Lisp_Cons. --- src/coding.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 8210cacc4d8..134ebf2ab73 100644 --- a/src/coding.c +++ b/src/coding.c @@ -9791,7 +9791,7 @@ usage: (define-coding-system-internal ...) */) val = args[coding_arg_ccl_valids]; valids = Fmake_string (make_number (256), make_number (0)); - for (tail = val; !NILP (tail); tail = Fcdr (tail)) + for (tail = val; CONSP (tail); tail = XCDR (tail)) { int from, to; @@ -9892,7 +9892,7 @@ usage: (define-coding-system-internal ...) */) CHECK_NUMBER_CDR (reg_usage); request = Fcopy_sequence (args[coding_arg_iso2022_request]); - for (tail = request; ! NILP (tail); tail = Fcdr (tail)) + for (tail = request; CONSP (tail); tail = XCDR (tail)) { int id; Lisp_Object tmp1; -- cgit v1.2.1 From 34348bd4e5c89fa0e440e37efa20be2a00c8fd9c Mon Sep 17 00:00:00 2001 From: Andreas Schwab Date: Wed, 11 Jul 2012 09:19:44 +0200 Subject: * coding.c (Fdefine_coding_system_internal): Use XCAR/XCDR instead of Fcar/Fcdr if possible. * font.c (check_otf_features): Likewise. * fontset.c (Fnew_fontset): Likewise. * gnutls.c (Fgnutls_boot): Likewise. * minibuf.c (read_minibuf): Likewise. * msdos.c (IT_set_frame_parameters): Likewise. * xmenu.c (Fx_popup_dialog): Likewise. * w32menu.c (Fx_popup_dialog): Likewise. --- src/coding.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 134ebf2ab73..d9fcc634b77 100644 --- a/src/coding.c +++ b/src/coding.c @@ -9795,7 +9795,7 @@ usage: (define-coding-system-internal ...) */) { int from, to; - val = Fcar (tail); + val = XCAR (tail); if (INTEGERP (val)) { if (! (0 <= XINT (val) && XINT (val) <= 255)) @@ -9897,7 +9897,7 @@ usage: (define-coding-system-internal ...) */) int id; Lisp_Object tmp1; - val = Fcar (tail); + val = XCAR (tail); CHECK_CONS (val); tmp1 = XCAR (val); CHECK_CHARSET_GET_ID (tmp1, id); -- cgit v1.2.1 From d17337e501a189c1d46f758e10c6c2842cafff17 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Thu, 19 Jul 2012 07:55:59 +0400 Subject: New macro to iterate over all buffers, miscellaneous cleanups. * lisp.h (all_buffers): Remove declaration. * buffer.h (all_buffers): Add declaration, with comment. (for_each_buffer): New macro. * alloc.c (Fgarbage_collect, mark_object): Use it. * buffer.c (Fkill_buffer, Fbuffer_swap_text, Fset_buffer_multibyte) (init_buffer): Likewise. * data.c (Fset_default): Likewise. * coding.c (code_conversion_restore): Remove redundant check for dead buffer. * buffer.c (Fkill_buffer): Likewise. Remove obsolete comment. --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index d9fcc634b77..212eb8275fe 100644 --- a/src/coding.c +++ b/src/coding.c @@ -7588,7 +7588,7 @@ code_conversion_restore (Lisp_Object arg) { if (EQ (workbuf, Vcode_conversion_reused_workbuf)) reused_workbuf_in_use = 0; - else if (! NILP (Fbuffer_live_p (workbuf))) + else Fkill_buffer (workbuf); } set_buffer_internal (XBUFFER (current)); -- cgit v1.2.1 From 694b6c97ebb8310bc18dd305c2f277bcc11cebca Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Fri, 27 Jul 2012 10:04:35 +0400 Subject: Utility function to make a list from specified amount of objects. * lisp.h (enum constype): New datatype. (listn): New prototype. * alloc.c (listn): New function. (Fmemory_use_count, syms_of_alloc): Use it. * buffer.c (syms_of_buffer): Likewise. * callint.c (syms_of_callint): Likewise. * charset.c (define_charset_internal): Likewise. * coding.c (syms_of_coding): Likewise. * keymap.c (syms_of_keymap): Likewise. * search.c (syms_of_search): Likewise. * syntax.c (syms_of_syntax): Likewise. * w32.c (init_environment): Likewise. * w32fns.c (Fw32_battery_status, syms_of_w32fns): Likewise. * xdisp.c (syms_of_xdisp): Likewise. * xfns.c (syms_of_xfns): Likewise. --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 212eb8275fe..8b858aa218e 100644 --- a/src/coding.c +++ b/src/coding.c @@ -10411,7 +10411,7 @@ syms_of_coding (void) DEFSYM (Qcoding_system_error, "coding-system-error"); Fput (Qcoding_system_error, Qerror_conditions, - pure_cons (Qcoding_system_error, pure_cons (Qerror, Qnil))); + listn (PURE, 2, Qcoding_system_error, Qerror)); Fput (Qcoding_system_error, Qerror_message, build_pure_c_string ("Invalid coding system")); -- cgit v1.2.1 From 3438fe218c77633ee2c5f106e3a335f906347247 Mon Sep 17 00:00:00 2001 From: Eli Zaretskii Date: Fri, 27 Jul 2012 12:24:34 +0300 Subject: Fix failure to compile on Windows due to 2012-07-27T06:04:35Z!dmantipov@yandex.ru. src/lisp.h (enum constype): Use CONSTYPE_HEAP and CONSTYPE_PURE for enumeration constants, as PURE and HEAP are too general, and clash with other headers and sources, such as gmalloc.c and the MS-Windows system headers. All users changed. --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 8b858aa218e..7b178b0ce14 100644 --- a/src/coding.c +++ b/src/coding.c @@ -10411,7 +10411,7 @@ syms_of_coding (void) DEFSYM (Qcoding_system_error, "coding-system-error"); Fput (Qcoding_system_error, Qerror_conditions, - listn (PURE, 2, Qcoding_system_error, Qerror)); + listn (CONSTYPE_PURE, 2, Qcoding_system_error, Qerror)); Fput (Qcoding_system_error, Qerror_message, build_pure_c_string ("Invalid coding system")); -- cgit v1.2.1 From 6cd7a13902729007a4d1e14a299bad47c9808353 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Mon, 30 Jul 2012 10:43:46 +0400 Subject: Convert safe_call to use variable number of arguments. * xdisp.c (safe_call): Convert to use varargs. Adjust users. (safe_call2): Fix comment. * lisp.h (safe_call): Adjust prototype. * coding.c (encode_coding_object): Change to use safe_call2. * xfaces.c (merge_face_heights): Change to use safe_call1. --- src/coding.c | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 7b178b0ce14..e4ed65079d9 100644 --- a/src/coding.c +++ b/src/coding.c @@ -7931,15 +7931,12 @@ encode_coding_object (struct coding_system *coding, } { - Lisp_Object args[3]; struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5; GCPRO5 (coding->src_object, coding->dst_object, src_object, dst_object, old_deactivate_mark); - args[0] = CODING_ATTR_PRE_WRITE (attrs); - args[1] = make_number (BEG); - args[2] = make_number (Z); - safe_call (3, args); + safe_call2 (CODING_ATTR_PRE_WRITE (attrs), + make_number (BEG), make_number (Z)); UNGCPRO; } if (XBUFFER (coding->src_object) != current_buffer) -- cgit v1.2.1 From 4939150cb43137980c49b318bc70119b9d8ff6f7 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Wed, 1 Aug 2012 13:51:44 -0700 Subject: Use "ASET (a, i, v)" rather than "AREF (a, i) = v". This how ASET and AREF are supposed to work, and makes it easier to think about future improvements. See . * charset.h (set_charset_attr): New function. All lvalue-style uses of CHARSET_DECODER etc. changed to use it. * lisp.h (ASET): Rewrite so as not to use AREF in an lvalue style. (aref_addr): New function. All uses of &AREF(...) changed. (set_hash_key, set_hash_value, set_hash_next, set_hash_hash) (set_hash_index): New functions. All lvalue-style uses of HASH_KEY etc. changed. * keyboard.c (set_prop): New function. All lvalue-style uses of PROP changed. --- src/coding.c | 89 ++++++++++++++++++++++++++++++------------------------------ 1 file changed, 45 insertions(+), 44 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index e4ed65079d9..12a7cf93c46 100644 --- a/src/coding.c +++ b/src/coding.c @@ -2674,8 +2674,8 @@ encode_coding_emacs_mule (struct coding_system *coding) CODING_GET_INFO (coding, attrs, charset_list); if (! EQ (charset_list, Vemacs_mule_charset_list)) { - CODING_ATTR_CHARSET_LIST (attrs) - = charset_list = Vemacs_mule_charset_list; + charset_list = Vemacs_mule_charset_list; + ASET (attrs, coding_attr_charset_list, charset_list); } while (charbuf < charbuf_end) @@ -2967,8 +2967,8 @@ setup_iso_safe_charsets (Lisp_Object attrs) if ((flags & CODING_ISO_FLAG_FULL_SUPPORT) && ! EQ (charset_list, Viso_2022_charset_list)) { - CODING_ATTR_CHARSET_LIST (attrs) - = charset_list = Viso_2022_charset_list; + charset_list = Viso_2022_charset_list; + ASET (attrs, coding_attr_charset_list, charset_list); ASET (attrs, coding_attr_safe_charsets, Qnil); } @@ -9603,16 +9603,16 @@ usage: (define-coding-system-internal ...) */) name = args[coding_arg_name]; CHECK_SYMBOL (name); - CODING_ATTR_BASE_NAME (attrs) = name; + ASET (attrs, coding_attr_base_name, name); val = args[coding_arg_mnemonic]; if (! STRINGP (val)) CHECK_CHARACTER (val); - CODING_ATTR_MNEMONIC (attrs) = val; + ASET (attrs, coding_attr_mnemonic, val); coding_type = args[coding_arg_coding_type]; CHECK_SYMBOL (coding_type); - CODING_ATTR_TYPE (attrs) = coding_type; + ASET (attrs, coding_attr_type, coding_type); charset_list = args[coding_arg_charset_list]; if (SYMBOLP (charset_list)) @@ -9659,49 +9659,49 @@ usage: (define-coding-system-internal ...) */) max_charset_id = charset->id; } } - CODING_ATTR_CHARSET_LIST (attrs) = charset_list; + ASET (attrs, coding_attr_charset_list, charset_list); safe_charsets = make_uninit_string (max_charset_id + 1); memset (SDATA (safe_charsets), 255, max_charset_id + 1); for (tail = charset_list; CONSP (tail); tail = XCDR (tail)) SSET (safe_charsets, XFASTINT (XCAR (tail)), 0); - CODING_ATTR_SAFE_CHARSETS (attrs) = safe_charsets; + ASET (attrs, coding_attr_safe_charsets, safe_charsets); - CODING_ATTR_ASCII_COMPAT (attrs) = args[coding_arg_ascii_compatible_p]; + ASET (attrs, coding_attr_ascii_compat, args[coding_arg_ascii_compatible_p]); val = args[coding_arg_decode_translation_table]; if (! CHAR_TABLE_P (val) && ! CONSP (val)) CHECK_SYMBOL (val); - CODING_ATTR_DECODE_TBL (attrs) = val; + ASET (attrs, coding_attr_decode_tbl, val); val = args[coding_arg_encode_translation_table]; if (! CHAR_TABLE_P (val) && ! CONSP (val)) CHECK_SYMBOL (val); - CODING_ATTR_ENCODE_TBL (attrs) = val; + ASET (attrs, coding_attr_encode_tbl, val); val = args[coding_arg_post_read_conversion]; CHECK_SYMBOL (val); - CODING_ATTR_POST_READ (attrs) = val; + ASET (attrs, coding_attr_post_read, val); val = args[coding_arg_pre_write_conversion]; CHECK_SYMBOL (val); - CODING_ATTR_PRE_WRITE (attrs) = val; + ASET (attrs, coding_attr_pre_write, val); val = args[coding_arg_default_char]; if (NILP (val)) - CODING_ATTR_DEFAULT_CHAR (attrs) = make_number (' '); + ASET (attrs, coding_attr_default_char, make_number (' ')); else { CHECK_CHARACTER (val); - CODING_ATTR_DEFAULT_CHAR (attrs) = val; + ASET (attrs, coding_attr_default_char, val); } val = args[coding_arg_for_unibyte]; - CODING_ATTR_FOR_UNIBYTE (attrs) = NILP (val) ? Qnil : Qt; + ASET (attrs, coding_attr_for_unibyte, NILP (val) ? Qnil : Qt); val = args[coding_arg_plist]; CHECK_LIST (val); - CODING_ATTR_PLIST (attrs) = val; + ASET (attrs, coding_attr_plist, val); if (EQ (coding_type, Qcharset)) { @@ -9726,7 +9726,7 @@ usage: (define-coding-system-internal ...) */) int idx = (dim - 1) * 4; if (CHARSET_ASCII_COMPATIBLE_P (charset)) - CODING_ATTR_ASCII_COMPAT (attrs) = Qt; + ASET (attrs, coding_attr_ascii_compat, Qt); for (i = charset->code_space[idx]; i <= charset->code_space[idx + 1]; i++) @@ -9824,7 +9824,7 @@ usage: (define-coding-system-internal ...) */) { Lisp_Object bom, endian; - CODING_ATTR_ASCII_COMPAT (attrs) = Qnil; + ASET (attrs, coding_attr_ascii_compat, Qnil); if (nargs < coding_arg_utf16_max) goto short_args; @@ -9877,7 +9877,7 @@ usage: (define-coding-system-internal ...) */) CHECK_CHARSET_GET_CHARSET (val, charset); ASET (initial, i, make_number (CHARSET_ID (charset))); if (i == 0 && CHARSET_ASCII_COMPATIBLE_P (charset)) - CODING_ATTR_ASCII_COMPAT (attrs) = Qt; + ASET (attrs, coding_attr_ascii_compat, Qt); } else ASET (initial, i, make_number (-1)); @@ -9938,13 +9938,13 @@ usage: (define-coding-system-internal ...) */) } if (category != coding_category_iso_8_1 && category != coding_category_iso_8_2) - CODING_ATTR_ASCII_COMPAT (attrs) = Qnil; + ASET (attrs, coding_attr_ascii_compat, Qnil); } else if (EQ (coding_type, Qemacs_mule)) { if (EQ (args[coding_arg_charset_list], Qemacs_mule)) ASET (attrs, coding_attr_emacs_mule_full, Qt); - CODING_ATTR_ASCII_COMPAT (attrs) = Qt; + ASET (attrs, coding_attr_ascii_compat, Qt); category = coding_category_emacs_mule; } else if (EQ (coding_type, Qshift_jis)) @@ -9961,7 +9961,7 @@ usage: (define-coding-system-internal ...) */) error ("Dimension of charset %s is not one", SDATA (SYMBOL_NAME (CHARSET_NAME (charset)))); if (CHARSET_ASCII_COMPATIBLE_P (charset)) - CODING_ATTR_ASCII_COMPAT (attrs) = Qt; + ASET (attrs, coding_attr_ascii_compat, Qt); charset_list = XCDR (charset_list); charset = CHARSET_FROM_ID (XINT (XCAR (charset_list))); @@ -9999,7 +9999,7 @@ usage: (define-coding-system-internal ...) */) error ("Dimension of charset %s is not one", SDATA (SYMBOL_NAME (CHARSET_NAME (charset)))); if (CHARSET_ASCII_COMPATIBLE_P (charset)) - CODING_ATTR_ASCII_COMPAT (attrs) = Qt; + ASET (attrs, coding_attr_ascii_compat, Qt); charset_list = XCDR (charset_list); charset = CHARSET_FROM_ID (XINT (XCAR (charset_list))); @@ -10013,7 +10013,7 @@ usage: (define-coding-system-internal ...) */) else if (EQ (coding_type, Qraw_text)) { category = coding_category_raw_text; - CODING_ATTR_ASCII_COMPAT (attrs) = Qt; + ASET (attrs, coding_attr_ascii_compat, Qt); } else if (EQ (coding_type, Qutf_8)) { @@ -10033,7 +10033,7 @@ usage: (define-coding-system-internal ...) */) } ASET (attrs, coding_attr_utf_bom, bom); if (NILP (bom)) - CODING_ATTR_ASCII_COMPAT (attrs) = Qt; + ASET (attrs, coding_attr_ascii_compat, Qt); category = (CONSP (bom) ? coding_category_utf_8_auto : NILP (bom) ? coding_category_utf_8_nosig @@ -10045,14 +10045,15 @@ usage: (define-coding-system-internal ...) */) error ("Invalid coding system type: %s", SDATA (SYMBOL_NAME (coding_type))); - CODING_ATTR_CATEGORY (attrs) = make_number (category); - CODING_ATTR_PLIST (attrs) - = Fcons (QCcategory, Fcons (AREF (Vcoding_category_table, category), - CODING_ATTR_PLIST (attrs))); - CODING_ATTR_PLIST (attrs) - = Fcons (QCascii_compatible_p, - Fcons (CODING_ATTR_ASCII_COMPAT (attrs), - CODING_ATTR_PLIST (attrs))); + ASET (attrs, coding_attr_category, make_number (category)); + ASET (attrs, coding_attr_plist, + Fcons (QCcategory, + Fcons (AREF (Vcoding_category_table, category), + CODING_ATTR_PLIST (attrs)))); + ASET (attrs, coding_attr_plist, + Fcons (QCascii_compatible_p, + Fcons (CODING_ATTR_ASCII_COMPAT (attrs), + CODING_ATTR_PLIST (attrs)))); eol_type = args[coding_arg_eol_type]; if (! NILP (eol_type) @@ -10126,7 +10127,7 @@ DEFUN ("coding-system-put", Fcoding_system_put, Scoding_system_put, { if (! STRINGP (val)) CHECK_CHARACTER (val); - CODING_ATTR_MNEMONIC (attrs) = val; + ASET (attrs, coding_attr_mnemonic, val); } else if (EQ (prop, QCdefault_char)) { @@ -10134,37 +10135,37 @@ DEFUN ("coding-system-put", Fcoding_system_put, Scoding_system_put, val = make_number (' '); else CHECK_CHARACTER (val); - CODING_ATTR_DEFAULT_CHAR (attrs) = val; + ASET (attrs, coding_attr_default_char, val); } else if (EQ (prop, QCdecode_translation_table)) { if (! CHAR_TABLE_P (val) && ! CONSP (val)) CHECK_SYMBOL (val); - CODING_ATTR_DECODE_TBL (attrs) = val; + ASET (attrs, coding_attr_decode_tbl, val); } else if (EQ (prop, QCencode_translation_table)) { if (! CHAR_TABLE_P (val) && ! CONSP (val)) CHECK_SYMBOL (val); - CODING_ATTR_ENCODE_TBL (attrs) = val; + ASET (attrs, coding_attr_encode_tbl, val); } else if (EQ (prop, QCpost_read_conversion)) { CHECK_SYMBOL (val); - CODING_ATTR_POST_READ (attrs) = val; + ASET (attrs, coding_attr_post_read, val); } else if (EQ (prop, QCpre_write_conversion)) { CHECK_SYMBOL (val); - CODING_ATTR_PRE_WRITE (attrs) = val; + ASET (attrs, coding_attr_pre_write, val); } else if (EQ (prop, QCascii_compatible_p)) { - CODING_ATTR_ASCII_COMPAT (attrs) = val; + ASET (attrs, coding_attr_ascii_compat, val); } - CODING_ATTR_PLIST (attrs) - = Fplist_put (CODING_ATTR_PLIST (attrs), prop, val); + ASET (attrs, coding_attr_plist, + Fplist_put (CODING_ATTR_PLIST (attrs), prop, val)); return val; } -- cgit v1.2.1 From a2752828083a77421efdcd59938eeb21657c39a3 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Thu, 9 Aug 2012 09:14:23 +0400 Subject: Use TSET for write access to Lisp_Object slots of struct terminal. * termhooks.h (TSET): New macro. * coding.c, terminal.c, xselect.c: Adjust users. --- src/coding.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 12a7cf93c46..5bed11b8241 100644 --- a/src/coding.c +++ b/src/coding.c @@ -9294,9 +9294,9 @@ DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_intern terminal_coding->src_multibyte = 1; terminal_coding->dst_multibyte = 0; if (terminal_coding->common_flags & CODING_REQUIRE_ENCODING_MASK) - term->charset_list = coding_charset_list (terminal_coding); + TSET (term, charset_list, coding_charset_list (terminal_coding)); else - term->charset_list = Fcons (make_number (charset_ascii), Qnil); + TSET (term, charset_list, Fcons (make_number (charset_ascii), Qnil)); return Qnil; } -- cgit v1.2.1 From 4c31be6153255dfe29a0231253263ea0d9011ac3 Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Mon, 13 Aug 2012 07:39:07 +0400 Subject: Use BSET for write access to Lisp_Object members of struct buffer. * buffer.h (BSET): New macro. * buffer.c, casetab.c, cmds.c, coding.c, data.c, editfns.c: * fileio.c, frame.c, indent.c, insdel.c, intervals.c, keymap.c: * minibuf.c, print.c, process.c, syntax.c, undo.c, w32fns.c: * window.c, xdisp.c, xfns.c: Adjust users. --- src/coding.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 5bed11b8241..08633d8bcff 100644 --- a/src/coding.c +++ b/src/coding.c @@ -7103,7 +7103,7 @@ decode_coding (struct coding_system *coding) if (GPT != PT) move_gap_both (PT, PT_BYTE); undo_list = BVAR (current_buffer, undo_list); - BVAR (current_buffer, undo_list) = Qt; + BSET (current_buffer, undo_list, Qt); } coding->consumed = coding->consumed_char = 0; @@ -7200,7 +7200,7 @@ decode_coding (struct coding_system *coding) decode_eol (coding); if (BUFFERP (coding->dst_object)) { - BVAR (current_buffer, undo_list) = undo_list; + BSET (current_buffer, undo_list, undo_list); record_insert (coding->dst_pos, coding->produced_char); } return coding->result; @@ -7568,8 +7568,8 @@ make_conversion_work_buffer (int multibyte) doesn't compile new regexps. */ Fset (Fmake_local_variable (Qinhibit_modification_hooks), Qt); Ferase_buffer (); - BVAR (current_buffer, undo_list) = Qt; - BVAR (current_buffer, enable_multibyte_characters) = multibyte ? Qt : Qnil; + BSET (current_buffer, undo_list, Qt); + BSET (current_buffer, enable_multibyte_characters, multibyte ? Qt : Qnil); set_buffer_internal (current); return workbuf; } -- cgit v1.2.1 From f48b82fd19703c5001c9cceb14b4d8372ce2b083 Mon Sep 17 00:00:00 2001 From: Gergely Risko Date: Tue, 14 Aug 2012 13:09:35 +0800 Subject: Fix for undo recording in decode_coding. * coding.c (decode_coding): Record buffer modification before disabling undo_list. Fixes: debbugs:11773 --- src/coding.c | 9 +++++++++ 1 file changed, 9 insertions(+) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 08633d8bcff..c601a18b26e 100644 --- a/src/coding.c +++ b/src/coding.c @@ -7102,6 +7102,15 @@ decode_coding (struct coding_system *coding) set_buffer_internal (XBUFFER (coding->dst_object)); if (GPT != PT) move_gap_both (PT, PT_BYTE); + + /* We must disable undo_list in order to record the whole insert + transaction via record_insert at the end. But doing so also + disables the recording of the first change to the undo_list. + Therefore we check for first change here and record it via + record_first_change if needed. */ + if (MODIFF <= SAVE_MODIFF) + record_first_change (); + undo_list = BVAR (current_buffer, undo_list); BSET (current_buffer, undo_list, Qt); } -- cgit v1.2.1 From 3f22b86fc7d9b66ff3e332b9a56350e93ddbd0aa Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Fri, 17 Aug 2012 17:07:52 -0700 Subject: * termhooks.h (TSET): Remove. Replace all uses with calls to new setter functions. Use INLINE_HEADER_BEGIN, INLINE_HEADER_END. (TERMHOOKS_INLINE): New macro. (tset_charset_list, tset_selection_alist): New setter functions. * terminal.c (TERMHOOKS_INLINE): Define to EXTERN_INLINE, so that the corresponding functions are compiled into code. (tset_param_alist): New setter function. Fixes: debbugs:12215 --- src/coding.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index c601a18b26e..290b9a5dbb6 100644 --- a/src/coding.c +++ b/src/coding.c @@ -9302,10 +9302,10 @@ DEFUN ("set-terminal-coding-system-internal", Fset_terminal_coding_system_intern terminal_coding->common_flags &= ~CODING_ANNOTATE_COMPOSITION_MASK; terminal_coding->src_multibyte = 1; terminal_coding->dst_multibyte = 0; - if (terminal_coding->common_flags & CODING_REQUIRE_ENCODING_MASK) - TSET (term, charset_list, coding_charset_list (terminal_coding)); - else - TSET (term, charset_list, Fcons (make_number (charset_ascii), Qnil)); + tset_charset_list + (term, (terminal_coding->common_flags & CODING_REQUIRE_ENCODING_MASK + ? coding_charset_list (terminal_coding) + : Fcons (make_number (charset_ascii), Qnil))); return Qnil; } -- cgit v1.2.1 From 39eb03f1b023ae3d94e311f6f5d9f913f75c42c4 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Fri, 17 Aug 2012 23:06:39 -0700 Subject: * buffer.h (BSET): Remove. Replace all uses with calls to new setter functions. (bset_bidi_paragraph_direction, bset_case_canon_table) (bset_case_eqv_table, bset_directory, bset_display_count) (bset_display_time, bset_downcase_table) (bset_enable_multibyte_characters, bset_filename, bset_keymap) (bset_last_selected_window, bset_local_var_alist) (bset_mark_active, bset_point_before_scroll, bset_read_only) (bset_truncate_lines, bset_undo_list, bset_upcase_table) (bset_width_table): * buffer.c (bset_abbrev_mode, bset_abbrev_table) (bset_auto_fill_function, bset_auto_save_file_format) (bset_auto_save_file_name, bset_backed_up, bset_begv_marker) (bset_bidi_display_reordering, bset_buffer_file_coding_system) (bset_cache_long_line_scans, bset_case_fold_search) (bset_ctl_arrow, bset_cursor_in_non_selected_windows) (bset_cursor_type, bset_display_table, bset_extra_line_spacing) (bset_file_format, bset_file_truename, bset_fringe_cursor_alist) (bset_fringe_indicator_alist, bset_fringes_outside_margins) (bset_header_line_format, bset_indicate_buffer_boundaries) (bset_indicate_empty_lines, bset_invisibility_spec) (bset_left_fringe_width, bset_major_mode, bset_mark) (bset_minor_modes, bset_mode_line_format, bset_mode_name) (bset_name, bset_overwrite_mode, bset_pt_marker) (bset_right_fringe_width, bset_save_length) (bset_scroll_bar_width, bset_scroll_down_aggressively) (bset_scroll_up_aggressively, bset_selective_display) (bset_selective_display_ellipses, bset_vertical_scroll_bar_type) (bset_word_wrap, bset_zv_marker): * category.c (bset_category_table): * syntax.c (bset_syntax_table): New setter functions. Fixes: debbugs:12215 --- src/coding.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 290b9a5dbb6..971686dc180 100644 --- a/src/coding.c +++ b/src/coding.c @@ -7112,7 +7112,7 @@ decode_coding (struct coding_system *coding) record_first_change (); undo_list = BVAR (current_buffer, undo_list); - BSET (current_buffer, undo_list, Qt); + bset_undo_list (current_buffer, Qt); } coding->consumed = coding->consumed_char = 0; @@ -7209,7 +7209,7 @@ decode_coding (struct coding_system *coding) decode_eol (coding); if (BUFFERP (coding->dst_object)) { - BSET (current_buffer, undo_list, undo_list); + bset_undo_list (current_buffer, undo_list); record_insert (coding->dst_pos, coding->produced_char); } return coding->result; @@ -7577,8 +7577,8 @@ make_conversion_work_buffer (int multibyte) doesn't compile new regexps. */ Fset (Fmake_local_variable (Qinhibit_modification_hooks), Qt); Ferase_buffer (); - BSET (current_buffer, undo_list, Qt); - BSET (current_buffer, enable_multibyte_characters, multibyte ? Qt : Qnil); + bset_undo_list (current_buffer, Qt); + bset_enable_multibyte_characters (current_buffer, multibyte ? Qt : Qnil); set_buffer_internal (current); return workbuf; } -- cgit v1.2.1 From f10fe38f772c29031a23ef7aa92d2de1b3675461 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Mon, 27 Aug 2012 09:19:34 -0700 Subject: * cmds.c, coding.c: Use bool for booleans. * cmds.c (move_point, Fself_insert_command): * coding.h (struct composition status, struct coding_system): * coding.c (detect_coding_utf_8, encode_coding_utf_8) (detect_coding_utf_16, encode_coding_utf_16, detect_coding_emacs_mule) (emacs_mule_char, decode_coding_emacs_mule) (encode_coding_emacs_mule, detect_coding_iso_2022) (decode_coding_iso_2022, encode_invocation_designation) (encode_designation_at_bol, encode_coding_iso_2022) (detect_coding_sjis, detect_coding_big5, decode_coding_sjis) (decode_coding_big5, encode_coding_sjis, encode_coding_big5) (detect_coding_ccl, encode_coding_ccl, decode_coding_raw_text) (encode_coding_raw_text, detect_coding_charset) (decode_coding_charset, encode_coding_charset, detect_eol) (detect_coding, get_translation_table, produce_chars) (consume_chars, reused_workbuf_in_use) (make_conversion_work_buffer, code_conversion_save) (decode_coding_object, encode_coding_object) (detect_coding_system, char_encodable_p) (Funencodable_char_position, code_convert_region) (code_convert_string, code_convert_string_norecord) (Fset_coding_system_priority): * fileio.c (Finsert_file_contents): Use bool for booleans. * coding.h, lisp.h: Reflect above API changes. * coding.c: Remove unnecessary static function decls. (detect_coding): Use unsigned, not signed, to copy an unsigned field. (decode_coding, encode_coding, decode_coding_gap): Return 'void', not a boolean 'int', since callers never look at the return value. (ALLOC_CONVERSION_WORK_AREA): Assume caller returns 'void', not 'int'. * coding.h (decoding_buffer_size, encoding_buffer_size) (emacs_mule_string_char): Remove unused extern decls. (struct iso_2022_spec, struct coding_system): Use 'unsigned int : 1' for boolean fields, since there's more than one. (struct emacs_mule_spec): Remove unused field 'full_support'. All initializations removed. * cmds.c (internal_self_insert): Don't assume EMACS_INT fits in 'int'. --- src/coding.c | 368 ++++++++++++++++++++++------------------------------------- 1 file changed, 137 insertions(+), 231 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 971686dc180..5bfd42c7272 100644 --- a/src/coding.c +++ b/src/coding.c @@ -147,18 +147,18 @@ STRUCT CODING_SYSTEM CODING conforms to the format of XXX, and update the members of DETECT_INFO. - Return 1 if the byte sequence conforms to XXX, otherwise return 0. + Return true if the byte sequence conforms to XXX. Below is the template of these functions. */ #if 0 -static int +static bool detect_coding_XXX (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; ptrdiff_t consumed_chars = 0; int found = 0; ...; @@ -212,7 +212,7 @@ decode_coding_XXXX (struct coding_system *coding) /* A buffer to produce decoded characters. */ int *charbuf = coding->charbuf + coding->charbuf_used; int *charbuf_end = coding->charbuf + coding->charbuf_size; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; while (1) { @@ -260,7 +260,7 @@ decode_coding_XXXX (struct coding_system *coding) static void encode_coding_XXX (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf->charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; @@ -651,8 +651,8 @@ static struct coding_system coding_categories[coding_category_max]; /* Safely get one byte from the source text pointed by SRC which ends at SRC_END, and set C to that byte. If there are not enough bytes - in the source, it jumps to `no_more_source'. If multibytep is - nonzero, and a multibyte character is found at SRC, set C to the + in the source, it jumps to 'no_more_source'. If MULTIBYTEP, + and a multibyte character is found at SRC, set C to the negative value of the character code. The caller should declare and set these variables appropriately in advance: src, src_end, multibytep */ @@ -685,7 +685,7 @@ static struct coding_system coding_categories[coding_category_max]; /* Safely get two bytes from the source text pointed by SRC which ends at SRC_END, and set C1 and C2 to those bytes while skipping the heading multibyte characters. If there are not enough bytes in the - source, it jumps to `no_more_source'. If multibytep is nonzero and + source, it jumps to 'no_more_source'. If MULTIBYTEP and a multibyte character is found for C2, set C2 to the negative value of the character code. The caller should declare and set these variables appropriately in advance: @@ -746,8 +746,8 @@ static struct coding_system coding_categories[coding_category_max]; /* Store a byte C in the place pointed by DST and increment DST to the - next free point, and increment PRODUCED_CHARS. If MULTIBYTEP is - nonzero, store in an appropriate multibyte from. The caller should + next free point, and increment PRODUCED_CHARS. If MULTIBYTEP, + store in an appropriate multibyte form. The caller should declare and set the variables `dst' and `multibytep' appropriately in advance. */ @@ -806,83 +806,6 @@ static struct coding_system coding_categories[coding_category_max]; } while (0) -/* Prototypes for static functions. */ -static void record_conversion_result (struct coding_system *coding, - enum coding_result_code result); -static int detect_coding_utf_8 (struct coding_system *, - struct coding_detection_info *info); -static void decode_coding_utf_8 (struct coding_system *); -static int encode_coding_utf_8 (struct coding_system *); - -static int detect_coding_utf_16 (struct coding_system *, - struct coding_detection_info *info); -static void decode_coding_utf_16 (struct coding_system *); -static int encode_coding_utf_16 (struct coding_system *); - -static int detect_coding_iso_2022 (struct coding_system *, - struct coding_detection_info *info); -static void decode_coding_iso_2022 (struct coding_system *); -static int encode_coding_iso_2022 (struct coding_system *); - -static int detect_coding_emacs_mule (struct coding_system *, - struct coding_detection_info *info); -static void decode_coding_emacs_mule (struct coding_system *); -static int encode_coding_emacs_mule (struct coding_system *); - -static int detect_coding_sjis (struct coding_system *, - struct coding_detection_info *info); -static void decode_coding_sjis (struct coding_system *); -static int encode_coding_sjis (struct coding_system *); - -static int detect_coding_big5 (struct coding_system *, - struct coding_detection_info *info); -static void decode_coding_big5 (struct coding_system *); -static int encode_coding_big5 (struct coding_system *); - -static int detect_coding_ccl (struct coding_system *, - struct coding_detection_info *info); -static void decode_coding_ccl (struct coding_system *); -static int encode_coding_ccl (struct coding_system *); - -static void decode_coding_raw_text (struct coding_system *); -static int encode_coding_raw_text (struct coding_system *); - -static void coding_set_source (struct coding_system *); -static ptrdiff_t coding_change_source (struct coding_system *); -static void coding_set_destination (struct coding_system *); -static ptrdiff_t coding_change_destination (struct coding_system *); -static void coding_alloc_by_realloc (struct coding_system *, ptrdiff_t); -static void coding_alloc_by_making_gap (struct coding_system *, - ptrdiff_t, ptrdiff_t); -static unsigned char *alloc_destination (struct coding_system *, - ptrdiff_t, unsigned char *); -static void setup_iso_safe_charsets (Lisp_Object); -static ptrdiff_t encode_designation_at_bol (struct coding_system *, - int *, int *, unsigned char *); -static int detect_eol (const unsigned char *, - ptrdiff_t, enum coding_category); -static Lisp_Object adjust_coding_eol_type (struct coding_system *, int); -static void decode_eol (struct coding_system *); -static Lisp_Object get_translation_table (Lisp_Object, int, int *); -static Lisp_Object get_translation (Lisp_Object, int *, int *); -static int produce_chars (struct coding_system *, Lisp_Object, int); -static inline void produce_charset (struct coding_system *, int *, - ptrdiff_t); -static void produce_annotation (struct coding_system *, ptrdiff_t); -static int decode_coding (struct coding_system *); -static inline int *handle_composition_annotation (ptrdiff_t, ptrdiff_t, - struct coding_system *, - int *, ptrdiff_t *); -static inline int *handle_charset_annotation (ptrdiff_t, ptrdiff_t, - struct coding_system *, - int *, ptrdiff_t *); -static void consume_chars (struct coding_system *, Lisp_Object, int); -static int encode_coding (struct coding_system *); -static Lisp_Object make_conversion_work_buffer (int); -static Lisp_Object code_conversion_restore (Lisp_Object); -static inline int char_encodable_p (int, Lisp_Object); -static Lisp_Object make_subsidiaries (Lisp_Object); - static void record_conversion_result (struct coding_system *coding, enum coding_result_code result) @@ -1264,8 +1187,7 @@ alloc_destination (struct coding_system *coding, ptrdiff_t nbytes, /*** 3. UTF-8 ***/ /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions". - Check if a text is encoded in UTF-8. If it is, return 1, else - return 0. */ + Return true if a text is encoded in UTF-8. */ #define UTF_8_1_OCTET_P(c) ((c) < 0x80) #define UTF_8_EXTRA_OCTET_P(c) (((c) & 0xC0) == 0x80) @@ -1278,16 +1200,16 @@ alloc_destination (struct coding_system *coding, ptrdiff_t nbytes, #define UTF_8_BOM_2 0xBB #define UTF_8_BOM_3 0xBF -static int +static bool detect_coding_utf_8 (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; ptrdiff_t consumed_chars = 0; - int bom_found = 0; - int found = 0; + bool bom_found = 0; + bool found = 0; detect_info->checked |= CATEGORY_MASK_UTF_8; /* A coding system of this category is always ASCII compatible. */ @@ -1371,10 +1293,10 @@ decode_coding_utf_8 (struct coding_system *coding) int *charbuf = coding->charbuf + coding->charbuf_used; int *charbuf_end = coding->charbuf + coding->charbuf_size; ptrdiff_t consumed_chars = 0, consumed_chars_base = 0; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; enum utf_bom_type bom = CODING_UTF_8_BOM (coding); - int eol_dos = - !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); + bool eol_dos + = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); int byte_after_cr = -1; if (bom != utf_without_bom) @@ -1513,10 +1435,10 @@ decode_coding_utf_8 (struct coding_system *coding) } -static int +static bool encode_coding_utf_8 (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; @@ -1577,8 +1499,7 @@ encode_coding_utf_8 (struct coding_system *coding) /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions". - Check if a text is encoded in one of UTF-16 based coding systems. - If it is, return 1, else return 0. */ + Return true if a text is encoded in one of UTF-16 based coding systems. */ #define UTF_16_HIGH_SURROGATE_P(val) \ (((val) & 0xFC00) == 0xD800) @@ -1587,13 +1508,13 @@ encode_coding_utf_8 (struct coding_system *coding) (((val) & 0xFC00) == 0xDC00) -static int +static bool detect_coding_utf_16 (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; int c1, c2; detect_info->checked |= CATEGORY_MASK_UTF_16; @@ -1680,12 +1601,12 @@ decode_coding_utf_16 (struct coding_system *coding) /* We may produces at most 3 chars in one loop. */ int *charbuf_end = coding->charbuf + coding->charbuf_size - 2; ptrdiff_t consumed_chars = 0, consumed_chars_base = 0; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; enum utf_bom_type bom = CODING_UTF_16_BOM (coding); enum utf_16_endian_type endian = CODING_UTF_16_ENDIAN (coding); int surrogate = CODING_UTF_16_SURROGATE (coding); - int eol_dos = - !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); + bool eol_dos + = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); int byte_after_cr1 = -1, byte_after_cr2 = -1; if (bom == utf_with_bom) @@ -1795,17 +1716,17 @@ decode_coding_utf_16 (struct coding_system *coding) coding->charbuf_used = charbuf - coding->charbuf; } -static int +static bool encode_coding_utf_16 (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; int safe_room = 8; enum utf_bom_type bom = CODING_UTF_16_BOM (coding); - int big_endian = CODING_UTF_16_ENDIAN (coding) == utf_16_big_endian; + bool big_endian = CODING_UTF_16_ENDIAN (coding) == utf_16_big_endian; ptrdiff_t produced_chars = 0; int c; @@ -1930,16 +1851,15 @@ char emacs_mule_bytes[256]; /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions". - Check if a text is encoded in `emacs-mule'. If it is, return 1, - else return 0. */ + Return true if a text is encoded in 'emacs-mule'. */ -static int +static bool detect_coding_emacs_mule (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; ptrdiff_t consumed_chars = 0; int c; int found = 0; @@ -2029,12 +1949,12 @@ emacs_mule_char (struct coding_system *coding, const unsigned char *src, { const unsigned char *src_end = coding->source + coding->src_bytes; const unsigned char *src_base = src; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; int charset_ID; unsigned code; int c; int consumed_chars = 0; - int mseq_found = 0; + bool mseq_found = 0; ONE_MORE_BYTE (c); if (c < 0) @@ -2411,12 +2331,12 @@ decode_coding_emacs_mule (struct coding_system *coding) /* We can produce up to 2 characters in a loop. */ - 1; ptrdiff_t consumed_chars = 0, consumed_chars_base; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; ptrdiff_t char_offset = coding->produced_char; ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; - int eol_dos = - !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); + bool eol_dos + = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); int byte_after_cr = -1; struct composition_status *cmp_status = &coding->spec.emacs_mule.cmp_status; @@ -2657,10 +2577,10 @@ decode_coding_emacs_mule (struct coding_system *coding) } while (0); -static int +static bool encode_coding_emacs_mule (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; @@ -2722,7 +2642,7 @@ encode_coding_emacs_mule (struct coding_system *coding) if (preferred_charset_id >= 0) { - int result; + bool result; charset = CHARSET_FROM_ID (preferred_charset_id); CODING_CHAR_CHARSET_P (coding, dst, dst_end, c, charset, result); @@ -3017,17 +2937,17 @@ setup_iso_safe_charsets (Lisp_Object attrs) /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions". - Check if a text is encoded in one of ISO-2022 based coding systems. - If it is, return 1, else return 0. */ + Return true if a text is encoded in one of ISO-2022 based coding + systems. */ -static int +static bool detect_coding_iso_2022 (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source, *src_base = src; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; - int single_shifting = 0; + bool multibytep = coding->src_multibyte; + bool single_shifting = 0; int id; int c, c1; ptrdiff_t consumed_chars = 0; @@ -3390,8 +3310,6 @@ detect_coding_iso_2022 (struct coding_system *coding, /* Finish the current composition as invalid. */ -static int finish_composition (int *, struct composition_status *); - static int finish_composition (int *charbuf, struct composition_status *cmp_status) { @@ -3541,7 +3459,7 @@ decode_coding_iso_2022 (struct coding_system *coding) int *charbuf_end = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 3); ptrdiff_t consumed_chars = 0, consumed_chars_base; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; /* Charsets invoked to graphic plane 0 and 1 respectively. */ int charset_id_0 = CODING_ISO_INVOKED_CHARSET (coding, 0); int charset_id_1 = CODING_ISO_INVOKED_CHARSET (coding, 1); @@ -3553,8 +3471,8 @@ decode_coding_iso_2022 (struct coding_system *coding) ptrdiff_t char_offset = coding->produced_char; ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; - int eol_dos = - !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); + bool eol_dos + = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); int byte_after_cr = -1; int i; @@ -4282,7 +4200,7 @@ encode_invocation_designation (struct charset *charset, struct coding_system *coding, unsigned char *dst, ptrdiff_t *p_nchars) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; ptrdiff_t produced_chars = *p_nchars; int reg; /* graphic register number */ int id = CHARSET_ID (charset); @@ -4380,7 +4298,7 @@ encode_designation_at_bol (struct coding_system *coding, int r[4]; int c, found = 0, reg; ptrdiff_t produced_chars = 0; - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; Lisp_Object attrs; Lisp_Object charset_list; @@ -4422,21 +4340,21 @@ encode_designation_at_bol (struct coding_system *coding, /* See the above "GENERAL NOTES on `encode_coding_XXX ()' functions". */ -static int +static bool encode_coding_iso_2022 (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; int safe_room = 16; - int bol_designation + bool bol_designation = (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATE_AT_BOL && CODING_ISO_BOL (coding)); ptrdiff_t produced_chars = 0; Lisp_Object attrs, eol_type, charset_list; - int ascii_compatible; + bool ascii_compatible; int c; int preferred_charset_id = -1; @@ -4523,8 +4441,9 @@ encode_coding_iso_2022 (struct coding_system *coding) CODING_ISO_DESIGNATION (coding, i) = CODING_ISO_INITIAL (coding, i); } - bol_designation - = CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_DESIGNATE_AT_BOL; + bol_designation = ((CODING_ISO_FLAGS (coding) + & CODING_ISO_FLAG_DESIGNATE_AT_BOL) + != 0); } else if (CODING_ISO_FLAGS (coding) & CODING_ISO_FLAG_RESET_AT_CNTL) ENCODE_RESET_PLANE_AND_REGISTER (); @@ -4551,7 +4470,7 @@ encode_coding_iso_2022 (struct coding_system *coding) if (preferred_charset_id >= 0) { - int result; + bool result; charset = CHARSET_FROM_ID (preferred_charset_id); CODING_CHAR_CHARSET_P (coding, dst, dst_end, c, charset, result); @@ -4631,16 +4550,15 @@ encode_coding_iso_2022 (struct coding_system *coding) */ /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions". - Check if a text is encoded in SJIS. If it is, return - CATEGORY_MASK_SJIS, else return 0. */ + Return true if a text is encoded in SJIS. */ -static int +static bool detect_coding_sjis (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; ptrdiff_t consumed_chars = 0; int found = 0; int c; @@ -4688,16 +4606,15 @@ detect_coding_sjis (struct coding_system *coding, } /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions". - Check if a text is encoded in BIG5. If it is, return - CATEGORY_MASK_BIG5, else return 0. */ + Return true if a text is encoded in BIG5. */ -static int +static bool detect_coding_big5 (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; ptrdiff_t consumed_chars = 0; int found = 0; int c; @@ -4735,8 +4652,7 @@ detect_coding_big5 (struct coding_system *coding, return 1; } -/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". - If SJIS_P is 1, decode SJIS text, else decode BIG5 test. */ +/* See the above "GENERAL NOTES on `decode_coding_XXX ()' functions". */ static void decode_coding_sjis (struct coding_system *coding) @@ -4750,15 +4666,15 @@ decode_coding_sjis (struct coding_system *coding) int *charbuf_end = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2); ptrdiff_t consumed_chars = 0, consumed_chars_base; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; struct charset *charset_roman, *charset_kanji, *charset_kana; struct charset *charset_kanji2; Lisp_Object attrs, charset_list, val; ptrdiff_t char_offset = coding->produced_char; ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; - int eol_dos = - !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); + bool eol_dos + = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); int byte_after_cr = -1; CODING_GET_INFO (coding, attrs, charset_list); @@ -4868,14 +4784,14 @@ decode_coding_big5 (struct coding_system *coding) int *charbuf_end = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2); ptrdiff_t consumed_chars = 0, consumed_chars_base; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; struct charset *charset_roman, *charset_big5; Lisp_Object attrs, charset_list, val; ptrdiff_t char_offset = coding->produced_char; ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; - int eol_dos = - !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); + bool eol_dos + = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); int byte_after_cr = -1; CODING_GET_INFO (coding, attrs, charset_list); @@ -4957,13 +4873,12 @@ decode_coding_big5 (struct coding_system *coding) `japanese-jisx0208', `chinese-big5-1', and `chinese-big5-2'. We are sure that all these charsets are registered as official charset (i.e. do not have extended leading-codes). Characters of other - charsets are produced without any encoding. If SJIS_P is 1, encode - SJIS text, else encode BIG5 text. */ + charsets are produced without any encoding. */ -static int +static bool encode_coding_sjis (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; @@ -4971,7 +4886,7 @@ encode_coding_sjis (struct coding_system *coding) int safe_room = 4; ptrdiff_t produced_chars = 0; Lisp_Object attrs, charset_list, val; - int ascii_compatible; + bool ascii_compatible; struct charset *charset_kanji, *charset_kana; struct charset *charset_kanji2; int c; @@ -5054,10 +4969,10 @@ encode_coding_sjis (struct coding_system *coding) return 0; } -static int +static bool encode_coding_big5 (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; @@ -5065,7 +4980,7 @@ encode_coding_big5 (struct coding_system *coding) int safe_room = 4; ptrdiff_t produced_chars = 0; Lisp_Object attrs, charset_list, val; - int ascii_compatible; + bool ascii_compatible; struct charset *charset_big5; int c; @@ -5130,17 +5045,16 @@ encode_coding_big5 (struct coding_system *coding) /*** 10. CCL handlers ***/ /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions". - Check if a text is encoded in a coding system of which - encoder/decoder are written in CCL program. If it is, return - CATEGORY_MASK_CCL, else return 0. */ + Return true if a text is encoded in a coding system of which + encoder/decoder are written in CCL program. */ -static int +static bool detect_coding_ccl (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; ptrdiff_t consumed_chars = 0; int found = 0; unsigned char *valids; @@ -5182,7 +5096,7 @@ decode_coding_ccl (struct coding_system *coding) int *charbuf = coding->charbuf + coding->charbuf_used; int *charbuf_end = coding->charbuf + coding->charbuf_size; ptrdiff_t consumed_chars = 0; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; struct ccl_program *ccl = &coding->spec.ccl->ccl; int source_charbuf[1024]; int source_byteidx[1025]; @@ -5243,11 +5157,11 @@ decode_coding_ccl (struct coding_system *coding) coding->charbuf_used = charbuf - coding->charbuf; } -static int +static bool encode_coding_ccl (struct coding_system *coding) { struct ccl_program *ccl = &coding->spec.ccl->ccl; - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; @@ -5308,7 +5222,6 @@ encode_coding_ccl (struct coding_system *coding) return 0; } - /*** 10, 11. no-conversion handlers ***/ @@ -5317,8 +5230,8 @@ encode_coding_ccl (struct coding_system *coding) static void decode_coding_raw_text (struct coding_system *coding) { - int eol_dos = - !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); + bool eol_dos + = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); coding->chars_at_source = 1; coding->consumed_char = coding->src_chars; @@ -5333,10 +5246,10 @@ decode_coding_raw_text (struct coding_system *coding) record_conversion_result (coding, CODING_RESULT_SUCCESS); } -static int +static bool encode_coding_raw_text (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = coding->charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; @@ -5414,21 +5327,20 @@ encode_coding_raw_text (struct coding_system *coding) } /* See the above "GENERAL NOTES on `detect_coding_XXX ()' functions". - Check if a text is encoded in a charset-based coding system. If it - is, return 1, else return 0. */ + Return true if a text is encoded in a charset-based coding system. */ -static int +static bool detect_coding_charset (struct coding_system *coding, struct coding_detection_info *detect_info) { const unsigned char *src = coding->source, *src_base; const unsigned char *src_end = coding->source + coding->src_bytes; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; ptrdiff_t consumed_chars = 0; Lisp_Object attrs, valids, name; int found = 0; ptrdiff_t head_ascii = coding->head_ascii; - int check_latin_extra = 0; + bool check_latin_extra = 0; detect_info->checked |= CATEGORY_MASK_CHARSET; @@ -5532,14 +5444,14 @@ decode_coding_charset (struct coding_system *coding) int *charbuf_end = coding->charbuf + coding->charbuf_size - (MAX_ANNOTATION_LENGTH * 2); ptrdiff_t consumed_chars = 0, consumed_chars_base; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; Lisp_Object attrs = CODING_ID_ATTRS (coding->id); Lisp_Object valids; ptrdiff_t char_offset = coding->produced_char; ptrdiff_t last_offset = char_offset; int last_id = charset_ascii; - int eol_dos = - !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); + bool eol_dos + = !inhibit_eol_conversion && EQ (CODING_ID_EOL_TYPE (coding->id), Qdos); int byte_after_cr = -1; valids = AREF (attrs, coding_attr_charset_valids); @@ -5648,10 +5560,10 @@ decode_coding_charset (struct coding_system *coding) coding->charbuf_used = charbuf - coding->charbuf; } -static int +static bool encode_coding_charset (struct coding_system *coding) { - int multibytep = coding->dst_multibyte; + bool multibytep = coding->dst_multibyte; int *charbuf = coding->charbuf; int *charbuf_end = charbuf + coding->charbuf_used; unsigned char *dst = coding->destination + coding->produced; @@ -5659,7 +5571,7 @@ encode_coding_charset (struct coding_system *coding) int safe_room = MAX_MULTIBYTE_LENGTH; ptrdiff_t produced_chars = 0; Lisp_Object attrs, charset_list; - int ascii_compatible; + bool ascii_compatible; int c; CODING_GET_INFO (coding, attrs, charset_list); @@ -5865,7 +5777,6 @@ setup_coding_system (Lisp_Object coding_system, struct coding_system *coding) coding->encoder = encode_coding_emacs_mule; coding->common_flags |= (CODING_REQUIRE_DECODING_MASK | CODING_REQUIRE_ENCODING_MASK); - coding->spec.emacs_mule.full_support = 1; if (! NILP (AREF (attrs, coding_attr_emacs_mule_full)) && ! EQ (CODING_ATTR_CHARSET_LIST (attrs), Vemacs_mule_charset_list)) { @@ -5883,7 +5794,6 @@ setup_coding_system (Lisp_Object coding_system, struct coding_system *coding) SSET (safe_charsets, XFASTINT (XCAR (tail)), 0); coding->max_charset_id = max_charset_id; coding->safe_charsets = SDATA (safe_charsets); - coding->spec.emacs_mule.full_support = 1; } coding->spec.emacs_mule.cmp_status.state = COMPOSING_NO; coding->spec.emacs_mule.cmp_status.method = COMPOSITION_NO; @@ -6216,11 +6126,9 @@ detect_eol (const unsigned char *source, ptrdiff_t src_bytes, if ((1 << category) & CATEGORY_MASK_UTF_16) { - int msb, lsb; - - msb = category == (coding_category_utf_16_le - | coding_category_utf_16_le_nosig); - lsb = 1 - msb; + bool msb = category == (coding_category_utf_16_le + | coding_category_utf_16_le_nosig); + bool lsb = !msb; while (src + 1 < src_end) { @@ -6335,7 +6243,7 @@ static void detect_coding (struct coding_system *coding) { const unsigned char *src, *src_end; - int saved_mode = coding->mode; + unsigned int saved_mode = coding->mode; coding->consumed = coding->consumed_char = 0; coding->produced = coding->produced_char = 0; @@ -6350,7 +6258,7 @@ detect_coding (struct coding_system *coding) { int c, i; struct coding_detection_info detect_info; - int null_byte_found = 0, eight_bit_found = 0; + bool null_byte_found = 0, eight_bit_found = 0; detect_info.checked = detect_info.found = detect_info.rejected = 0; for (src = coding->source; src < src_end; src++) @@ -6609,11 +6517,11 @@ decode_eol (struct coding_system *coding) /* Return a translation table (or list of them) from coding system - attribute vector ATTRS for encoding (ENCODEP is nonzero) or - decoding (ENCODEP is zero). */ + attribute vector ATTRS for encoding (if ENCODEP) or decoding (if + not ENCODEP). */ static Lisp_Object -get_translation_table (Lisp_Object attrs, int encodep, int *max_lookup) +get_translation_table (Lisp_Object attrs, bool encodep, int *max_lookup) { Lisp_Object standard, translation_table; Lisp_Object val; @@ -6743,7 +6651,7 @@ get_translation (Lisp_Object trans, int *buf, int *buf_end) static int produce_chars (struct coding_system *coding, Lisp_Object translation_table, - int last_block) + bool last_block) { unsigned char *dst = coding->destination + coding->produced; unsigned char *dst_end = coding->destination + coding->dst_bytes; @@ -6846,7 +6754,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, { if (coding->src_multibyte) { - int multibytep = 1; + bool multibytep = 1; ptrdiff_t consumed_chars = 0; while (1) @@ -6882,7 +6790,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, else while (src < src_end) { - int multibytep = 1; + bool multibytep = 1; int c = *src++; if (dst >= dst_end - 1) @@ -7018,7 +6926,7 @@ produce_charset (struct coding_system *coding, int *charbuf, ptrdiff_t pos) if (! coding->charbuf) \ { \ record_conversion_result (coding, CODING_RESULT_INSUFFICIENT_MEM); \ - return coding->result; \ + return; \ } \ coding->charbuf_size = size; \ } while (0) @@ -7079,7 +6987,7 @@ produce_annotation (struct coding_system *coding, ptrdiff_t pos) CODING->dst_object. */ -static int +static void decode_coding (struct coding_system *coding) { Lisp_Object attrs; @@ -7212,7 +7120,6 @@ decode_coding (struct coding_system *coding) bset_undo_list (current_buffer, undo_list); record_insert (coding->dst_pos, coding->produced_char); } - return coding->result; } @@ -7341,7 +7248,7 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table, const unsigned char *src_end = coding->source + coding->src_bytes; ptrdiff_t pos = coding->src_pos + coding->consumed_char; ptrdiff_t end_pos = coding->src_pos + coding->src_chars; - int multibytep = coding->src_multibyte; + bool multibytep = coding->src_multibyte; Lisp_Object eol_type; int c; ptrdiff_t stop, stop_composition, stop_charset; @@ -7488,7 +7395,7 @@ consume_chars (struct coding_system *coding, Lisp_Object translation_table, If CODING->dst_object is nil, the encoded data is placed at the memory area specified by CODING->destination. */ -static int +static void encode_coding (struct coding_system *coding) { Lisp_Object attrs; @@ -7530,8 +7437,6 @@ encode_coding (struct coding_system *coding) if (BUFFERP (coding->dst_object) && coding->produced_char > 0) insert_from_gap (coding->produced_char, coding->produced); - - return (coding->result); } @@ -7545,26 +7450,27 @@ static Lisp_Object Vcode_conversion_workbuf_name; versions of Vcode_conversion_workbuf_name. */ static Lisp_Object Vcode_conversion_reused_workbuf; -/* 1 iff Vcode_conversion_reused_workbuf is already in use. */ -static int reused_workbuf_in_use; +/* True iff Vcode_conversion_reused_workbuf is already in use. */ +static bool reused_workbuf_in_use; /* Return a working buffer of code conversion. MULTIBYTE specifies the multibyteness of returning buffer. */ static Lisp_Object -make_conversion_work_buffer (int multibyte) +make_conversion_work_buffer (bool multibyte) { Lisp_Object name, workbuf; struct buffer *current; - if (reused_workbuf_in_use++) + if (reused_workbuf_in_use) { name = Fgenerate_new_buffer_name (Vcode_conversion_workbuf_name, Qnil); workbuf = Fget_buffer_create (name); } else { + reused_workbuf_in_use = 1; if (NILP (Fbuffer_live_p (Vcode_conversion_reused_workbuf))) Vcode_conversion_reused_workbuf = Fget_buffer_create (Vcode_conversion_workbuf_name); @@ -7606,7 +7512,7 @@ code_conversion_restore (Lisp_Object arg) } Lisp_Object -code_conversion_save (int with_work_buf, int multibyte) +code_conversion_save (bool with_work_buf, bool multibyte) { Lisp_Object workbuf = Qnil; @@ -7617,7 +7523,7 @@ code_conversion_save (int with_work_buf, int multibyte) return workbuf; } -int +void decode_coding_gap (struct coding_system *coding, ptrdiff_t chars, ptrdiff_t bytes) { @@ -7660,7 +7566,6 @@ decode_coding_gap (struct coding_system *coding, } unbind_to (count, Qnil); - return coding->result; } @@ -7706,8 +7611,8 @@ decode_coding_object (struct coding_system *coding, ptrdiff_t chars = to - from; ptrdiff_t bytes = to_byte - from_byte; Lisp_Object attrs; - int saved_pt = -1, saved_pt_byte IF_LINT (= 0); - int need_marker_adjustment = 0; + ptrdiff_t saved_pt = -1, saved_pt_byte IF_LINT (= 0); + bool need_marker_adjustment = 0; Lisp_Object old_deactivate_mark; old_deactivate_mark = Vdeactivate_mark; @@ -7894,9 +7799,9 @@ encode_coding_object (struct coding_system *coding, ptrdiff_t chars = to - from; ptrdiff_t bytes = to_byte - from_byte; Lisp_Object attrs; - int saved_pt = -1, saved_pt_byte IF_LINT (= 0); - int need_marker_adjustment = 0; - int kill_src_buffer = 0; + ptrdiff_t saved_pt = -1, saved_pt_byte IF_LINT (= 0); + bool need_marker_adjustment = 0; + bool kill_src_buffer = 0; Lisp_Object old_deactivate_mark; old_deactivate_mark = Vdeactivate_mark; @@ -8172,10 +8077,10 @@ function `define-coding-system'. */) /* Detect how the bytes at SRC of length SRC_BYTES are encoded. If - HIGHEST is nonzero, return the coding system of the highest + HIGHEST, return the coding system of the highest priority among the detected coding systems. Otherwise return a list of detected coding systems sorted by their priorities. If - MULTIBYTEP is nonzero, it is assumed that the bytes are in correct + MULTIBYTEP, it is assumed that the bytes are in correct multibyte form but contains only ASCII and eight-bit chars. Otherwise, the bytes are raw bytes. @@ -8190,7 +8095,7 @@ function `define-coding-system'. */) Lisp_Object detect_coding_system (const unsigned char *src, ptrdiff_t src_chars, ptrdiff_t src_bytes, - int highest, int multibytep, + bool highest, bool multibytep, Lisp_Object coding_system) { const unsigned char *src_end = src + src_bytes; @@ -8200,7 +8105,7 @@ detect_coding_system (const unsigned char *src, ptrdiff_t id; struct coding_detection_info detect_info; enum coding_category base_category; - int null_byte_found = 0, eight_bit_found = 0; + bool null_byte_found = 0, eight_bit_found = 0; if (NILP (coding_system)) coding_system = Qundecided; @@ -8556,7 +8461,7 @@ highest priority. */) } -static inline int +static inline bool char_encodable_p (int c, Lisp_Object attrs) { Lisp_Object tail; @@ -8728,7 +8633,7 @@ to the string. */) Lisp_Object positions; ptrdiff_t from, to; const unsigned char *p, *stop, *pend; - int ascii_compatible; + bool ascii_compatible; setup_coding_system (Fcheck_coding_system (coding_system), &coding); attrs = CODING_ID_ATTRS (coding.id); @@ -8952,7 +8857,7 @@ is nil. */) static Lisp_Object code_convert_region (Lisp_Object start, Lisp_Object end, Lisp_Object coding_system, Lisp_Object dst_object, - int encodep, int norecord) + bool encodep, bool norecord) { struct coding_system coding; ptrdiff_t from, from_byte, to, to_byte; @@ -9040,7 +8945,8 @@ not fully specified.) */) Lisp_Object code_convert_string (Lisp_Object string, Lisp_Object coding_system, - Lisp_Object dst_object, int encodep, int nocopy, int norecord) + Lisp_Object dst_object, bool encodep, bool nocopy, + bool norecord) { struct coding_system coding; ptrdiff_t chars, bytes; @@ -9088,7 +8994,7 @@ code_convert_string (Lisp_Object string, Lisp_Object coding_system, Lisp_Object code_convert_string_norecord (Lisp_Object string, Lisp_Object coding_system, - int encodep) + bool encodep) { return code_convert_string (string, coding_system, Qt, encodep, 0, 1); } @@ -9489,7 +9395,7 @@ usage: (set-coding-system-priority &rest coding-systems) */) (ptrdiff_t nargs, Lisp_Object *args) { ptrdiff_t i, j; - int changed[coding_category_max]; + bool changed[coding_category_max]; enum coding_category priorities[coding_category_max]; memset (changed, 0, sizeof changed); -- cgit v1.2.1 From a3d794a153425b09a0185c660926c241d13e0f2c Mon Sep 17 00:00:00 2001 From: Dmitry Antipov Date: Tue, 28 Aug 2012 09:49:02 +0400 Subject: Fix usage of set_buffer_internal. * buffer.h (set_buffer_internal): Make it BUFFER_INLINE. * buffer.c (set_buffer_if_live): Use set_buffer_internal. * coding.c (decode_coding): Omit redundant test. * fileio.c (decide_coding_unwind): Likewise. * fns.c (secure_hash): Likewise. * insdel.c (modify_region): Likewise. * keyboard.c (command_loop_1): Likewise. * print.c (PRINTFINISH): Likewise. * xdisp.c (run_window_scroll_functions): Use set_buffer_internal. --- src/coding.c | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 5bfd42c7272..02e7b34695e 100644 --- a/src/coding.c +++ b/src/coding.c @@ -7006,8 +7006,7 @@ decode_coding (struct coding_system *coding) undo_list = Qt; if (BUFFERP (coding->dst_object)) { - if (current_buffer != XBUFFER (coding->dst_object)) - set_buffer_internal (XBUFFER (coding->dst_object)); + set_buffer_internal (XBUFFER (coding->dst_object)); if (GPT != PT) move_gap_both (PT, PT_BYTE); -- cgit v1.2.1 From 1088b9226e7dac7314dab52ef0696a5f540900cd Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Tue, 4 Sep 2012 10:34:54 -0700 Subject: Simplify redefinition of 'abort' (Bug#12316). Do not try to redefine the 'abort' function. Instead, redo the code so that it calls 'emacs_abort' rather than 'abort'. This removes the need for the NO_ABORT configure-time macro and makes it easier to change the abort code to do a backtrace. * configure.ac (NO_ABRT): Remove. * admin/CPP-DEFINES (NO_ABORT): Remove. * nt/inc/ms-w32.h (w32_abort) [HAVE_NTGUI]: Remove. * src/.gdbinit: Just stop at emacs_abort, not at w32_abort or abort. * src/emacs.c (abort) [!DOS_NT && !NO_ABORT]: Remove; sysdep.c's emacs_abort now takes its place. * src/lisp.h (emacs_abort): New decl. All calls from Emacs code to 'abort' changed to use 'emacs_abort'. * src/msdos.c (dos_abort) [defined abort]: Remove; not used. (abort) [!defined abort]: Rename to ... (emacs_abort): ... new name. * src/sysdep.c (emacs_abort) [!HAVE_NTGUI]: New function, taking the place of the old 'abort' in emacs.c. * src/w32.c, src/w32fns.c (abort): Do not #undef. * src/w32.c (emacs_abort): Rename from w32_abort. --- src/coding.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 02e7b34695e..94a2d9fea80 100644 --- a/src/coding.c +++ b/src/coding.c @@ -2051,7 +2051,7 @@ emacs_mule_char (struct coding_system *coding, const unsigned char *src, break; default: - abort (); + emacs_abort (); } CODING_DECODE_CHAR (coding, src, src_base, src_end, CHARSET_FROM_ID (charset_ID), code, c); @@ -2345,7 +2345,7 @@ decode_coding_emacs_mule (struct coding_system *coding) int i; if (charbuf_end - charbuf < cmp_status->length) - abort (); + emacs_abort (); for (i = 0; i < cmp_status->length; i++) *charbuf++ = cmp_status->carryover[i]; coding->annotated = 1; @@ -2619,7 +2619,7 @@ encode_coding_emacs_mule (struct coding_system *coding) preferred_charset_id = -1; break; default: - abort (); + emacs_abort (); } charbuf += -c - 1; continue; @@ -3482,7 +3482,7 @@ decode_coding_iso_2022 (struct coding_system *coding) if (cmp_status->state != COMPOSING_NO) { if (charbuf_end - charbuf < cmp_status->length) - abort (); + emacs_abort (); for (i = 0; i < cmp_status->length; i++) *charbuf++ = cmp_status->carryover[i]; coding->annotated = 1; @@ -3864,7 +3864,7 @@ decode_coding_iso_2022 (struct coding_system *coding) break; default: - abort (); + emacs_abort (); } if (cmp_status->state == COMPOSING_NO @@ -4419,7 +4419,7 @@ encode_coding_iso_2022 (struct coding_system *coding) preferred_charset_id = -1; break; default: - abort (); + emacs_abort (); } charbuf += -c - 1; continue; @@ -4933,7 +4933,7 @@ encode_coding_sjis (struct coding_system *coding) } } if (code == CHARSET_INVALID_CODE (charset)) - abort (); + emacs_abort (); if (charset == charset_kanji) { int c1, c2; @@ -5023,7 +5023,7 @@ encode_coding_big5 (struct coding_system *coding) } } if (code == CHARSET_INVALID_CODE (charset)) - abort (); + emacs_abort (); if (charset == charset_big5) { int c1, c2; @@ -7190,7 +7190,7 @@ handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit, *buf++ = XINT (XCAR (components)); } else - abort (); + emacs_abort (); *head -= len; } } @@ -9428,7 +9428,7 @@ usage: (set-coding-system-priority &rest coding-systems) */) && changed[coding_priorities[j]]) j++; if (j == coding_category_max) - abort (); + emacs_abort (); priorities[i] = coding_priorities[j]; } -- cgit v1.2.1 From 0328b6de4a92676b4ad4616095ce19a4f51d1c4d Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sat, 15 Sep 2012 00:06:56 -0700 Subject: Port better to POSIX hosts lacking _setjmp. * configure.ac (HAVE__SETJMP, HAVE_SIGSETJMP): New symbols. (_setjmp, _longjmp): Remove. * src/lisp.h: Include here, since we use its symbols here. All instances of '#include ' removed, if the only reason for the instance was because "lisp.h" was included. (sys_jmp_buf, sys_setjmp, sys_longjmp): New symbols. Unless otherwise specified, replace all uses of jmp_buf, _setjmp, and _longjmp with the new symbols. Emacs already uses _setjmp if available, so this change affects only POSIXish hosts that have sigsetjmp but not _setjmp, such as some versions of Solaris and Unixware. (Also, POSIX-2008 marks _setjmp as obsolescent.) * src/image.c (_setjmp, _longjmp) [HAVE_PNG && !HAVE__SETJMP]: New macros. (png_load_body) [HAVE_PNG]: (PNG_LONGJMP) [HAVE_PNG && PNG_LIBPNG_VER < 10500]: (PNG_JMPBUF) [HAVE_PNG && PNG_LIBPNG_VER >= 10500]: Use _setjmp and _longjmp rather than sys_setjmp and sys_longjmp, since PNG requires jmp_buf. This is the only exception to the general rule that we now use sys_setjmp and sys_longjmp. This exception is OK since this code does not change the signal mask or longjmp out of a signal handler. Fixes: debbugs:12446 --- src/coding.c | 1 - 1 file changed, 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 94a2d9fea80..4b3d22f956c 100644 --- a/src/coding.c +++ b/src/coding.c @@ -285,7 +285,6 @@ encode_coding_XXX (struct coding_system *coding) #include #include -#include #include "lisp.h" #include "character.h" -- cgit v1.2.1 From eedec3eec8ea42189032fcde9d5f11a048fa837a Mon Sep 17 00:00:00 2001 From: Eli Zaretskii Date: Tue, 25 Sep 2012 14:44:13 +0200 Subject: Followup to not using maybe_unify_char in processing buffers and strings. src/coding.c (CHAR_STRING_ADVANCE_NO_UNIFY): Make it an alias of CHAR_STRING_ADVANCE. (STRING_CHAR_ADVANCE_NO_UNIFY): Make it an alias of STRING_CHAR_ADVANCE. --- src/coding.c | 63 ++++++++---------------------------------------------------- 1 file changed, 8 insertions(+), 55 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 4b3d22f956c..13f53ad5abc 100644 --- a/src/coding.c +++ b/src/coding.c @@ -920,65 +920,18 @@ record_conversion_result (struct coding_system *coding, /* Store multibyte form of the character C in P, and advance P to the - end of the multibyte form. This is like CHAR_STRING_ADVANCE but it - never calls MAYBE_UNIFY_CHAR. */ - -#define CHAR_STRING_ADVANCE_NO_UNIFY(c, p) \ - do { \ - if ((c) <= MAX_1_BYTE_CHAR) \ - *(p)++ = (c); \ - else if ((c) <= MAX_2_BYTE_CHAR) \ - *(p)++ = (0xC0 | ((c) >> 6)), \ - *(p)++ = (0x80 | ((c) & 0x3F)); \ - else if ((c) <= MAX_3_BYTE_CHAR) \ - *(p)++ = (0xE0 | ((c) >> 12)), \ - *(p)++ = (0x80 | (((c) >> 6) & 0x3F)), \ - *(p)++ = (0x80 | ((c) & 0x3F)); \ - else if ((c) <= MAX_4_BYTE_CHAR) \ - *(p)++ = (0xF0 | (c >> 18)), \ - *(p)++ = (0x80 | ((c >> 12) & 0x3F)), \ - *(p)++ = (0x80 | ((c >> 6) & 0x3F)), \ - *(p)++ = (0x80 | (c & 0x3F)); \ - else if ((c) <= MAX_5_BYTE_CHAR) \ - *(p)++ = 0xF8, \ - *(p)++ = (0x80 | ((c >> 18) & 0x0F)), \ - *(p)++ = (0x80 | ((c >> 12) & 0x3F)), \ - *(p)++ = (0x80 | ((c >> 6) & 0x3F)), \ - *(p)++ = (0x80 | (c & 0x3F)); \ - else \ - (p) += BYTE8_STRING ((c) - 0x3FFF80, p); \ - } while (0) + end of the multibyte form. This used to be like CHAR_STRING_ADVANCE + without ever calling MAYBE_UNIFY_CHAR, but nowadays we don't call + MAYBE_UNIFY_CHAR in CHAR_STRING_ADVANCE. */ +#define CHAR_STRING_ADVANCE_NO_UNIFY(c, p) CHAR_STRING_ADVANCE(c, p) /* Return the character code of character whose multibyte form is at - P, and advance P to the end of the multibyte form. This is like - STRING_CHAR_ADVANCE, but it never calls MAYBE_UNIFY_CHAR. */ - -#define STRING_CHAR_ADVANCE_NO_UNIFY(p) \ - (!((p)[0] & 0x80) \ - ? *(p)++ \ - : ! ((p)[0] & 0x20) \ - ? ((p) += 2, \ - ((((p)[-2] & 0x1F) << 6) \ - | ((p)[-1] & 0x3F) \ - | ((unsigned char) ((p)[-2]) < 0xC2 ? 0x3FFF80 : 0))) \ - : ! ((p)[0] & 0x10) \ - ? ((p) += 3, \ - ((((p)[-3] & 0x0F) << 12) \ - | (((p)[-2] & 0x3F) << 6) \ - | ((p)[-1] & 0x3F))) \ - : ! ((p)[0] & 0x08) \ - ? ((p) += 4, \ - ((((p)[-4] & 0xF) << 18) \ - | (((p)[-3] & 0x3F) << 12) \ - | (((p)[-2] & 0x3F) << 6) \ - | ((p)[-1] & 0x3F))) \ - : ((p) += 5, \ - ((((p)[-4] & 0x3F) << 18) \ - | (((p)[-3] & 0x3F) << 12) \ - | (((p)[-2] & 0x3F) << 6) \ - | ((p)[-1] & 0x3F)))) + P, and advance P to the end of the multibyte form. This used to be + like STRING_CHAR_ADVANCE without ever calling MAYBE_UNIFY_CHAR, but + nowadays STRING_CHAR_ADVANCE doesn't call MAYBE_UNIFY_CHAR. */ +#define STRING_CHAR_ADVANCE_NO_UNIFY(p) STRING_CHAR_ADVANCE(p) /* Set coding->source from coding->src_object. */ -- cgit v1.2.1 From 95402d5faa114a311cabfb8c64cf22a93787a066 Mon Sep 17 00:00:00 2001 From: Kenichi Handa Date: Sun, 30 Sep 2012 22:25:11 +0900 Subject: coding.c (decode_coding_ccl, encode_coding_ccl): Pay attention to the buffer relocation which may be caused by ccl_driver. --- src/coding.c | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 4b3d22f956c..40e67b9a6c8 100644 --- a/src/coding.c +++ b/src/coding.c @@ -5106,6 +5106,7 @@ decode_coding_ccl (struct coding_system *coding) while (1) { const unsigned char *p = src; + ptrdiff_t offset; int i = 0; if (multibytep) @@ -5123,8 +5124,17 @@ decode_coding_ccl (struct coding_system *coding) if (p == src_end && coding->mode & CODING_MODE_LAST_BLOCK) ccl->last_block = 1; + /* As ccl_driver calls DECODE_CHAR, buffer may be relocated. */ + charset_map_loaded = 0; ccl_driver (ccl, source_charbuf, charbuf, i, charbuf_end - charbuf, charset_list); + if (charset_map_loaded + && (offset = coding_change_source (coding))) + { + p += offset; + src += offset; + src_end += offset; + } charbuf += ccl->produced; if (multibytep) src += source_byteidx[ccl->consumed]; @@ -5177,8 +5187,15 @@ encode_coding_ccl (struct coding_system *coding) do { + ptrdiff_t offset; + + /* As ccl_driver calls DECODE_CHAR, buffer may be relocated. */ + charset_map_loaded = 0; ccl_driver (ccl, charbuf, destination_charbuf, charbuf_end - charbuf, 1024, charset_list); + if (charset_map_loaded + && (offset = coding_change_destination (coding))) + dst += offset; if (multibytep) { ASSURE_DESTINATION (ccl->produced * 2); -- cgit v1.2.1 From b0ab8123df78b7149d1f55b2ef0d3095c3f10628 Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Sun, 30 Sep 2012 23:36:54 -0700 Subject: Prefer plain 'static' to 'static inline'. With static functions, modern compilers inline pretty well by themselves; advice from programmers often hurts as much as it helps. On my host (x86-64, Fedora 17, GCC 4.7.2, default 'configure'), this change shrinks the text size of the Emacs executable by 1.1% without affecting CPU significantly in my benchmark. * alloc.c (mem_find, live_string_p, live_cons_p, live_symbol_p) (live_float_p, live_misc_p, live_vector_p, live_buffer_p) (mark_maybe_object, mark_maybe_pointer, bounded_number): * buffer.c (bset_abbrev_mode, bset_abbrev_table) (bset_auto_fill_function, bset_auto_save_file_format) (bset_auto_save_file_name, bset_backed_up, bset_begv_marker) (bset_bidi_display_reordering, bset_buffer_file_coding_system) (bset_cache_long_line_scans, bset_case_fold_search) (bset_ctl_arrow, bset_cursor_in_non_selected_windows) (bset_cursor_type, bset_display_table, bset_extra_line_spacing) (bset_file_format, bset_file_truename, bset_fringe_cursor_alist) (bset_fringe_indicator_alist, bset_fringes_outside_margins) (bset_header_line_format, bset_indicate_buffer_boundaries) (bset_indicate_empty_lines, bset_invisibility_spec) (bset_left_fringe_width, bset_major_mode, bset_mark) (bset_minor_modes, bset_mode_line_format, bset_mode_name) (bset_name, bset_overwrite_mode, bset_pt_marker) (bset_right_fringe_width, bset_save_length) (bset_scroll_bar_width, bset_scroll_down_aggressively) (bset_scroll_up_aggressively, bset_selective_display) (bset_selective_display_ellipses, bset_vertical_scroll_bar_type) (bset_word_wrap, bset_zv_marker, set_buffer_overlays_before) (set_buffer_overlays_after): * category.c (bset_category_table): * charset.c (read_hex): * coding.c (produce_composition, produce_charset) (handle_composition_annotation, handle_charset_annotation) (char_encodable_p): * dispnew.c (swap_glyph_pointers, copy_row_except_pointers) (assign_row, set_frame_matrix_frame, make_current) (add_row_entry): * eval.c (set_specpdl_symbol, set_specpdl_old_value): * fns.c (maybe_resize_hash_table): * frame.c (fset_buffer_predicate, fset_minibuffer_window): * gmalloc.c (register_heapinfo): * image.c (lookup_image_type): * intervals.c (set_interval_object, set_interval_left) (set_interval_right, copy_interval_parent, rotate_right) (rotate_left, balance_possible_root_interval): * keyboard.c (kset_echo_string, kset_kbd_queue) (kset_keyboard_translate_table, kset_last_prefix_arg) (kset_last_repeatable_command, kset_local_function_key_map) (kset_overriding_terminal_local_map, kset_real_last_command) (kset_system_key_syms, clear_event, set_prop): * lread.c (digit_to_number): * marker.c (attach_marker, live_buffer, set_marker_internal): * nsterm.m (ns_compute_glyph_string_overhangs): * process.c (pset_buffer, pset_command) (pset_decode_coding_system, pset_decoding_buf) (pset_encode_coding_system, pset_encoding_buf, pset_filter) (pset_log, pset_mark, pset_name, pset_plist, pset_sentinel) (pset_status, pset_tty_name, pset_type, pset_write_queue): * syntax.c (bset_syntax_table, dec_bytepos): * terminal.c (tset_param_alist): * textprop.c (interval_has_some_properties) (interval_has_some_properties_list): * window.c (wset_combination_limit, wset_dedicated) (wset_display_table, wset_hchild, wset_left_fringe_width) (wset_left_margin_cols, wset_new_normal, wset_new_total) (wset_normal_cols, wset_normal_lines, wset_parent, wset_pointm) (wset_right_fringe_width, wset_right_margin_cols) (wset_scroll_bar_width, wset_start, wset_temslot, wset_vchild) (wset_vertical_scroll_bar_type, wset_window_parameters): * xdisp.c (wset_base_line_number, wset_base_line_pos) (wset_column_number_displayed, wset_region_showing) (window_box_edges, run_window_scroll_functions) (append_glyph_string_lists, prepend_glyph_string_lists) (append_glyph_string, set_glyph_string_background_width) (append_glyph, append_composite_glyph) (take_vertical_position_into_account): * xfaces.c (x_create_gc, x_free_gc, merge_face_vectors) (face_attr_equal_p, lface_equal_p, hash_string_case_insensitive) (lface_hash, lface_same_font_attributes_p, lookup_face): * xml.c (libxml2_loaded_p): * xterm.c (x_set_mode_line_face_gc, x_set_glyph_string_gc) (x_set_glyph_string_clipping, x_clear_glyph_string_rect): Now 'static', not 'static inline'. Fixes: debbugs:12541 --- src/coding.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 32d300b9923..d9606cf5710 100644 --- a/src/coding.c +++ b/src/coding.c @@ -6822,7 +6822,7 @@ produce_chars (struct coding_system *coding, Lisp_Object translation_table, [ -LENGTH ANNOTATION_MASK NCHARS NBYTES METHOD [ COMPONENTS... ] ] */ -static inline void +static void produce_composition (struct coding_system *coding, int *charbuf, ptrdiff_t pos) { int len; @@ -6866,7 +6866,7 @@ produce_composition (struct coding_system *coding, int *charbuf, ptrdiff_t pos) [ -LENGTH ANNOTATION_MASK NCHARS CHARSET-ID ] */ -static inline void +static void produce_charset (struct coding_system *coding, int *charbuf, ptrdiff_t pos) { ptrdiff_t from = pos - charbuf[2]; @@ -7101,7 +7101,7 @@ decode_coding (struct coding_system *coding) position of a composition after POS (if any) or to LIMIT, and return BUF. */ -static inline int * +static int * handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit, struct coding_system *coding, int *buf, ptrdiff_t *stop) @@ -7184,7 +7184,7 @@ handle_composition_annotation (ptrdiff_t pos, ptrdiff_t limit, If the property value is nil, set *STOP to the position where the property value is non-nil (limiting by LIMIT), and return BUF. */ -static inline int * +static int * handle_charset_annotation (ptrdiff_t pos, ptrdiff_t limit, struct coding_system *coding, int *buf, ptrdiff_t *stop) @@ -8429,7 +8429,7 @@ highest priority. */) } -static inline bool +static bool char_encodable_p (int c, Lisp_Object attrs) { Lisp_Object tail; -- cgit v1.2.1 From 0ba06a77fd4ccf92f1106b8ab7d8d64d6d812a1d Mon Sep 17 00:00:00 2001 From: Kenichi Handa Date: Sat, 13 Oct 2012 21:58:52 +0900 Subject: coding.c (detect_coding): Set coding->id before calling this->detector. --- src/coding.c | 3 +++ 1 file changed, 3 insertions(+) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index d9606cf5710..412d7245223 100644 --- a/src/coding.c +++ b/src/coding.c @@ -6301,6 +6301,9 @@ detect_coding (struct coding_system *coding) { category = coding_priorities[i]; this = coding_categories + category; + /* Some of this->detector (e.g. detect_coding_sjis) + require this information. */ + coding->id = this->id; if (this->id < 0) { /* No coding system of this category is defined. */ -- cgit v1.2.1 From a0d7415fb62cf17e1465ee19cffb3ae6e20390b3 Mon Sep 17 00:00:00 2001 From: Kenichi Handa Date: Fri, 19 Oct 2012 21:59:42 +0900 Subject: font.c (Ffont_at): Fix previous change. --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 412d7245223..7628a9fbf2e 100644 --- a/src/coding.c +++ b/src/coding.c @@ -415,7 +415,7 @@ enum iso_code_class_type ISO_shift_out, /* ISO_CODE_SO (0x0E) */ ISO_shift_in, /* ISO_CODE_SI (0x0F) */ ISO_single_shift_2_7, /* ISO_CODE_SS2_7 (0x19) */ - ISO_escape, /* ISO_CODE_SO (0x1B) */ + ISO_escape, /* ISO_CODE_ESC (0x1B) */ ISO_control_1, /* Control codes in the range 0x80..0x9F, except for the following 3 codes. */ -- cgit v1.2.1 From ba11600816880f862a7a85899bfa3dc41c176273 Mon Sep 17 00:00:00 2001 From: Daniel Colascione Date: Mon, 29 Oct 2012 09:24:29 -0800 Subject: 2012-10-29 Daniel Colascione cygw32.h, cygw32.c (Qutf_16le, from_unicode, to_unicode): In preparation for fixing bug#12739, move these functions from here... * coding.h, coding.c: ... to here, and compile them only when WINDOWSNT or HAVE_NTGUI. Moving these functions out of cygw32 proper lets us write cygw32-agnostic code for the HAVE_NTGUI case. --- src/coding.c | 42 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 42 insertions(+) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 7628a9fbf2e..611f92ea152 100644 --- a/src/coding.c +++ b/src/coding.c @@ -343,6 +343,10 @@ Lisp_Object Qcoding_system_p, Qcoding_system_error; Lisp_Object Qemacs_mule, Qraw_text; Lisp_Object Qutf_8_emacs; +#if defined (WINDOWSNT) || defined (HAVE_NTGUI) +static Lisp_Object Qutf_16le; +#endif + /* Coding-systems are handed between Emacs Lisp programs and C internal routines by the following three variables. */ /* Coding system to be used to encode text for terminal display when @@ -7971,6 +7975,39 @@ preferred_coding_system (void) return CODING_ID_NAME (id); } +#if defined (WINDOWSNT) || defined (HAVE_NTGUI) + +Lisp_Object +from_unicode (Lisp_Object str) +{ + CHECK_STRING (str); + if (!STRING_MULTIBYTE (str) && + SBYTES (str) & 1) + { + str = Fsubstring (str, make_number (0), make_number (-1)); + } + + return code_convert_string_norecord (str, Qutf_16le, 0); +} + +wchar_t * +to_unicode (Lisp_Object str, Lisp_Object *buf) +{ + *buf = code_convert_string_norecord (str, Qutf_16le, 1); + /* We need to make a another copy (in addition to the one made by + code_convert_string_norecord) to ensure that the final string is + _doubly_ zero terminated --- that is, that the string is + terminated by two zero bytes and one utf-16le null character. + Because strings are already terminated with a single zero byte, + we just add one additional zero. */ + str = make_uninit_string (SBYTES (*buf) + 1); + memcpy (SDATA (str), SDATA (*buf), SBYTES (*buf)); + SDATA (str) [SBYTES (*buf)] = '\0'; + *buf = str; + return WCSDATA (*buf); +} +#endif /* WINDOWSNT || HAVE_NTGUI */ + #ifdef emacs /*** 8. Emacs Lisp library functions ***/ @@ -10284,6 +10321,11 @@ syms_of_coding (void) DEFSYM (Qutf_8, "utf-8"); DEFSYM (Qutf_8_emacs, "utf-8-emacs"); +#if defined (WINDOWSNT) || defined (HAVE_NTGUI) + /* No, not utf-16-le: that one has a BOM. */ + DEFSYM (Qutf_16le, "utf-16le"); +#endif + DEFSYM (Qutf_16, "utf-16"); DEFSYM (Qbig, "big"); DEFSYM (Qlittle, "little"); -- cgit v1.2.1 From 7f590b0c3b25602499432bf986e7b593fc158c0b Mon Sep 17 00:00:00 2001 From: Daniel Colascione Date: Mon, 29 Oct 2012 17:56:38 -0800 Subject: Fix build break in non-Cygw32 Cygwin builds introduced in 2012-10-29T17:24:29Z!dancol@dancol.org. --- src/coding.c | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 611f92ea152..97268e0dcd8 100644 --- a/src/coding.c +++ b/src/coding.c @@ -7975,7 +7975,7 @@ preferred_coding_system (void) return CODING_ID_NAME (id); } -#if defined (WINDOWSNT) || defined (HAVE_NTGUI) +#if defined (WINDOWSNT) || defined (CYGWIN) Lisp_Object from_unicode (Lisp_Object str) @@ -8006,7 +8006,8 @@ to_unicode (Lisp_Object str, Lisp_Object *buf) *buf = str; return WCSDATA (*buf); } -#endif /* WINDOWSNT || HAVE_NTGUI */ + +#endif /* WINDOWSNT || CYGWIN */ #ifdef emacs @@ -10321,7 +10322,7 @@ syms_of_coding (void) DEFSYM (Qutf_8, "utf-8"); DEFSYM (Qutf_8_emacs, "utf-8-emacs"); -#if defined (WINDOWSNT) || defined (HAVE_NTGUI) +#if defined (WINDOWSNT) || defined (CYGWIN) /* No, not utf-16-le: that one has a BOM. */ DEFSYM (Qutf_16le, "utf-16le"); #endif -- cgit v1.2.1 From 53372c278e7e79b97aed97b159a00bde45de3a80 Mon Sep 17 00:00:00 2001 From: Daniel Colascione Date: Mon, 29 Oct 2012 19:10:52 -0800 Subject: Complete fix for build break --- src/coding.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/coding.c') diff --git a/src/coding.c b/src/coding.c index 97268e0dcd8..56202e4861d 100644 --- a/src/coding.c +++ b/src/coding.c @@ -343,7 +343,7 @@ Lisp_Object Qcoding_system_p, Qcoding_system_error; Lisp_Object Qemacs_mule, Qraw_text; Lisp_Object Qutf_8_emacs; -#if defined (WINDOWSNT) || defined (HAVE_NTGUI) +#if defined (WINDOWSNT) || defined (CYGWIN) static Lisp_Object Qutf_16le; #endif -- cgit v1.2.1