Mercurial > emacs

comparison src/alloc.c @ 109165:750db9f3e6d8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Replace bcopy, bzero, bcmp by memcpy, memmove, memset, memcmp * alloc.c (overrun_check_malloc, overrun_check_realloc) (overrun_check_free, xstrdup, allocate_string) (allocate_string_data, compact_small_strings, Fmake_string) (make_unibyte_string, make_multibyte_string) (make_string_from_bytes, make_specified_string, make_float) (Fcons, allocate_terminal, allocate_frame, make_pure_string) (Fgarbage_collect): Replace bcopy, safe_bcopy, bzero, bcmp by memcpy, memmove, memset, memcmp. * atimer.c (start_atimer, set_alarm): Likewise. * buffer.c (clone_per_buffer_values, report_overlay_modification) (mmap_realloc, init_buffer_once): Likewise. * callint.c (Fcall_interactively): Likewise. * callproc.c (Fcall_process, Fcall_process_region, child_setup) (getenv_internal_1): Likewise. * casefiddle.c (casify_object): Likewise. * ccl.c (ccl_driver): Likewise. * character.c (str_as_multibyte, str_to_multibyte): Likewise. * charset.c (load_charset_map_from_file) (load_charset_map_from_file, load_charset_map_from_vector) (Fdefine_charset_internal): Likewise. * cm.c (Wcm_clear): Likewise. * coding.c (decode_eol, decode_coding_object) (Fset_coding_system_priority, make_subsidiaries): Likewise. * data.c (Faset): Likewise. * dired.c (directory_files_internal, file_name_completion_stat): Likewise. * dispnew.c (new_glyph_matrix, adjust_glyph_matrix) (clear_glyph_row, copy_row_except_pointers) (copy_glyph_row_contents, new_glyph_pool, realloc_glyph_pool) (save_current_matrix, restore_current_matrix) (build_frame_matrix_from_leaf_window, mirrored_line_dance) (mirror_line_dance, scrolling_window): Likewise. * doc.c (Fsnarf_documentation, Fsubstitute_command_keys): Likewise. * doprnt.c (doprnt): Likewise. * editfns.c (Fuser_full_name, make_buffer_string_both) (Fmessage_box, Fformat, Ftranspose_regions): Likewise. * emacs.c (sort_args): Likewise. * eval.c (Fapply, Ffuncall): Likewise. * fileio.c (Ffile_name_directory, make_temp_name) (Fexpand_file_name, search_embedded_absfilename) (Fsubstitute_in_file_name, Ffile_symlink_p, Finsert_file_contents) (auto_save_error): Likewise. * fns.c (Fstring_equal, Fcopy_sequence, concat) (string_to_multibyte, Fstring_as_unibyte, Fstring_as_multibyte) (internal_equal, Fclear_string, larger_vector, copy_hash_table) (Fmake_hash_table): Likewise. * fringe.c (Fdefine_fringe_bitmap): Likewise. * ftfont.c (ftfont_text_extents): Likewise. * getloadavg.c (getloadavg): Likewise. * image.c (define_image_type, make_image, make_image_cache) (x_create_x_image_and_pixmap, xbm_image_p) (w32_create_pixmap_from_bitmap_data, xbm_load, xpm_lookup_color) (xpm_image_p, x_create_bitmap_from_xpm_data, xpm_load) (init_color_table, x_build_heuristic_mask, pbm_image_p, pbm_load) (png_image_p, png_read_from_memory, png_load, jpeg_image_p) (tiff_image_p, tiff_read_from_memory, gif_image_p) (gif_read_from_memory, gif_load, svg_image_p, gs_image_p): Likewise. * indent.c (scan_for_column, compute_motion): Likewise. * insdel.c (gap_left, gap_right, make_gap_smaller, copy_text) (insert_1_both, insert_from_gap, replace_range_2): Likewise. * intervals.c (reproduce_tree, reproduce_tree_obj): Likewise. * keyboard.c (echo_char, save_getcjmp, restore_getcjmp) (kbd_buffer_store_event_hold, apply_modifiers_uncached) (store_user_signal_events, menu_bar_items, tool_bar_items) (process_tool_bar_item, append_tool_bar_item) (read_char_minibuf_menu_prompt, read_key_sequence) (Fread_key_sequence, Fread_key_sequence_vector, Frecent_keys): Likewise. * keymap.c (current_minor_maps, Fdescribe_buffer_bindings): Likewise. * lisp.h (STRING_COPYIN): Likewise. * lread.c (Fload, read1, oblookup): Likewise. * msdos.c (Frecent_doskeys): Likewise. * nsfns.m (Fx_create_frame): Likewise. * nsfont.m (nsfont_open, nsfont_text_extents, ns_glyph_metrics): Likewise. * nsimage.m (EmacsImage-initFromSkipXBM:width:height:) (EmacsImage-initForXPMWithDepth:width:height:flip:length:): Likewise. * nsmenu.m (ns_update_menubar): Likewise. * nsterm.m (ns_draw_fringe_bitmap, ns_term_init): Likewise. * print.c (print_unwind, printchar, strout, print_string) (print_error_message): Likewise. * process.c (conv_lisp_to_sockaddr, set_socket_option) (Fmake_network_process, Fnetwork_interface_list) (Fnetwork_interface_info, read_process_output, Fprocess_send_eof) (init_process): Likewise. * ralloc.c (resize_bloc, r_alloc_sbrk, r_alloc_init): Likewise. * regex.c (init_syntax_once, regex_compile, re_compile_fastmap): Likewise. * scroll.c (do_scrolling, do_direct_scrolling) (scrolling_max_lines_saved): Likewise. * search.c (search_buffer, wordify, Freplace_match): Likewise. * sound.c (wav_init, au_init, Fplay_sound_internal): Likewise. * syntax.c (skip_chars, skip_syntaxes): Likewise. * sysdep.c (child_setup_tty, sys_subshell, emacs_get_tty) (emacs_set_tty): Likewise. * term.c (encode_terminal_code, calculate_costs) (produce_special_glyphs, create_tty_output, init_tty, delete_tty): Likewise. * termcap.c (tgetst1, gobble_line): Likewise. * termhooks.h (EVENT_INIT): Likewise. * tparam.c (tparam1): Likewise. * unexalpha.c (unexec): Likewise. * unexec.c (write_segment): Likewise. * unexmacosx.c (unexec_write_zero): Likewise. * w32fns.c (w32_wnd_proc, Fx_create_frame, x_create_tip_frame) (Fx_file_dialog, Fsystem_move_file_to_trash): Likewise. * w32font.c (w32font_list_family, w32font_text_extents) (w32font_list_internal, w32font_match_internal) (w32font_open_internal, compute_metrics, Fx_select_font): Likewise. * w32menu.c (set_frame_menubar, add_menu_item) (w32_menu_display_help, w32_free_submenu_strings): Likewise. * w32term.c (XCreateGC, w32_initialize_display_info): Likewise. * w32uniscribe.c (uniscribe_list_family): Likewise. * w32xfns.c (get_next_msg, post_msg, prepend_msg): Likewise. * window.c (make_window, replace_window, set_window_buffer) (Fsplit_window): Likewise. * xdisp.c (init_iterator, RECORD_OVERLAY_STRING, reseat_to_string) (add_to_log, message3, x_consider_frame_title) (append_space_for_newline, extend_face_to_end_of_line) (decode_mode_spec_coding, init_glyph_string): Likewise. * xfaces.c (x_create_gc, get_lface_attributes_no_remap) (Finternal_copy_lisp_face, Finternal_merge_in_global_face) (face_attr_equal_p, make_realized_face, make_face_cache) (free_realized_faces, lookup_named_face, smaller_face) (face_with_height, lookup_derived_face) (x_supports_face_attributes_p, Finternal_set_font_selection_order) (Finternal_set_font_selection_order, realize_default_face) (compute_char_face, face_at_buffer_position) (face_for_overlay_string, face_at_string_position, merge_faces): Likewise. * xfns.c (xic_create_fontsetname, Fx_create_frame) (Fx_window_property, x_create_tip_frame) (Fx_backspace_delete_keys_p): Likewise. * xfont.c (xfont_list, xfont_match, xfont_list_family) (xfont_text_extents): Likewise. * xmenu.c (set_frame_menubar, xmenu_show): Likewise. * xrdb.c (magic_file_p, x_get_resource): Likewise. * xselect.c (x_queue_event, x_get_window_property) (receive_incremental_selection): Likewise. * xsmfns.c (x_session_check_input): Likewise. * xterm.c (x_send_scroll_bar_event, SET_SAVED_MENU_EVENT) (handle_one_xevent, x_check_errors, xim_initialize, x_term_init): Likewise. * character.h (BCOPY_SHORT): Removed. * config.in: Regenerate. * dispnew.c (safe_bcopy): Only define as dummy if PROFILING. * emacs.c (main) [PROFILING]: Don't declare dump_opcode_frequencies. * lisp.h (safe_bcopy): Remove declaration. (memset) [!HAVE_MEMSET]: Declare. (memcpy) [!HAVE_MEMCPY]: Likewise. (memmove) [!HAVE_MEMMOVE]: Likewise. (memcmp) [!HAVE_MEMCMP]: Likewise. * s/ms-w32.h (bzero, bcopy, bcmp, GAP_USE_BCOPY) (BCOPY_UPWARD_SAFE, BCOPY_DOWNWARD_SAFE, HAVE_BCOPY, HAVE_BCMP): Don't define. (HAVE_MEMCMP, HAVE_MEMCPY, HAVE_MEMMOVE, HAVE_MEMSET): Define. * s/msdos.h (GAP_USE_BCOPY, BCOPY_UPWARD_SAFE) (BCOPY_DOWNWARD_SAFE): Don't define. * sysdep.c (memset) [!HAVE_MEMSET]: Define. (memcpy) [!HAVE_MEMCPY]: Define. (memmove) [!HAVE_MEMMOVE]: Define. (memcmp) [!HAVE_MEMCMP]: Define. * config.nt (HAVE_BCOPY, HAVE_BCMP): Remove undefs. (HAVE_MEMCPY, HAVE_MEMMOVE, HAVE_MEMSET, HAVE_MEMCMP): Add undefs. * sed2v2.inp (HAVE_MEMCPY, HAVE_MEMSET): Edit to 1. (HAVE_BZERO): Don't edit. * lwlib.c (lwlib_memset, lwlib_bcopy): Remove. (malloc_widget_value, free_widget_info, allocate_widget_instance) (lw_separator_p): Replace lwlib_memset, lwlib_bcopy, bzero, bcmp by memset, memcpy, memcmp. * lwlib-utils.c (XtApplyToWidgets): Likewise. * xlwmenu.c (XlwMenuInitialize): Likewise. * lwlib.h (lwlib_bcopy): Remove declaration. * ebrowse.c (add_sym, make_namespace): Replace bcopy, bzero by memcpy, memmove, memset. * pop.c (pop_retrieve, socket_connection, pop_getline): Likewise. * CPP-DEFINES (BCOPY_DOWNWARD_SAFE, BCOPY_UPWARD_SAFE) (GAP_USE_BCOPY, HAVE_BCMP, HAVE_BCOPY, bcmp, bcopy, bzero): Remove. * configure.in: Don't check for bcopy, bcmp, bzero. Don't include <strings.h> and don't define bcopy, bzero, BCMP in config.h.
author Andreas Schwab <schwab@linux-m68k.org>
date Thu, 08 Jul 2010 00:18:28 +0200
parents c25c24812fb1
children 8cfee7d2955f
comparison
equal deleted inserted replaced
109164:a7b09b567d58 109165:750db9f3e6d8
634 size_t overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_SIZE*2 : 0; 634 size_t overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_SIZE*2 : 0;
635 635
636 val = (unsigned char *) malloc (size + overhead); 636 val = (unsigned char *) malloc (size + overhead);
637 if (val && check_depth == 1) 637 if (val && check_depth == 1)
638 { 638 {
639 bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4); 639 memcpy (val, xmalloc_overrun_check_header,
640 XMALLOC_OVERRUN_CHECK_SIZE - 4);
640 val += XMALLOC_OVERRUN_CHECK_SIZE; 641 val += XMALLOC_OVERRUN_CHECK_SIZE;
641 XMALLOC_PUT_SIZE(val, size); 642 XMALLOC_PUT_SIZE(val, size);
642 bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE); 643 memcpy (val + size, xmalloc_overrun_check_trailer,
644 XMALLOC_OVERRUN_CHECK_SIZE);
643 } 645 }
644 --check_depth; 646 --check_depth;
645 return (POINTER_TYPE *)val; 647 return (POINTER_TYPE *)val;
646 } 648 }
647 649
657 register unsigned char *val = (unsigned char *)block; 659 register unsigned char *val = (unsigned char *)block;
658 size_t overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_SIZE*2 : 0; 660 size_t overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_SIZE*2 : 0;
659 661
660 if (val 662 if (val
661 && check_depth == 1 663 && check_depth == 1
662 && bcmp (xmalloc_overrun_check_header, 664 && memcmp (xmalloc_overrun_check_header,
663 val - XMALLOC_OVERRUN_CHECK_SIZE, 665 val - XMALLOC_OVERRUN_CHECK_SIZE,
664 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0) 666 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
665 { 667 {
666 size_t osize = XMALLOC_GET_SIZE (val); 668 size_t osize = XMALLOC_GET_SIZE (val);
667 if (bcmp (xmalloc_overrun_check_trailer, 669 if (memcmp (xmalloc_overrun_check_trailer, val + osize,
668 val + osize, 670 XMALLOC_OVERRUN_CHECK_SIZE))
669 XMALLOC_OVERRUN_CHECK_SIZE))
670 abort (); 671 abort ();
671 bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE); 672 memset (val + osize, 0, XMALLOC_OVERRUN_CHECK_SIZE);
672 val -= XMALLOC_OVERRUN_CHECK_SIZE; 673 val -= XMALLOC_OVERRUN_CHECK_SIZE;
673 bzero (val, XMALLOC_OVERRUN_CHECK_SIZE); 674 memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE);
674 } 675 }
675 676
676 val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + overhead); 677 val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + overhead);
677 678
678 if (val && check_depth == 1) 679 if (val && check_depth == 1)
679 { 680 {
680 bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4); 681 memcpy (val, xmalloc_overrun_check_header,
682 XMALLOC_OVERRUN_CHECK_SIZE - 4);
681 val += XMALLOC_OVERRUN_CHECK_SIZE; 683 val += XMALLOC_OVERRUN_CHECK_SIZE;
682 XMALLOC_PUT_SIZE(val, size); 684 XMALLOC_PUT_SIZE(val, size);
683 bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE); 685 memcpy (val + size, xmalloc_overrun_check_trailer,
686 XMALLOC_OVERRUN_CHECK_SIZE);
684 } 687 }
685 --check_depth; 688 --check_depth;
686 return (POINTER_TYPE *)val; 689 return (POINTER_TYPE *)val;
687 } 690 }
688 691
695 unsigned char *val = (unsigned char *)block; 698 unsigned char *val = (unsigned char *)block;
696 699
697 ++check_depth; 700 ++check_depth;
698 if (val 701 if (val
699 && check_depth == 1 702 && check_depth == 1
700 && bcmp (xmalloc_overrun_check_header, 703 && memcmp (xmalloc_overrun_check_header,
701 val - XMALLOC_OVERRUN_CHECK_SIZE, 704 val - XMALLOC_OVERRUN_CHECK_SIZE,
702 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0) 705 XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
703 { 706 {
704 size_t osize = XMALLOC_GET_SIZE (val); 707 size_t osize = XMALLOC_GET_SIZE (val);
705 if (bcmp (xmalloc_overrun_check_trailer, 708 if (memcmp (xmalloc_overrun_check_trailer, val + osize,
706 val + osize, 709 XMALLOC_OVERRUN_CHECK_SIZE))
707 XMALLOC_OVERRUN_CHECK_SIZE))
708 abort (); 710 abort ();
709 #ifdef XMALLOC_CLEAR_FREE_MEMORY 711 #ifdef XMALLOC_CLEAR_FREE_MEMORY
710 val -= XMALLOC_OVERRUN_CHECK_SIZE; 712 val -= XMALLOC_OVERRUN_CHECK_SIZE;
711 memset (val, 0xff, osize + XMALLOC_OVERRUN_CHECK_SIZE*2); 713 memset (val, 0xff, osize + XMALLOC_OVERRUN_CHECK_SIZE*2);
712 #else 714 #else
713 bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE); 715 memset (val + osize, 0, XMALLOC_OVERRUN_CHECK_SIZE);
714 val -= XMALLOC_OVERRUN_CHECK_SIZE; 716 val -= XMALLOC_OVERRUN_CHECK_SIZE;
715 bzero (val, XMALLOC_OVERRUN_CHECK_SIZE); 717 memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE);
716 #endif 718 #endif
717 } 719 }
718 720
719 free (val); 721 free (val);
720 --check_depth; 722 --check_depth;
797 char * 799 char *
798 xstrdup (const char *s) 800 xstrdup (const char *s)
799 { 801 {
800 size_t len = strlen (s) + 1; 802 size_t len = strlen (s) + 1;
801 char *p = (char *) xmalloc (len); 803 char *p = (char *) xmalloc (len);
802 bcopy (s, p, len); 804 memcpy (p, s, len);
803 return p; 805 return p;
804 } 806 }
805 807
806 808
807 /* Unwind for SAFE_ALLOCA */ 809 /* Unwind for SAFE_ALLOCA */
1871 { 1873 {
1872 struct string_block *b; 1874 struct string_block *b;
1873 int i; 1875 int i;
1874 1876
1875 b = (struct string_block *) lisp_malloc (sizeof *b, MEM_TYPE_STRING); 1877 b = (struct string_block *) lisp_malloc (sizeof *b, MEM_TYPE_STRING);
1876 bzero (b, sizeof *b); 1878 memset (b, 0, sizeof *b);
1877 b->next = string_blocks; 1879 b->next = string_blocks;
1878 string_blocks = b; 1880 string_blocks = b;
1879 ++n_string_blocks; 1881 ++n_string_blocks;
1880 1882
1881 for (i = STRING_BLOCK_SIZE - 1; i >= 0; --i) 1883 for (i = STRING_BLOCK_SIZE - 1; i >= 0; --i)
1895 string_free_list = NEXT_FREE_LISP_STRING (s); 1897 string_free_list = NEXT_FREE_LISP_STRING (s);
1896 1898
1897 MALLOC_UNBLOCK_INPUT; 1899 MALLOC_UNBLOCK_INPUT;
1898 1900
1899 /* Probably not strictly necessary, but play it safe. */ 1901 /* Probably not strictly necessary, but play it safe. */
1900 bzero (s, sizeof *s); 1902 memset (s, 0, sizeof *s);
1901 1903
1902 --total_free_strings; 1904 --total_free_strings;
1903 ++total_strings; 1905 ++total_strings;
1904 ++strings_consed; 1906 ++strings_consed;
1905 consing_since_gc += sizeof *s; 1907 consing_since_gc += sizeof *s;
2003 #endif 2005 #endif
2004 s->size = nchars; 2006 s->size = nchars;
2005 s->size_byte = nbytes; 2007 s->size_byte = nbytes;
2006 s->data[nbytes] = '\0'; 2008 s->data[nbytes] = '\0';
2007 #ifdef GC_CHECK_STRING_OVERRUN 2009 #ifdef GC_CHECK_STRING_OVERRUN
2008 bcopy (string_overrun_cookie, (char *) data + needed, 2010 memcpy (data + needed, string_overrun_cookie, GC_STRING_OVERRUN_COOKIE_SIZE);
2009 GC_STRING_OVERRUN_COOKIE_SIZE);
2010 #endif 2011 #endif
2011 2012
2012 /* If S had already data assigned, mark that as free by setting its 2013 /* If S had already data assigned, mark that as free by setting its
2013 string back-pointer to null, and recording the size of the data 2014 string back-pointer to null, and recording the size of the data
2014 in it. */ 2015 in it. */
2195 2196
2196 nbytes = SDATA_SIZE (nbytes); 2197 nbytes = SDATA_SIZE (nbytes);
2197 from_end = (struct sdata *) ((char *) from + nbytes + GC_STRING_EXTRA); 2198 from_end = (struct sdata *) ((char *) from + nbytes + GC_STRING_EXTRA);
2198 2199
2199 #ifdef GC_CHECK_STRING_OVERRUN 2200 #ifdef GC_CHECK_STRING_OVERRUN
2200 if (bcmp (string_overrun_cookie, 2201 if (memcmp (string_overrun_cookie,
2201 ((char *) from_end) - GC_STRING_OVERRUN_COOKIE_SIZE, 2202 (char *) from_end - GC_STRING_OVERRUN_COOKIE_SIZE,
2202 GC_STRING_OVERRUN_COOKIE_SIZE)) 2203 GC_STRING_OVERRUN_COOKIE_SIZE))
2203 abort (); 2204 abort ();
2204 #endif 2205 #endif
2205 2206
2206 /* FROM->string non-null means it's alive. Copy its data. */ 2207 /* FROM->string non-null means it's alive. Copy its data. */
2207 if (from->string) 2208 if (from->string)
2219 2220
2220 /* Copy, and update the string's `data' pointer. */ 2221 /* Copy, and update the string's `data' pointer. */
2221 if (from != to) 2222 if (from != to)
2222 { 2223 {
2223 xassert (tb != b || to <= from); 2224 xassert (tb != b || to <= from);
2224 safe_bcopy ((char *) from, (char *) to, nbytes + GC_STRING_EXTRA); 2225 memmove (to, from, nbytes + GC_STRING_EXTRA);
2225 to->string->data = SDATA_DATA (to); 2226 to->string->data = SDATA_DATA (to);
2226 } 2227 }
2227 2228
2228 /* Advance past the sdata we copied to. */ 2229 /* Advance past the sdata we copied to. */
2229 to = to_end; 2230 to = to_end;
2278 val = make_uninit_multibyte_string (XINT (length), nbytes); 2279 val = make_uninit_multibyte_string (XINT (length), nbytes);
2279 p = SDATA (val); 2280 p = SDATA (val);
2280 end = p + nbytes; 2281 end = p + nbytes;
2281 while (p != end) 2282 while (p != end)
2282 { 2283 {
2283 bcopy (str, p, len); 2284 memcpy (p, str, len);
2284 p += len; 2285 p += len;
2285 } 2286 }
2286 } 2287 }
2287 2288
2288 *p = 0; 2289 *p = 0;
2360 Lisp_Object 2361 Lisp_Object
2361 make_unibyte_string (const char *contents, int length) 2362 make_unibyte_string (const char *contents, int length)
2362 { 2363 {
2363 register Lisp_Object val; 2364 register Lisp_Object val;
2364 val = make_uninit_string (length); 2365 val = make_uninit_string (length);
2365 bcopy (contents, SDATA (val), length); 2366 memcpy (SDATA (val), contents, length);
2366 STRING_SET_UNIBYTE (val); 2367 STRING_SET_UNIBYTE (val);
2367 return val; 2368 return val;
2368 } 2369 }
2369 2370
2370 2371
2374 Lisp_Object 2375 Lisp_Object
2375 make_multibyte_string (const char *contents, int nchars, int nbytes) 2376 make_multibyte_string (const char *contents, int nchars, int nbytes)
2376 { 2377 {
2377 register Lisp_Object val; 2378 register Lisp_Object val;
2378 val = make_uninit_multibyte_string (nchars, nbytes); 2379 val = make_uninit_multibyte_string (nchars, nbytes);
2379 bcopy (contents, SDATA (val), nbytes); 2380 memcpy (SDATA (val), contents, nbytes);
2380 return val; 2381 return val;
2381 } 2382 }
2382 2383
2383 2384
2384 /* Make a string from NCHARS characters occupying NBYTES bytes at 2385 /* Make a string from NCHARS characters occupying NBYTES bytes at
2387 Lisp_Object 2388 Lisp_Object
2388 make_string_from_bytes (const char *contents, int nchars, int nbytes) 2389 make_string_from_bytes (const char *contents, int nchars, int nbytes)
2389 { 2390 {
2390 register Lisp_Object val; 2391 register Lisp_Object val;
2391 val = make_uninit_multibyte_string (nchars, nbytes); 2392 val = make_uninit_multibyte_string (nchars, nbytes);
2392 bcopy (contents, SDATA (val), nbytes); 2393 memcpy (SDATA (val), contents, nbytes);
2393 if (SBYTES (val) == SCHARS (val)) 2394 if (SBYTES (val) == SCHARS (val))
2394 STRING_SET_UNIBYTE (val); 2395 STRING_SET_UNIBYTE (val);
2395 return val; 2396 return val;
2396 } 2397 }
2397 2398
2412 nchars = multibyte_chars_in_text (contents, nbytes); 2413 nchars = multibyte_chars_in_text (contents, nbytes);
2413 else 2414 else
2414 nchars = nbytes; 2415 nchars = nbytes;
2415 } 2416 }
2416 val = make_uninit_multibyte_string (nchars, nbytes); 2417 val = make_uninit_multibyte_string (nchars, nbytes);
2417 bcopy (contents, SDATA (val), nbytes); 2418 memcpy (SDATA (val), contents, nbytes);
2418 if (!multibyte) 2419 if (!multibyte)
2419 STRING_SET_UNIBYTE (val); 2420 STRING_SET_UNIBYTE (val);
2420 return val; 2421 return val;
2421 } 2422 }
2422 2423
2585 register struct float_block *new; 2586 register struct float_block *new;
2586 2587
2587 new = (struct float_block *) lisp_align_malloc (sizeof *new, 2588 new = (struct float_block *) lisp_align_malloc (sizeof *new,
2588 MEM_TYPE_FLOAT); 2589 MEM_TYPE_FLOAT);
2589 new->next = float_block; 2590 new->next = float_block;
2590 bzero ((char *) new->gcmarkbits, sizeof new->gcmarkbits); 2591 memset (new->gcmarkbits, 0, sizeof new->gcmarkbits);
2591 float_block = new; 2592 float_block = new;
2592 float_block_index = 0; 2593 float_block_index = 0;
2593 n_float_blocks++; 2594 n_float_blocks++;
2594 } 2595 }
2595 XSETFLOAT (val, &float_block->floats[float_block_index]); 2596 XSETFLOAT (val, &float_block->floats[float_block_index]);
2707 if (cons_block_index == CONS_BLOCK_SIZE) 2708 if (cons_block_index == CONS_BLOCK_SIZE)
2708 { 2709 {
2709 register struct cons_block *new; 2710 register struct cons_block *new;
2710 new = (struct cons_block *) lisp_align_malloc (sizeof *new, 2711 new = (struct cons_block *) lisp_align_malloc (sizeof *new,
2711 MEM_TYPE_CONS); 2712 MEM_TYPE_CONS);
2712 bzero ((char *) new->gcmarkbits, sizeof new->gcmarkbits); 2713 memset (new->gcmarkbits, 0, sizeof new->gcmarkbits);
2713 new->next = cons_block; 2714 new->next = cons_block;
2714 cons_block = new; 2715 cons_block = new;
2715 cons_block_index = 0; 2716 cons_block_index = 0;
2716 n_cons_blocks++; 2717 n_cons_blocks++;
2717 } 2718 }
2948 allocate_terminal (void) 2949 allocate_terminal (void)
2949 { 2950 {
2950 struct terminal *t = ALLOCATE_PSEUDOVECTOR (struct terminal, 2951 struct terminal *t = ALLOCATE_PSEUDOVECTOR (struct terminal,
2951 next_terminal, PVEC_TERMINAL); 2952 next_terminal, PVEC_TERMINAL);
2952 /* Zero out the non-GC'd fields. FIXME: This should be made unnecessary. */ 2953 /* Zero out the non-GC'd fields. FIXME: This should be made unnecessary. */
2953 bzero (&(t->next_terminal), 2954 memset (&t->next_terminal, 0,
2954 ((char*)(t+1)) - ((char*)&(t->next_terminal))); 2955 (char*) (t + 1) - (char*) &t->next_terminal);
2955 2956
2956 return t; 2957 return t;
2957 } 2958 }
2958 2959
2959 struct frame * 2960 struct frame *
2960 allocate_frame (void) 2961 allocate_frame (void)
2961 { 2962 {
2962 struct frame *f = ALLOCATE_PSEUDOVECTOR (struct frame, 2963 struct frame *f = ALLOCATE_PSEUDOVECTOR (struct frame,
2963 face_cache, PVEC_FRAME); 2964 face_cache, PVEC_FRAME);
2964 /* Zero out the non-GC'd fields. FIXME: This should be made unnecessary. */ 2965 /* Zero out the non-GC'd fields. FIXME: This should be made unnecessary. */
2965 bzero (&(f->face_cache), 2966 memset (&f->face_cache, 0,
2966 ((char*)(f+1)) - ((char*)&(f->face_cache))); 2967 (char *) (f + 1) - (char *) &f->face_cache);
2967 return f; 2968 return f;
2968 } 2969 }
2969 2970
2970 2971
2971 struct Lisp_Process * 2972 struct Lisp_Process *
4711 s = (struct Lisp_String *) pure_alloc (sizeof *s, Lisp_String); 4712 s = (struct Lisp_String *) pure_alloc (sizeof *s, Lisp_String);
4712 s->data = find_string_data_in_pure (data, nbytes); 4713 s->data = find_string_data_in_pure (data, nbytes);
4713 if (s->data == NULL) 4714 if (s->data == NULL)
4714 { 4715 {
4715 s->data = (unsigned char *) pure_alloc (nbytes + 1, -1); 4716 s->data = (unsigned char *) pure_alloc (nbytes + 1, -1);
4716 bcopy (data, s->data, nbytes); 4717 memcpy (s->data, data, nbytes);
4717 s->data[nbytes] = '\0'; 4718 s->data[nbytes] = '\0';
4718 } 4719 }
4719 s->size = nchars; 4720 s->size = nchars;
4720 s->size_byte = multibyte ? nbytes : -1; 4721 s->size_byte = multibyte ? nbytes : -1;
4721 s->intervals = NULL_INTERVAL; 4722 s->intervals = NULL_INTERVAL;
4978 else if (stack_copy_size < i) 4979 else if (stack_copy_size < i)
4979 stack_copy = (char *) xrealloc (stack_copy, (stack_copy_size = i)); 4980 stack_copy = (char *) xrealloc (stack_copy, (stack_copy_size = i));
4980 if (stack_copy) 4981 if (stack_copy)
4981 { 4982 {
4982 if ((EMACS_INT) (&stack_top_variable - stack_bottom) > 0) 4983 if ((EMACS_INT) (&stack_top_variable - stack_bottom) > 0)
4983 bcopy (stack_bottom, stack_copy, i); 4984 memcpy (stack_copy, stack_bottom, i);
4984 else 4985 else
4985 bcopy (&stack_top_variable, stack_copy, i); 4986 memcpy (stack_copy, &stack_top_variable, i);
4986 } 4987 }
4987 } 4988 }
4988 } 4989 }
4989 #endif /* MAX_SAVE_STACK > 0 */ 4990 #endif /* MAX_SAVE_STACK > 0 */
4990 4991