mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2026-01-17 00:30:37 -08:00
Code Issues Projects Releases Wiki Activity
emacs/src/composite.c
Paul Eggert d311d28c3f * 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.
2011-09-21 10:41:20 -07:00

2064 lines
63 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* Composite sequence support.
Copyright (C) 2001-2011 Free Software Foundation, Inc.
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
National Institute of Advanced Industrial Science and Technology (AIST)
Registration Number H14PRO021
Copyright (C) 2003, 2006
National Institute of Advanced Industrial Science and Technology (AIST)
Registration Number H13PRO009
This file is part of GNU Emacs.
GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
#include <setjmp.h>
#include "lisp.h"
#include "buffer.h"
#include "character.h"
#include "coding.h"
#include "intervals.h"
#include "window.h"
#include "frame.h"
#include "dispextern.h"
#include "font.h"
#include "termhooks.h"
/* Emacs uses special text property `composition' to support character
composition. A sequence of characters that have the same (i.e. eq)
`composition' property value is treated as a single composite
sequence (we call it just `composition' here after). Characters in
a composition are all composed somehow on the screen.
The property value has this form when the composition is made:
((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
then turns to this form:
(COMPOSITION-ID . (LENGTH COMPONENTS-VEC . MODIFICATION-FUNC))
when the composition is registered in composition_hash_table and
composition_table. These rather peculiar structures were designed
to make it easy to distinguish them quickly (we can do that by
checking only the first element) and to extract LENGTH (from the
former form) and COMPOSITION-ID (from the latter form).
We register a composition when it is displayed, or when the width
is required (for instance, to calculate columns).
LENGTH -- Length of the composition. This information is used to
check the validity of the composition.
COMPONENTS -- Character, string, vector, list, or nil.
If it is nil, characters in the text are composed relatively
according to their metrics in font glyphs.
If it is a character or a string, the character or characters
in the string are composed relatively.
If it is a vector or list of integers, the element is a
character or an encoded composition rule. The characters are
composed according to the rules. (2N)th elements are
characters to be composed and (2N+1)th elements are
composition rules to tell how to compose (2N+2)th element with
the previously composed 2N glyphs.
COMPONENTS-VEC -- Vector of integers. In a relative composition,
the elements are the characters to be composed. In a rule-base
composition, the elements are characters or encoded
composition rules.
MODIFICATION-FUNC -- If non nil, it is a function to call when the
composition gets invalid after a modification in a buffer. If
it is nil, a function in `composition-function-table' of the
first character in the sequence is called.
COMPOSITION-ID --Identification number of the composition. It is
used as an index to composition_table for the composition.
When Emacs has to display a composition or has to know its
displaying width, the function get_composition_id is called. It
returns COMPOSITION-ID so that the caller can access the
information about the composition through composition_table. If a
COMPOSITION-ID has not yet been assigned to the composition,
get_composition_id checks the validity of `composition' property,
and, if valid, assigns a new ID, registers the information in
composition_hash_table and composition_table, and changes the form
of the property value. If the property is invalid,
get_composition_id returns -1 without changing the property value.
We use two tables to keep the information about composition;
composition_hash_table and composition_table.
The former is a hash table whose keys are COMPONENTS-VECs and
values are the corresponding COMPOSITION-IDs. This hash table is
weak, but as each key (COMPONENTS-VEC) is also kept as a value of the
`composition' property, it won't be collected as garbage until all
bits of text that have the same COMPONENTS-VEC are deleted.
The latter is a table of pointers to `struct composition' indexed
by COMPOSITION-ID. This structure keeps the other information (see
composite.h).
In general, a text property holds information about individual
characters. But, a `composition' property holds information about
a sequence of characters (in this sense, it is like the `intangible'
property). That means that we should not share the property value
in adjacent compositions -- we can't distinguish them if they have the
same property. So, after any changes, we call
`update_compositions' and change a property of one of adjacent
compositions to a copy of it. This function also runs a proper
composition modification function to make a composition that gets
invalid by the change valid again.
As the value of the `composition' property holds information about a
specific range of text, the value gets invalid if we change the
text in the range. We treat the `composition' property as always
rear-nonsticky (currently by setting default-text-properties to
(rear-nonsticky (composition))) and we never make properties of
adjacent compositions identical. Thus, any such changes make the
range just shorter. So, we can check the validity of the `composition'
property by comparing LENGTH information with the actual length of
the composition.
*/
Lisp_Object Qcomposition;
/* Table of pointers to the structure `composition' indexed by
COMPOSITION-ID. This structure is for storing information about
each composition except for COMPONENTS-VEC. */
struct composition **composition_table;
/* The current size of `composition_table'. */
static ptrdiff_t composition_table_size;
/* Number of compositions currently made. */
ptrdiff_t n_compositions;
/* Hash table for compositions. The key is COMPONENTS-VEC of
`composition' property. The value is the corresponding
COMPOSITION-ID. */
Lisp_Object composition_hash_table;
static Lisp_Object Qauto_composed;
static Lisp_Object Qauto_composition_function;
/* Maximum number of characters to look back for
auto-compositions. */
#define MAX_AUTO_COMPOSITION_LOOKBACK 3
static Lisp_Object Fcomposition_get_gstring (Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object);
/* Temporary variable used in macros COMPOSITION_XXX. */
Lisp_Object composition_temp;
/* Return COMPOSITION-ID of a composition at buffer position
CHARPOS/BYTEPOS and length NCHARS. The `composition' property of
the sequence is PROP. STRING, if non-nil, is a string that
contains the composition instead of the current buffer.
If the composition is invalid, return -1. */
ptrdiff_t
get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
Lisp_Object prop, Lisp_Object string)
{
Lisp_Object id, length, components, key, *key_contents;
ptrdiff_t glyph_len;
struct Lisp_Hash_Table *hash_table = XHASH_TABLE (composition_hash_table);
ptrdiff_t hash_index;
EMACS_UINT hash_code;
enum composition_method method;
struct composition *cmp;
ptrdiff_t i;
int ch;
/* Maximum length of a string of glyphs. XftGlyphExtents limits
this to INT_MAX, and Emacs limits it further. Divide INT_MAX - 1
by 2 because x_produce_glyphs computes glyph_len * 2 + 1. Divide
the size by MAX_MULTIBYTE_LENGTH because encode_terminal_code
multiplies glyph_len by MAX_MULTIBYTE_LENGTH. */
enum {
GLYPH_LEN_MAX = min ((INT_MAX - 1) / 2,
min (PTRDIFF_MAX, SIZE_MAX) / MAX_MULTIBYTE_LENGTH)
};
/* PROP should be
Form-A: ((LENGTH . COMPONENTS) . MODIFICATION-FUNC)
or
Form-B: (COMPOSITION-ID . (LENGTH COMPONENTS-VEC . MODIFICATION-FUNC))
*/
if (nchars == 0 || !CONSP (prop))
goto invalid_composition;
id = XCAR (prop);
if (INTEGERP (id))
{
/* PROP should be Form-B. */
if (XINT (id) < 0 || XINT (id) >= n_compositions)
goto invalid_composition;
return XINT (id);
}
/* PROP should be Form-A.
Thus, ID should be (LENGTH . COMPONENTS). */
if (!CONSP (id))
goto invalid_composition;
length = XCAR (id);
if (!INTEGERP (length) || XINT (length) != nchars)
goto invalid_composition;
components = XCDR (id);
/* Check if the same composition has already been registered or not
by consulting composition_hash_table. The key for this table is
COMPONENTS (converted to a vector COMPONENTS-VEC) or, if it is
nil, vector of characters in the composition range. */
if (INTEGERP (components))
key = Fmake_vector (make_number (1), components);
else if (STRINGP (components) || CONSP (components))
key = Fvconcat (1, &components);
else if (VECTORP (components))
key = components;
else if (NILP (components))
{
key = Fmake_vector (make_number (nchars), Qnil);
if (STRINGP (string))
for (i = 0; i < nchars; i++)
{
FETCH_STRING_CHAR_ADVANCE (ch, string, charpos, bytepos);
XVECTOR (key)->contents[i] = make_number (ch);
}
else
for (i = 0; i < nchars; i++)
{
FETCH_CHAR_ADVANCE (ch, charpos, bytepos);
XVECTOR (key)->contents[i] = make_number (ch);
}
}
else
goto invalid_composition;
hash_index = hash_lookup (hash_table, key, &hash_code);
if (hash_index >= 0)
{
/* We have already registered the same composition. Change PROP
from Form-A above to Form-B while replacing COMPONENTS with
COMPONENTS-VEC stored in the hash table. We can directly
modify the cons cell of PROP because it is not shared. */
key = HASH_KEY (hash_table, hash_index);
id = HASH_VALUE (hash_table, hash_index);
XSETCAR (prop, id);
XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
return XINT (id);
}
/* This composition is a new one. We must register it. */
/* Check if we have sufficient memory to store this information. */
if (composition_table_size <= n_compositions)
composition_table = xpalloc (composition_table, &composition_table_size,
1, -1, sizeof *composition_table);
key_contents = XVECTOR (key)->contents;
/* Check if the contents of COMPONENTS are valid if COMPONENTS is a
vector or a list. It should be a sequence of:
char1 rule1 char2 rule2 char3 ... ruleN charN+1 */
if (VECTORP (components)
&& ASIZE (components) >= 2
&& VECTORP (AREF (components, 0)))
{
/* COMPONENTS is a glyph-string. */
ptrdiff_t len = ASIZE (key);
for (i = 1; i < len; i++)
if (! VECTORP (AREF (key, i)))
goto invalid_composition;
}
else if (VECTORP (components) || CONSP (components))
{
ptrdiff_t len = ASIZE (key);
/* The number of elements should be odd. */
if ((len % 2) == 0)
goto invalid_composition;
/* All elements should be integers (character or encoded
composition rule). */
for (i = 0; i < len; i++)
{
if (!INTEGERP (key_contents[i]))
goto invalid_composition;
}
}
/* Change PROP from Form-A above to Form-B. We can directly modify
the cons cell of PROP because it is not shared. */
XSETFASTINT (id, n_compositions);
XSETCAR (prop, id);
XSETCDR (prop, Fcons (make_number (nchars), Fcons (key, XCDR (prop))));
/* Register the composition in composition_hash_table. */
hash_index = hash_put (hash_table, key, id, hash_code);
method = (NILP (components)
? COMPOSITION_RELATIVE
: ((INTEGERP (components) || STRINGP (components))
? COMPOSITION_WITH_ALTCHARS
: COMPOSITION_WITH_RULE_ALTCHARS));
glyph_len = (method == COMPOSITION_WITH_RULE_ALTCHARS
? (ASIZE (key) + 1) / 2
: ASIZE (key));
if (GLYPH_LEN_MAX < glyph_len)
memory_full (SIZE_MAX);
/* Register the composition in composition_table. */
cmp = (struct composition *) xmalloc (sizeof (struct composition));
cmp->method = method;
cmp->hash_index = hash_index;
cmp->glyph_len = glyph_len;
cmp->offsets = xnmalloc (glyph_len, 2 * sizeof *cmp->offsets);
cmp->font = NULL;
if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
{
/* Relative composition. */
cmp->width = 0;
for (i = 0; i < glyph_len; i++)
{
int this_width;
ch = XINT (key_contents[i]);
/* TAB in a composition means display glyphs with padding
space on the left or right. */
this_width = (ch == '\t' ? 1 : CHAR_WIDTH (ch));
if (cmp->width < this_width)
cmp->width = this_width;
}
}
else
{
/* Rule-base composition. */
float leftmost = 0.0, rightmost;
ch = XINT (key_contents[0]);
rightmost = ch != '\t' ? CHAR_WIDTH (ch) : 1;
for (i = 1; i < glyph_len; i += 2)
{
int rule, gref, nref;
int this_width;
float this_left;
rule = XINT (key_contents[i]);
ch = XINT (key_contents[i + 1]);
this_width = ch != '\t' ? CHAR_WIDTH (ch) : 1;
/* A composition rule is specified by an integer value
that encodes global and new reference points (GREF and
NREF). GREF and NREF are specified by numbers as
below:
0---1---2 -- ascent
| |
| |
| |
9--10--11 -- center
| |
---3---4---5--- baseline
| |
6---7---8 -- descent
*/
COMPOSITION_DECODE_REFS (rule, gref, nref);
this_left = (leftmost
+ (gref % 3) * (rightmost - leftmost) / 2.0
- (nref % 3) * this_width / 2.0);
if (this_left < leftmost)
leftmost = this_left;
if (this_left + this_width > rightmost)
rightmost = this_left + this_width;
}
cmp->width = rightmost - leftmost;
if (cmp->width < (rightmost - leftmost))
/* To get a ceiling integer value. */
cmp->width++;
}
composition_table[n_compositions] = cmp;
return n_compositions++;
invalid_composition:
/* Would it be better to remove this `composition' property? */
return -1;
}
/* Find a static composition at or nearest to position POS of OBJECT
(buffer or string).
OBJECT defaults to the current buffer. If there's a composition at
POS, set *START and *END to the start and end of the sequence,
*PROP to the `composition' property, and return 1.
If there's no composition at POS and LIMIT is negative, return 0.
Otherwise, search for a composition forward (LIMIT > POS) or
backward (LIMIT < POS). In this case, LIMIT bounds the search.
If a composition is found, set *START, *END, and *PROP as above,
and return 1, else return 0.
This doesn't check the validity of composition. */
int
find_composition (ptrdiff_t pos, ptrdiff_t limit,
ptrdiff_t *start, ptrdiff_t *end,
Lisp_Object *prop, Lisp_Object object)
{
Lisp_Object val;
if (get_property_and_range (pos, Qcomposition, prop, start, end, object))
return 1;
if (limit < 0 || limit == pos)
return 0;
if (limit > pos) /* search forward */
{
val = Fnext_single_property_change (make_number (pos), Qcomposition,
object, make_number (limit));
pos = XINT (val);
if (pos == limit)
return 0;
}
else /* search backward */
{
if (get_property_and_range (pos - 1, Qcomposition, prop, start, end,
object))
return 1;
val = Fprevious_single_property_change (make_number (pos), Qcomposition,
object, make_number (limit));
pos = XINT (val);
if (pos == limit)
return 0;
pos--;
}
get_property_and_range (pos, Qcomposition, prop, start, end, object);
return 1;
}
/* Run a proper function to adjust the composition sitting between
FROM and TO with property PROP. */
static void
run_composition_function (ptrdiff_t from, ptrdiff_t to, Lisp_Object prop)
{
Lisp_Object func;
ptrdiff_t start, end;
func = COMPOSITION_MODIFICATION_FUNC (prop);
/* If an invalid composition precedes or follows, try to make them
valid too. */
if (from > BEGV
&& find_composition (from - 1, -1, &start, &end, &prop, Qnil)
&& !COMPOSITION_VALID_P (start, end, prop))
from = start;
if (to < ZV
&& find_composition (to, -1, &start, &end, &prop, Qnil)
&& !COMPOSITION_VALID_P (start, end, prop))
to = end;
if (!NILP (Ffboundp (func)))
call2 (func, make_number (from), make_number (to));
}
/* Make invalid compositions adjacent to or inside FROM and TO valid.
CHECK_MASK is bitwise `or' of mask bits defined by macros
CHECK_XXX (see the comment in composite.h).
It also resets the text-property `auto-composed' to a proper region
so that automatic character composition works correctly later while
displaying the region.
This function is called when a buffer text is changed. If the
change is deletion, FROM == TO. Otherwise, FROM < TO. */
void
update_compositions (ptrdiff_t from, ptrdiff_t to, int check_mask)
{
Lisp_Object prop;
ptrdiff_t start, end;
/* The beginning and end of the region to set the property
`auto-composed' to nil. */
ptrdiff_t min_pos = from, max_pos = to;
if (inhibit_modification_hooks)
return;
/* If FROM and TO are not in a valid range, do nothing. */
if (! (BEGV <= from && from <= to && to <= ZV))
return;
if (check_mask & CHECK_HEAD)
{
/* FROM should be at composition boundary. But, insertion or
deletion will make two compositions adjacent and
indistinguishable when they have same (eq) property. To
avoid it, in such a case, we change the property of the
latter to the copy of it. */
if (from > BEGV
&& find_composition (from - 1, -1, &start, &end, &prop, Qnil)
&& COMPOSITION_VALID_P (start, end, prop))
{
min_pos = start;
if (end > to)
max_pos = end;
if (from < end)
Fput_text_property (make_number (from), make_number (end),
Qcomposition,
Fcons (XCAR (prop), XCDR (prop)), Qnil);
run_composition_function (start, end, prop);
from = end;
}
else if (from < ZV
&& find_composition (from, -1, &start, &from, &prop, Qnil)
&& COMPOSITION_VALID_P (start, from, prop))
{
if (from > to)
max_pos = from;
run_composition_function (start, from, prop);
}
}
if (check_mask & CHECK_INSIDE)
{
/* In this case, we are sure that (check & CHECK_TAIL) is also
nonzero. Thus, here we should check only compositions before
(to - 1). */
while (from < to - 1
&& find_composition (from, to, &start, &from, &prop, Qnil)
&& COMPOSITION_VALID_P (start, from, prop)
&& from < to - 1)
run_composition_function (start, from, prop);
}
if (check_mask & CHECK_TAIL)
{
if (from < to
&& find_composition (to - 1, -1, &start, &end, &prop, Qnil)
&& COMPOSITION_VALID_P (start, end, prop))
{
/* TO should be also at composition boundary. But,
insertion or deletion will make two compositions adjacent
and indistinguishable when they have same (eq) property.
To avoid it, in such a case, we change the property of
the former to the copy of it. */
if (to < end)
{
Fput_text_property (make_number (start), make_number (to),
Qcomposition,
Fcons (XCAR (prop), XCDR (prop)), Qnil);
max_pos = end;
}
run_composition_function (start, end, prop);
}
else if (to < ZV
&& find_composition (to, -1, &start, &end, &prop, Qnil)
&& COMPOSITION_VALID_P (start, end, prop))
{
run_composition_function (start, end, prop);
max_pos = end;
}
}
if (min_pos < max_pos)
{
ptrdiff_t count = SPECPDL_INDEX ();
specbind (Qinhibit_read_only, Qt);
specbind (Qinhibit_modification_hooks, Qt);
specbind (Qinhibit_point_motion_hooks, Qt);
Fremove_list_of_text_properties (make_number (min_pos),
make_number (max_pos),
Fcons (Qauto_composed, Qnil), Qnil);
unbind_to (count, Qnil);
}
}
/* Modify composition property values in LIST destructively. LIST is
a list as returned from text_property_list. Change values to the
top-level copies of them so that none of them are `eq'. */
void
make_composition_value_copy (Lisp_Object list)
{
Lisp_Object plist, val;
for (; CONSP (list); list = XCDR (list))
{
plist = XCAR (XCDR (XCDR (XCAR (list))));
while (CONSP (plist) && CONSP (XCDR (plist)))
{
if (EQ (XCAR (plist), Qcomposition)
&& (val = XCAR (XCDR (plist)), CONSP (val)))
XSETCAR (XCDR (plist), Fcons (XCAR (val), XCDR (val)));
plist = XCDR (XCDR (plist));
}
}
}
/* Make text in the region between START and END a composition that
has COMPONENTS and MODIFICATION-FUNC.
If STRING is non-nil, then operate on characters contained between
indices START and END in STRING. */
void
compose_text (ptrdiff_t start, ptrdiff_t end, Lisp_Object components,
Lisp_Object modification_func, Lisp_Object string)
{
Lisp_Object prop;
prop = Fcons (Fcons (make_number (end - start), components),
modification_func);
Fput_text_property (make_number (start), make_number (end),
Qcomposition, prop, string);
}
static Lisp_Object autocmp_chars (Lisp_Object, ptrdiff_t, ptrdiff_t,
ptrdiff_t, struct window *,
struct face *, Lisp_Object);
/* Lisp glyph-string handlers */
/* Hash table for automatic composition. The key is a header of a
lgstring (Lispy glyph-string), and the value is a body of a
lgstring. */
static Lisp_Object gstring_hash_table;
static Lisp_Object gstring_lookup_cache (Lisp_Object);
static Lisp_Object
gstring_lookup_cache (Lisp_Object header)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
ptrdiff_t i = hash_lookup (h, header, NULL);
return (i >= 0 ? HASH_VALUE (h, i) : Qnil);
}
Lisp_Object
composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
EMACS_UINT hash;
Lisp_Object header, copy;
ptrdiff_t i;
header = LGSTRING_HEADER (gstring);
hash = h->hashfn (h, header);
if (len < 0)
{
ptrdiff_t j, glyph_len = LGSTRING_GLYPH_LEN (gstring);
for (j = 0; j < glyph_len; j++)
if (NILP (LGSTRING_GLYPH (gstring, j)))
break;
len = j;
}
lint_assume (len <= TYPE_MAXIMUM (ptrdiff_t) - 2);
copy = Fmake_vector (make_number (len + 2), Qnil);
LGSTRING_SET_HEADER (copy, Fcopy_sequence (header));
for (i = 0; i < len; i++)
LGSTRING_SET_GLYPH (copy, i, Fcopy_sequence (LGSTRING_GLYPH (gstring, i)));
i = hash_put (h, LGSTRING_HEADER (copy), copy, hash);
LGSTRING_SET_ID (copy, make_number (i));
return copy;
}
Lisp_Object
composition_gstring_from_id (ptrdiff_t id)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
return HASH_VALUE (h, id);
}
static Lisp_Object fill_gstring_header (Lisp_Object, Lisp_Object,
Lisp_Object, Lisp_Object,
Lisp_Object);
int
composition_gstring_p (Lisp_Object gstring)
{
Lisp_Object header;
ptrdiff_t i;
if (! VECTORP (gstring) || ASIZE (gstring) < 2)
return 0;
header = LGSTRING_HEADER (gstring);
if (! VECTORP (header) || ASIZE (header) < 2)
return 0;
if (! NILP (LGSTRING_FONT (gstring))
&& (! FONT_OBJECT_P (LGSTRING_FONT (gstring))
&& ! CODING_SYSTEM_P (LGSTRING_FONT (gstring))))
return 0;
for (i = 1; i < ASIZE (LGSTRING_HEADER (gstring)); i++)
if (! NATNUMP (AREF (LGSTRING_HEADER (gstring), i)))
return 0;
if (! NILP (LGSTRING_ID (gstring)) && ! NATNUMP (LGSTRING_ID (gstring)))
return 0;
for (i = 0; i < LGSTRING_GLYPH_LEN (gstring); i++)
{
Lisp_Object glyph = LGSTRING_GLYPH (gstring, i);
if (NILP (glyph))
break;
if (! VECTORP (glyph) || ASIZE (glyph) != LGLYPH_SIZE)
return 0;
}
return 1;
}
int
composition_gstring_width (Lisp_Object gstring, ptrdiff_t from, ptrdiff_t to,
struct font_metrics *metrics)
{
Lisp_Object *glyph;
int width = 0;
if (metrics)
{
Lisp_Object font_object = LGSTRING_FONT (gstring);
if (FONT_OBJECT_P (font_object))
{
struct font *font = XFONT_OBJECT (font_object);
metrics->ascent = font->ascent;
metrics->descent = font->descent;
}
else
{
metrics->ascent = 1;
metrics->descent = 0;
}
metrics->width = metrics->lbearing = metrics->rbearing = 0;
}
for (glyph = &LGSTRING_GLYPH (gstring, from); from < to; from++, glyph++)
{
int x;
if (NILP (LGLYPH_ADJUSTMENT (*glyph)))
width += LGLYPH_WIDTH (*glyph);
else
width += LGLYPH_WADJUST (*glyph);
if (metrics)
{
x = metrics->width + LGLYPH_LBEARING (*glyph) + LGLYPH_XOFF (*glyph);
if (metrics->lbearing > x)
metrics->lbearing = x;
x = metrics->width + LGLYPH_RBEARING (*glyph) + LGLYPH_XOFF (*glyph);
if (metrics->rbearing < x)
metrics->rbearing = x;
metrics->width = width;
x = LGLYPH_ASCENT (*glyph) - LGLYPH_YOFF (*glyph);
if (metrics->ascent < x)
metrics->ascent = x;
x = LGLYPH_DESCENT (*glyph) + LGLYPH_YOFF (*glyph);
if (metrics->descent < x)
metrics->descent = x;
}
}
return width;
}
static Lisp_Object gstring_work;
static Lisp_Object gstring_work_headers;
static Lisp_Object
fill_gstring_header (Lisp_Object header, Lisp_Object start, Lisp_Object end, Lisp_Object font_object, Lisp_Object string)
{
ptrdiff_t from, to, from_byte;
ptrdiff_t len, i;
if (NILP (string))
{
if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
error ("Attempt to shape unibyte text");
validate_region (&start, &end);
from = XFASTINT (start);
to = XFASTINT (end);
from_byte = CHAR_TO_BYTE (from);
}
else
{
CHECK_STRING (string);
if (! STRING_MULTIBYTE (string))
error ("Attempt to shape unibyte text");
/* The caller checks that START and END are nonnegative integers. */
if (! (XINT (start) <= XINT (end) && XINT (end) <= SCHARS (string)))
args_out_of_range_3 (string, start, end);
from = XINT (start);
to = XINT (end);
from_byte = string_char_to_byte (string, from);
}
len = to - from;
if (len == 0)
error ("Attempt to shape zero-length text");
if (VECTORP (header))
{
if (ASIZE (header) != len + 1)
args_out_of_range (header, make_number (len + 1));
}
else
{
if (len <= 8)
header = AREF (gstring_work_headers, len - 1);
else
header = Fmake_vector (make_number (len + 1), Qnil);
}
ASET (header, 0, font_object);
for (i = 0; i < len; i++)
{
int c;
if (NILP (string))
FETCH_CHAR_ADVANCE_NO_CHECK (c, from, from_byte);
else
FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, string, from, from_byte);
ASET (header, i + 1, make_number (c));
}
return header;
}
static void
fill_gstring_body (Lisp_Object gstring)
{
Lisp_Object font_object = LGSTRING_FONT (gstring);
Lisp_Object header = AREF (gstring, 0);
ptrdiff_t len = LGSTRING_CHAR_LEN (gstring);
ptrdiff_t i;
for (i = 0; i < len; i++)
{
Lisp_Object g = LGSTRING_GLYPH (gstring, i);
int c = XFASTINT (AREF (header, i + 1));
if (NILP (g))
{
g = LGLYPH_NEW ();
LGSTRING_SET_GLYPH (gstring, i, g);
}
LGLYPH_SET_FROM (g, i);
LGLYPH_SET_TO (g, i);
LGLYPH_SET_CHAR (g, c);
if (FONT_OBJECT_P (font_object))
{
font_fill_lglyph_metrics (g, font_object);
}
else
{
int width = XFASTINT (CHAR_TABLE_REF (Vchar_width_table, c));
LGLYPH_SET_CODE (g, c);
LGLYPH_SET_LBEARING (g, 0);
LGLYPH_SET_RBEARING (g, width);
LGLYPH_SET_WIDTH (g, width);
LGLYPH_SET_ASCENT (g, 1);
LGLYPH_SET_DESCENT (g, 0);
}
LGLYPH_SET_ADJUSTMENT (g, Qnil);
}
if (i < LGSTRING_GLYPH_LEN (gstring))
LGSTRING_SET_GLYPH (gstring, i, Qnil);
}
/* Try to compose the characters at CHARPOS according to composition
rule RULE ([PATTERN PREV-CHARS FUNC]). LIMIT limits the characters
to compose. STRING, if not nil, is a target string. WIN is a
window where the characters are being displayed. If characters are
successfully composed, return the composition as a glyph-string
object. Otherwise return nil. */
static Lisp_Object
autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t limit, struct window *win, struct face *face, Lisp_Object string)
{
ptrdiff_t count = SPECPDL_INDEX ();
FRAME_PTR f = XFRAME (win->frame);
Lisp_Object pos = make_number (charpos);
ptrdiff_t to;
ptrdiff_t pt = PT, pt_byte = PT_BYTE;
Lisp_Object re, font_object, lgstring;
ptrdiff_t len;
record_unwind_save_match_data ();
re = AREF (rule, 0);
if (NILP (re))
len = 1;
else if (! STRINGP (re))
return unbind_to (count, Qnil);
else if ((len = fast_looking_at (re, charpos, bytepos, limit, -1, string))
> 0)
{
if (NILP (string))
len = BYTE_TO_CHAR (bytepos + len) - charpos;
else
len = string_byte_to_char (string, bytepos + len) - charpos;
}
if (len <= 0)
return unbind_to (count, Qnil);
to = limit = charpos + len;
#ifdef HAVE_WINDOW_SYSTEM
if (FRAME_WINDOW_P (f))
{
font_object = font_range (charpos, &to, win, face, string);
if (! FONT_OBJECT_P (font_object)
|| (! NILP (re)
&& to < limit
&& (fast_looking_at (re, charpos, bytepos, to, -1, string) <= 0)))
return unbind_to (count, Qnil);
}
else
#endif /* not HAVE_WINDOW_SYSTEM */
font_object = win->frame;
lgstring = Fcomposition_get_gstring (pos, make_number (to), font_object,
string);
if (NILP (LGSTRING_ID (lgstring)))
{
Lisp_Object args[6];
/* Save point as marker before calling out to lisp. */
if (NILP (string))
{
Lisp_Object m = Fmake_marker ();
set_marker_both (m, Qnil, pt, pt_byte);
record_unwind_protect (restore_point_unwind, m);
}
args[0] = Vauto_composition_function;
args[1] = AREF (rule, 2);
args[2] = pos;
args[3] = make_number (to);
args[4] = font_object;
args[5] = string;
lgstring = safe_call (6, args);
}
return unbind_to (count, lgstring);
}
static Lisp_Object _work_val;
/* 1 iff the character C is composable. Characters of general
category Z? or C? are not composable except for ZWNJ and ZWJ. */
#define CHAR_COMPOSABLE_P(C) \
((C) > ' ' \
&& ((C) == 0x200C || (C) == 0x200D \
|| (_work_val = CHAR_TABLE_REF (Vunicode_category_table, (C)), \
(INTEGERP (_work_val) \
&& (XINT (_work_val) <= UNICODE_CATEGORY_So)))))
/* Update cmp_it->stop_pos to the next position after CHARPOS (and
BYTEPOS) where character composition may happen. If BYTEPOS is
negative, compute it. ENDPOS is a limit of searching. If it is
less than CHARPOS, search backward to ENDPOS+1 assuming that
set_iterator_to_next works in reverse order. In this case, if a
composition closest to CHARPOS is found, set cmp_it->stop_pos to
the last character of the composition.
If no composition is found, set cmp_it->ch to -2. If a static
composition is found, set cmp_it->ch to -1. Otherwise, set
cmp_it->ch to the character that triggers the automatic
composition. */
void
composition_compute_stop_pos (struct composition_it *cmp_it, ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t endpos, Lisp_Object string)
{
ptrdiff_t start, end;
int c;
Lisp_Object prop, val;
/* This is from forward_to_next_line_start in xdisp.c. */
const int MAX_NEWLINE_DISTANCE = 500;
if (charpos < endpos)
{
if (endpos > charpos + MAX_NEWLINE_DISTANCE)
endpos = charpos + MAX_NEWLINE_DISTANCE;
}
else if (endpos < charpos)
{
/* We search backward for a position to check composition. */
if (endpos < 0)
{
/* But we don't know where to stop the searching. */
endpos = NILP (string) ? BEGV - 1 : -1;
/* Usually we don't reach ENDPOS because we stop searching
at an uncomposable character (NL, LRE, etc). */
}
}
cmp_it->id = -1;
cmp_it->ch = -2;
cmp_it->reversed_p = 0;
cmp_it->stop_pos = endpos;
if (charpos == endpos)
return;
/* FIXME: Bidi is not yet handled well in static composition. */
if (charpos < endpos
&& find_composition (charpos, endpos, &start, &end, &prop, string)
&& start >= charpos
&& COMPOSITION_VALID_P (start, end, prop))
{
cmp_it->stop_pos = endpos = start;
cmp_it->ch = -1;
}
if (NILP (BVAR (current_buffer, enable_multibyte_characters))
|| NILP (Vauto_composition_mode))
return;
if (bytepos < 0)
{
if (NILP (string))
bytepos = CHAR_TO_BYTE (charpos);
else
bytepos = string_char_to_byte (string, charpos);
}
start = charpos;
if (charpos < endpos)
{
/* Forward search. */
while (charpos < endpos)
{
if (STRINGP (string))
FETCH_STRING_CHAR_ADVANCE (c, string, charpos, bytepos);
else
FETCH_CHAR_ADVANCE (c, charpos, bytepos);
if (c == '\n')
{
cmp_it->ch = -2;
break;
}
val = CHAR_TABLE_REF (Vcomposition_function_table, c);
if (! NILP (val))
{
Lisp_Object elt;
int ridx;
for (ridx = 0; CONSP (val); val = XCDR (val), ridx++)
{
elt = XCAR (val);
if (VECTORP (elt) && ASIZE (elt) == 3
&& NATNUMP (AREF (elt, 1))
&& charpos - 1 - XFASTINT (AREF (elt, 1)) >= start)
break;
}
if (CONSP (val))
{
cmp_it->rule_idx = ridx;
cmp_it->lookback = XFASTINT (AREF (elt, 1));
cmp_it->stop_pos = charpos - 1 - cmp_it->lookback;
cmp_it->ch = c;
return;
}
}
}
if (charpos == endpos)
{
/* We couldn't find a composition point before ENDPOS. But,
some character after ENDPOS may be composed with
characters before ENDPOS. So, we should stop at the safe
point. */
charpos = endpos - MAX_AUTO_COMPOSITION_LOOKBACK;
if (charpos < start)
charpos = start;
}
}
else if (charpos > endpos)
{
/* Search backward for a pattern that may be composed and the
position of (possibly) the last character of the match is
closest to (but not after) START. The reason for the last
character is that set_iterator_to_next works in reverse order,
and thus we must stop at the last character for composition
check. */
unsigned char *p;
int len;
/* Limit byte position used in fast_looking_at. This is the
byte position of the character after START. */
ptrdiff_t limit;
if (NILP (string))
p = BYTE_POS_ADDR (bytepos);
else
p = SDATA (string) + bytepos;
c = STRING_CHAR_AND_LENGTH (p, len);
limit = bytepos + len;
while (CHAR_COMPOSABLE_P (c))
{
val = CHAR_TABLE_REF (Vcomposition_function_table, c);
if (! NILP (val))
{
Lisp_Object elt;
int ridx, blen;
for (ridx = 0; CONSP (val); val = XCDR (val), ridx++)
{
elt = XCAR (val);
if (VECTORP (elt) && ASIZE (elt) == 3
&& NATNUMP (AREF (elt, 1))
&& charpos - XFASTINT (AREF (elt, 1)) > endpos)
{
ptrdiff_t back = XFASTINT (AREF (elt, 1));
ptrdiff_t cpos = charpos - back, bpos;
if (back == 0)
bpos = bytepos;
else
bpos = (NILP (string) ? CHAR_TO_BYTE (cpos)
: string_char_to_byte (string, cpos));
if (STRINGP (AREF (elt, 0)))
blen = fast_looking_at (AREF (elt, 0), cpos, bpos,
start + 1, limit, string);
else
blen = 1;
if (blen > 0)
{
/* Make CPOS point to the last character of
match. Note that BLEN is byte-length. */
if (blen > 1)
{
bpos += blen;
if (NILP (string))
cpos = BYTE_TO_CHAR (bpos) - 1;
else
cpos = string_byte_to_char (string, bpos) - 1;
}
back = cpos - (charpos - back);
if (cmp_it->stop_pos < cpos
|| (cmp_it->stop_pos == cpos
&& cmp_it->lookback < back))
{
cmp_it->rule_idx = ridx;
cmp_it->stop_pos = cpos;
cmp_it->ch = c;
cmp_it->lookback = back;
cmp_it->nchars = back + 1;
}
}
}
}
}
if (charpos - 1 == endpos)
break;
if (STRINGP (string))
{
p--, bytepos--;
while (! CHAR_HEAD_P (*p))
p--, bytepos--;
charpos--;
}
else
{
DEC_BOTH (charpos, bytepos);
p = BYTE_POS_ADDR (bytepos);
}
c = STRING_CHAR (p);
}
if (cmp_it->ch >= 0)
/* We found a position to check. */
return;
/* Skip all uncomposable characters. */
if (NILP (string))
{
while (charpos - 1 > endpos && ! CHAR_COMPOSABLE_P (c))
{
DEC_BOTH (charpos, bytepos);
c = FETCH_MULTIBYTE_CHAR (bytepos);
}
}
else
{
while (charpos - 1 > endpos && ! CHAR_COMPOSABLE_P (c))
{
p--;
while (! CHAR_HEAD_P (*p))
p--;
charpos--;
c = STRING_CHAR (p);
}
}
}
cmp_it->stop_pos = charpos;
}
/* Check if the character at CHARPOS (and BYTEPOS) is composed
(possibly with the following characters) on window W. ENDPOS limits
characters to be composed. FACE, in non-NULL, is a base face of
the character. If STRING is not nil, it is a string containing the
character to check, and CHARPOS and BYTEPOS are indices in the
string. In that case, FACE must not be NULL.
If the character is composed, setup members of CMP_IT (id, nglyphs,
from, to, reversed_p), and return 1. Otherwise, update
CMP_IT->stop_pos, and return 0. */
int
composition_reseat_it (struct composition_it *cmp_it, ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t endpos, struct window *w, struct face *face, Lisp_Object string)
{
if (endpos < 0)
endpos = NILP (string) ? BEGV : 0;
if (cmp_it->ch == -2)
{
composition_compute_stop_pos (cmp_it, charpos, bytepos, endpos, string);
if (cmp_it->ch == -2 || cmp_it->stop_pos != charpos)
/* The current position is not composed. */
return 0;
}
if (cmp_it->ch < 0)
{
/* We are looking at a static composition. */
ptrdiff_t start, end;
Lisp_Object prop;
find_composition (charpos, -1, &start, &end, &prop, string);
cmp_it->id = get_composition_id (charpos, bytepos, end - start,
prop, string);
if (cmp_it->id < 0)
goto no_composition;
cmp_it->nchars = end - start;
cmp_it->nglyphs = composition_table[cmp_it->id]->glyph_len;
}
else if (w)
{
Lisp_Object lgstring = Qnil;
Lisp_Object val, elt;
ptrdiff_t i;
val = CHAR_TABLE_REF (Vcomposition_function_table, cmp_it->ch);
for (i = 0; i < cmp_it->rule_idx; i++, val = XCDR (val));
if (charpos < endpos)
{
for (; CONSP (val); val = XCDR (val))
{
elt = XCAR (val);
if (! VECTORP (elt) || ASIZE (elt) != 3
|| ! INTEGERP (AREF (elt, 1)))
continue;
if (XFASTINT (AREF (elt, 1)) != cmp_it->lookback)
goto no_composition;
lgstring = autocmp_chars (elt, charpos, bytepos, endpos,
w, face, string);
if (composition_gstring_p (lgstring))
break;
lgstring = Qnil;
/* Composition failed perhaps because the font doesn't
support sufficient range of characters. Try the
other composition rules if any. */
}
cmp_it->reversed_p = 0;
}
else
{
ptrdiff_t cpos = charpos, bpos = bytepos;
while (1)
{
elt = XCAR (val);
if (cmp_it->lookback > 0)
{
cpos = charpos - cmp_it->lookback;
if (STRINGP (string))
bpos = string_char_to_byte (string, cpos);
else
bpos = CHAR_TO_BYTE (cpos);
}
lgstring = autocmp_chars (elt, cpos, bpos, charpos + 1, w, face,
string);
if (composition_gstring_p (lgstring)
&& cpos + LGSTRING_CHAR_LEN (lgstring) - 1 == charpos)
break;
/* Composition failed or didn't cover the current
character. */
if (cmp_it->lookback == 0)
goto no_composition;
lgstring = Qnil;
/* Try to find a shorter compostion that starts after CPOS. */
composition_compute_stop_pos (cmp_it, charpos, bytepos, cpos,
string);
if (cmp_it->ch == -2 || cmp_it->stop_pos < charpos)
goto no_composition;
val = CHAR_TABLE_REF (Vcomposition_function_table, cmp_it->ch);
for (i = 0; i < cmp_it->rule_idx; i++, val = XCDR (val));
}
cmp_it->reversed_p = 1;
}
if (NILP (lgstring))
goto no_composition;
if (NILP (LGSTRING_ID (lgstring)))
lgstring = composition_gstring_put_cache (lgstring, -1);
cmp_it->id = XINT (LGSTRING_ID (lgstring));
for (i = 0; i < LGSTRING_GLYPH_LEN (lgstring); i++)
if (NILP (LGSTRING_GLYPH (lgstring, i)))
break;
cmp_it->nglyphs = i;
cmp_it->from = 0;
cmp_it->to = i;
}
else
goto no_composition;
return 1;
no_composition:
if (charpos == endpos)
return 0;
if (charpos < endpos)
{
charpos++;
if (NILP (string))
INC_POS (bytepos);
else
bytepos += BYTES_BY_CHAR_HEAD (*(SDATA (string) + bytepos));
}
else
{
charpos--;
/* BYTEPOS is calculated in composition_compute_stop_pos */
bytepos = -1;
}
composition_compute_stop_pos (cmp_it, charpos, bytepos, endpos, string);
return 0;
}
/* Update charpos, nchars, nbytes, and width of the current grapheme
cluster.
If the composition is static or automatic in L2R context, the
cluster is identified by CMP_IT->from, and CHARPOS is the position
of the first character of the cluster. In this case, update
CMP_IT->to too.
If the composition is automatic in R2L context, the cluster is
identified by CMP_IT->to, and CHARPOS is the position of the last
character of the cluster. In this case, update CMP_IT->from too.
The return value is the character code of the first character of
the cluster, or -1 if the composition is somehow broken. */
int
composition_update_it (struct composition_it *cmp_it, ptrdiff_t charpos, ptrdiff_t bytepos, Lisp_Object string)
{
int i, c IF_LINT (= 0);
if (cmp_it->ch < 0)
{
/* static composition */
struct composition *cmp = composition_table[cmp_it->id];
cmp_it->charpos = charpos;
cmp_it->to = cmp_it->nglyphs;
if (cmp_it->nglyphs == 0)
c = -1;
else
{
for (i = 0; i < cmp->glyph_len; i++)
/* TAB in a composition means display glyphs with padding
space on the left or right. */
if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
break;
if (c == '\t')
c = ' ';
}
cmp_it->width = cmp->width;
charpos += cmp_it->nchars;
if (STRINGP (string))
cmp_it->nbytes = string_char_to_byte (string, charpos) - bytepos;
else
cmp_it->nbytes = CHAR_TO_BYTE (charpos) - bytepos;
}
else
{
/* automatic composition */
Lisp_Object gstring = composition_gstring_from_id (cmp_it->id);
Lisp_Object glyph;
ptrdiff_t from;
if (cmp_it->nglyphs == 0)
{
cmp_it->nchars = LGSTRING_CHAR_LEN (gstring);
cmp_it->width = 0;
cmp_it->from = cmp_it->to = 0;
return -1;
}
if (! cmp_it->reversed_p)
{
glyph = LGSTRING_GLYPH (gstring, cmp_it->from);
from = LGLYPH_FROM (glyph);
for (cmp_it->to = cmp_it->from + 1; cmp_it->to < cmp_it->nglyphs;
cmp_it->to++)
{
glyph = LGSTRING_GLYPH (gstring, cmp_it->to);
if (LGLYPH_FROM (glyph) != from)
break;
}
cmp_it->charpos = charpos;
}
else
{
glyph = LGSTRING_GLYPH (gstring, cmp_it->to - 1);
from = LGLYPH_FROM (glyph);
cmp_it->charpos = charpos - (LGLYPH_TO (glyph) - from);
for (cmp_it->from = cmp_it->to - 1; cmp_it->from > 0;
cmp_it->from--)
{
glyph = LGSTRING_GLYPH (gstring, cmp_it->from - 1);
if (LGLYPH_FROM (glyph) != from)
break;
}
}
glyph = LGSTRING_GLYPH (gstring, cmp_it->from);
cmp_it->nchars = LGLYPH_TO (glyph) + 1 - from;
cmp_it->nbytes = 0;
cmp_it->width = 0;
for (i = cmp_it->nchars - 1; i >= 0; i--)
{
c = XINT (LGSTRING_CHAR (gstring, i));
cmp_it->nbytes += CHAR_BYTES (c);
cmp_it->width += CHAR_WIDTH (c);
}
}
return c;
}
struct position_record
{
ptrdiff_t pos, pos_byte;
unsigned char *p;
};
/* Update the members of POSITION to the next character boundary. */
#define FORWARD_CHAR(POSITION, STOP) \
do { \
(POSITION).pos++; \
if ((POSITION).pos == (STOP)) \
{ \
(POSITION).p = GAP_END_ADDR; \
(POSITION).pos_byte = GPT_BYTE; \
} \
else \
{ \
(POSITION).pos_byte += BYTES_BY_CHAR_HEAD (*((POSITION).p)); \
(POSITION).p += BYTES_BY_CHAR_HEAD (*((POSITION).p)); \
} \
} while (0)
/* Update the members of POSITION to the previous character boundary. */
#define BACKWARD_CHAR(POSITION, STOP) \
do { \
if ((POSITION).pos == (STOP)) \
(POSITION).p = GPT_ADDR; \
do { \
(POSITION).pos_byte--; \
(POSITION).p--; \
} while (! CHAR_HEAD_P (*((POSITION).p))); \
(POSITION).pos--; \
} while (0)
/* This is like find_composition, but find an automatic composition
instead. It is assured that POS is not within a static
composition. If found, set *GSTRING to the glyph-string
representing the composition, and return 1. Otherwise, *GSTRING to
Qnil, and return 0. */
static int
find_automatic_composition (ptrdiff_t pos, ptrdiff_t limit,
ptrdiff_t *start, ptrdiff_t *end,
Lisp_Object *gstring, Lisp_Object string)
{
ptrdiff_t head, tail, stop;
/* Forward limit position of checking a composition taking a
looking-back count into account. */
ptrdiff_t fore_check_limit;
struct position_record cur, prev;
int c;
Lisp_Object window;
struct window *w;
int need_adjustment = 0;
window = Fget_buffer_window (Fcurrent_buffer (), Qnil);
if (NILP (window))
return 0;
w = XWINDOW (window);
cur.pos = pos;
if (NILP (string))
{
head = BEGV, tail = ZV, stop = GPT;
cur.pos_byte = CHAR_TO_BYTE (cur.pos);
cur.p = BYTE_POS_ADDR (cur.pos_byte);
}
else
{
head = 0, tail = SCHARS (string), stop = -1;
cur.pos_byte = string_char_to_byte (string, cur.pos);
cur.p = SDATA (string) + cur.pos_byte;
}
if (limit < 0)
/* Finding a composition covering the character after POS is the
same as setting LIMIT to POS. */
limit = pos;
if (limit <= pos)
fore_check_limit = min (tail, pos + 1 + MAX_AUTO_COMPOSITION_LOOKBACK);
else
fore_check_limit = min (tail, limit + MAX_AUTO_COMPOSITION_LOOKBACK);
/* Provided that we have these possible compositions now:
POS: 1 2 3 4 5 6 7 8 9
|-A-|
|-B-|-C-|--D--|
Here, it is known that characters after positions 1 and 9 can
never be composed (i.e. ! CHAR_COMPOSABLE_P (CH)), and
composition A is an invalid one because it's partially covered by
the valid composition C. And to know whether a composition is
valid or not, the only way is to start searching forward from a
position that can not be a tail part of composition (it's 2 in
the above case).
Now we have these cases (1 through 4):
-- character after POS is ... --
not composable composable
LIMIT <= POS (1) (3)
POS < LIMIT (2) (4)
Among them, in case (2), we simply search forward from POS.
In the other cases, we at first rewind back to the position where
the previous character is not composable or the beginning of
buffer (string), then search compositions forward. In case (1)
and (3) we repeat this process until a composition is found. */
while (1)
{
c = STRING_CHAR (cur.p);
if (! CHAR_COMPOSABLE_P (c))
{
if (limit <= pos) /* case (1) */
{
do {
if (cur.pos <= limit)
return 0;
BACKWARD_CHAR (cur, stop);
c = STRING_CHAR (cur.p);
} while (! CHAR_COMPOSABLE_P (c));
fore_check_limit = cur.pos + 1;
}
else /* case (2) */
/* No need of rewinding back. */
goto search_forward;
}
/* Rewind back to the position where we can safely search
forward for compositions. It is assured that the character
at cur.pos is composable. */
while (head < cur.pos)
{
prev = cur;
BACKWARD_CHAR (cur, stop);
c = STRING_CHAR (cur.p);
if (! CHAR_COMPOSABLE_P (c))
{
cur = prev;
break;
}
}
search_forward:
/* Now search forward. */
*gstring = Qnil;
prev = cur; /* remember the start of searching position. */
while (cur.pos < fore_check_limit)
{
Lisp_Object val;
c = STRING_CHAR (cur.p);
for (val = CHAR_TABLE_REF (Vcomposition_function_table, c);
CONSP (val); val = XCDR (val))
{
Lisp_Object elt = XCAR (val);
if (VECTORP (elt) && ASIZE (elt) == 3 && NATNUMP (AREF (elt, 1)))
{
EMACS_INT check_pos = cur.pos - XFASTINT (AREF (elt, 1));
struct position_record check;
if (check_pos < head
|| (limit <= pos ? pos < check_pos
: limit <= check_pos))
continue;
for (check = cur; check_pos < check.pos; )
BACKWARD_CHAR (check, stop);
*gstring = autocmp_chars (elt, check.pos, check.pos_byte,
tail, w, NULL, string);
need_adjustment = 1;
if (NILP (*gstring))
{
/* As we have called Lisp, there's a possibility
that buffer/string is relocated. */
if (NILP (string))
cur.p = BYTE_POS_ADDR (cur.pos_byte);
else
cur.p = SDATA (string) + cur.pos_byte;
}
else
{
/* We found a candidate of a target composition. */
*start = check.pos;
*end = check.pos + LGSTRING_CHAR_LEN (*gstring);
if (pos < limit
? pos < *end
: *start <= pos && pos < *end)
/* This is the target composition. */
return 1;
cur.pos = *end;
if (NILP (string))
{
cur.pos_byte = CHAR_TO_BYTE (cur.pos);
cur.p = BYTE_POS_ADDR (cur.pos_byte);
}
else
{
cur.pos_byte = string_char_to_byte (string, cur.pos);
cur.p = SDATA (string) + cur.pos_byte;
}
break;
}
}
}
if (! CONSP (val))
/* We found no composition here. */
FORWARD_CHAR (cur, stop);
}
if (pos < limit) /* case (2) and (4)*/
return 0;
if (! NILP (*gstring))
return 1;
if (prev.pos == head)
return 0;
cur = prev;
if (need_adjustment)
{
if (NILP (string))
cur.p = BYTE_POS_ADDR (cur.pos_byte);
else
cur.p = SDATA (string) + cur.pos_byte;
}
BACKWARD_CHAR (cur, stop);
}
}
/* Return the adjusted point provided that point is moved from LAST_PT
to NEW_PT. */
ptrdiff_t
composition_adjust_point (ptrdiff_t last_pt, ptrdiff_t new_pt)
{
ptrdiff_t i, beg, end;
Lisp_Object val;
if (new_pt == BEGV || new_pt == ZV)
return new_pt;
/* At first check the static composition. */
if (get_property_and_range (new_pt, Qcomposition, &val, &beg, &end, Qnil)
&& COMPOSITION_VALID_P (beg, end, val))
{
if (beg < new_pt /* && end > new_pt <- It's always the case. */
&& (last_pt <= beg || last_pt >= end))
return (new_pt < last_pt ? beg : end);
return new_pt;
}
if (NILP (BVAR (current_buffer, enable_multibyte_characters))
|| NILP (Vauto_composition_mode))
return new_pt;
/* Next check the automatic composition. */
if (! find_automatic_composition (new_pt, (ptrdiff_t) -1, &beg, &end, &val,
Qnil)
|| beg == new_pt)
return new_pt;
for (i = 0; i < LGSTRING_GLYPH_LEN (val); i++)
{
Lisp_Object glyph = LGSTRING_GLYPH (val, i);
if (NILP (glyph))
break;
if (beg + LGLYPH_FROM (glyph) == new_pt)
return new_pt;
if (beg + LGLYPH_TO (glyph) >= new_pt)
return (new_pt < last_pt
? beg + LGLYPH_FROM (glyph)
: beg + LGLYPH_TO (glyph) + 1);
}
return new_pt;
}
DEFUN ("composition-get-gstring", Fcomposition_get_gstring,
Scomposition_get_gstring, 4, 4, 0,
doc: /* Return a glyph-string for characters between FROM and TO.
If the glyph string is for graphic display, FONT-OBJECT must be
a font-object to use for those characters.
Otherwise (for terminal display), FONT-OBJECT must be a terminal ID, a
frame, or nil for the selected frame's terminal device.
If the optional 4th argument STRING is not nil, it is a string
containing the target characters between indices FROM and TO.
A glyph-string is a vector containing information about how to display
a specific character sequence. The format is:
[HEADER ID GLYPH ...]
HEADER is a vector of this form:
[FONT-OBJECT CHAR ...]
where
FONT-OBJECT is a font-object for all glyphs in the glyph-string,
or the terminal coding system of the specified terminal.
CHARs are characters to be composed by GLYPHs.
ID is an identification number of the glyph-string. It may be nil if
not yet shaped.
GLYPH is a vector whose elements have this form:
[ FROM-IDX TO-IDX C CODE WIDTH LBEARING RBEARING ASCENT DESCENT
[ [X-OFF Y-OFF WADJUST] | nil] ]
where
FROM-IDX and TO-IDX are used internally and should not be touched.
C is the character of the glyph.
CODE is the glyph-code of C in FONT-OBJECT.
WIDTH thru DESCENT are the metrics (in pixels) of the glyph.
X-OFF and Y-OFF are offsets to the base position for the glyph.
WADJUST is the adjustment to the normal width of the glyph.
If GLYPH is nil, the remaining elements of the glyph-string vector
should be ignored. */)
(Lisp_Object from, Lisp_Object to, Lisp_Object font_object, Lisp_Object string)
{
Lisp_Object gstring, header;
ptrdiff_t frompos, topos;
CHECK_NATNUM (from);
CHECK_NATNUM (to);
if (! FONT_OBJECT_P (font_object))
{
struct coding_system *coding;
struct terminal *terminal = get_terminal (font_object, 1);
coding = ((TERMINAL_TERMINAL_CODING (terminal)->common_flags
& CODING_REQUIRE_ENCODING_MASK)
? TERMINAL_TERMINAL_CODING (terminal) : &safe_terminal_coding);
font_object = CODING_ID_NAME (coding->id);
}
header = fill_gstring_header (Qnil, from, to, font_object, string);
gstring = gstring_lookup_cache (header);
if (! NILP (gstring))
return gstring;
frompos = XINT (from);
topos = XINT (to);
if (LGSTRING_GLYPH_LEN (gstring_work) < topos - frompos)
gstring_work = Fmake_vector (make_number (topos - frompos + 2), Qnil);
LGSTRING_SET_HEADER (gstring_work, header);
LGSTRING_SET_ID (gstring_work, Qnil);
fill_gstring_body (gstring_work);
return gstring_work;
}
/* Emacs Lisp APIs. */
DEFUN ("compose-region-internal", Fcompose_region_internal,
Scompose_region_internal, 2, 4, 0,
doc: /* Internal use only.
Compose text in the region between START and END.
Optional 3rd and 4th arguments are COMPONENTS and MODIFICATION-FUNC
for the composition. See `compose-region' for more details. */)
(Lisp_Object start, Lisp_Object end, Lisp_Object components, Lisp_Object modification_func)
{
validate_region (&start, &end);
if (!NILP (components)
&& !INTEGERP (components)
&& !CONSP (components)
&& !STRINGP (components))
CHECK_VECTOR (components);
compose_text (XINT (start), XINT (end), components, modification_func, Qnil);
return Qnil;
}
DEFUN ("compose-string-internal", Fcompose_string_internal,
Scompose_string_internal, 3, 5, 0,
doc: /* Internal use only.
Compose text between indices START and END of STRING.
Optional 4th and 5th arguments are COMPONENTS and MODIFICATION-FUNC
for the composition. See `compose-string' for more details. */)
(Lisp_Object string, Lisp_Object start, Lisp_Object end, Lisp_Object components, Lisp_Object modification_func)
{
CHECK_STRING (string);
CHECK_NUMBER (start);
CHECK_NUMBER (end);
if (XINT (start) < 0 ||
XINT (start) > XINT (end)
|| XINT (end) > SCHARS (string))
args_out_of_range (start, end);
compose_text (XINT (start), XINT (end), components, modification_func, string);
return string;
}
DEFUN ("find-composition-internal", Ffind_composition_internal,
Sfind_composition_internal, 4, 4, 0,
doc: /* Internal use only.
Return information about composition at or nearest to position POS.
See `find-composition' for more details. */)
(Lisp_Object pos, Lisp_Object limit, Lisp_Object string, Lisp_Object detail_p)
{
Lisp_Object prop, tail, gstring;
ptrdiff_t start, end, from, to;
int id;
CHECK_NUMBER_COERCE_MARKER (pos);
if (!NILP (limit))
{
CHECK_NUMBER_COERCE_MARKER (limit);
to = min (XINT (limit), ZV);
}
else
to = -1;
if (!NILP (string))
{
CHECK_STRING (string);
if (XINT (pos) < 0 || XINT (pos) > SCHARS (string))
args_out_of_range (string, pos);
}
else
{
if (XINT (pos) < BEGV || XINT (pos) > ZV)
args_out_of_range (Fcurrent_buffer (), pos);
}
from = XINT (pos);
if (!find_composition (from, to, &start, &end, &prop, string))
{
if (!NILP (BVAR (current_buffer, enable_multibyte_characters))
&& ! NILP (Vauto_composition_mode)
&& find_automatic_composition (from, to, &start, &end, &gstring,
string))
return list3 (make_number (start), make_number (end), gstring);
return Qnil;
}
if ((end <= XINT (pos) || start > XINT (pos)))
{
ptrdiff_t s, e;
if (find_automatic_composition (from, to, &s, &e, &gstring, string)
&& (e <= XINT (pos) ? e > end : s < start))
return list3 (make_number (s), make_number (e), gstring);
}
if (!COMPOSITION_VALID_P (start, end, prop))
return Fcons (make_number (start), Fcons (make_number (end),
Fcons (Qnil, Qnil)));
if (NILP (detail_p))
return Fcons (make_number (start), Fcons (make_number (end),
Fcons (Qt, Qnil)));
if (COMPOSITION_REGISTERD_P (prop))
id = COMPOSITION_ID (prop);
else
{
ptrdiff_t start_byte = (NILP (string)
? CHAR_TO_BYTE (start)
: string_char_to_byte (string, start));
id = get_composition_id (start, start_byte, end - start, prop, string);
}
if (id >= 0)
{
Lisp_Object components, relative_p, mod_func;
enum composition_method method = COMPOSITION_METHOD (prop);
int width = composition_table[id]->width;
components = Fcopy_sequence (COMPOSITION_COMPONENTS (prop));
relative_p = (method == COMPOSITION_WITH_RULE_ALTCHARS
? Qnil : Qt);
mod_func = COMPOSITION_MODIFICATION_FUNC (prop);
tail = Fcons (components,
Fcons (relative_p,
Fcons (mod_func,
Fcons (make_number (width), Qnil))));
}
else
tail = Qnil;
return Fcons (make_number (start), Fcons (make_number (end), tail));
}
void
syms_of_composite (void)
{
int i;
DEFSYM (Qcomposition, "composition");
/* Make a hash table for static composition. */
{
Lisp_Object args[6];
args[0] = QCtest;
args[1] = Qequal;
args[2] = QCweakness;
/* We used to make the hash table weak so that unreferenced
compositions can be garbage-collected. But, usually once
created compositions are repeatedly used in an Emacs session,
and thus it's not worth to save memory in such a way. So, we
make the table not weak. */
args[3] = Qnil;
args[4] = QCsize;
args[5] = make_number (311);
composition_hash_table = Fmake_hash_table (6, args);
staticpro (&composition_hash_table);
}
/* Make a hash table for glyph-string. */
{
Lisp_Object args[6];
args[0] = QCtest;
args[1] = Qequal;
args[2] = QCweakness;
args[3] = Qnil;
args[4] = QCsize;
args[5] = make_number (311);
gstring_hash_table = Fmake_hash_table (6, args);
staticpro (&gstring_hash_table);
}
staticpro (&gstring_work_headers);
gstring_work_headers = Fmake_vector (make_number (8), Qnil);
for (i = 0; i < 8; i++)
ASET (gstring_work_headers, i, Fmake_vector (make_number (i + 2), Qnil));
staticpro (&gstring_work);
gstring_work = Fmake_vector (make_number (10), Qnil);
/* Text property `composition' should be nonsticky by default. */
Vtext_property_default_nonsticky
= Fcons (Fcons (Qcomposition, Qt), Vtext_property_default_nonsticky);
DEFVAR_LISP ("compose-chars-after-function", Vcompose_chars_after_function,
doc: /* Function to adjust composition of buffer text.
This function is called with three arguments: FROM, TO, and OBJECT.
FROM and TO specify the range of text whose composition should be
adjusted. OBJECT, if non-nil, is a string that contains the text.
This function is called after a text with `composition' property is
inserted or deleted to keep `composition' property of buffer text
valid.
The default value is the function `compose-chars-after'. */);
Vcompose_chars_after_function = intern_c_string ("compose-chars-after");
DEFSYM (Qauto_composed, "auto-composed");
DEFSYM (Qauto_composition_function, "auto-composition-function");
DEFVAR_LISP ("auto-composition-mode", Vauto_composition_mode,
doc: /* Non-nil if Auto-Composition mode is enabled.
Use the command `auto-composition-mode' to change this variable. */);
Vauto_composition_mode = Qt;
DEFVAR_LISP ("auto-composition-function", Vauto_composition_function,
doc: /* Function to call to compose characters automatically.
This function is called from the display routine with four arguments:
FROM, TO, WINDOW, and STRING.
If STRING is nil, the function must compose characters in the region
between FROM and TO in the current buffer.
Otherwise, STRING is a string, and FROM and TO are indices into the
string. In this case, the function must compose characters in the
string. */);
Vauto_composition_function = Qnil;
DEFVAR_LISP ("composition-function-table", Vcomposition_function_table,
doc: /* Char-table of functions for automatic character composition.
For each character that has to be composed automatically with
preceding and/or following characters, this char-table contains
a function to call to compose that character.
The element at index C in the table, if non-nil, is a list of
composition rules of this form: ([PATTERN PREV-CHARS FUNC] ...)
PATTERN is a regular expression which C and the surrounding
characters must match.
PREV-CHARS is a non-negative integer (less than 4) specifying how many
characters before C to check the matching with PATTERN. If it is 0,
PATTERN must match C and the following characters. If it is 1,
PATTERN must match a character before C and the following characters.
If PREV-CHARS is 0, PATTERN can be nil, which means that the
single character C should be composed.
FUNC is a function to return a glyph-string representing a
composition of the characters that match PATTERN. It is
called with one argument GSTRING.
GSTRING is a template of a glyph-string to return. It is already
filled with a proper header for the characters to compose, and
glyphs corresponding to those characters one by one. The
function must return a new glyph-string with the same header as
GSTRING, or modify GSTRING itself and return it.
See also the documentation of `auto-composition-mode'. */);
Vcomposition_function_table = Fmake_char_table (Qnil, Qnil);
defsubr (&Scompose_region_internal);
defsubr (&Scompose_string_internal);
defsubr (&Sfind_composition_internal);
defsubr (&Scomposition_get_gstring);
}
Reference in a new issue View git blame Copy permalink