procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Replace bcopy, bzero, bcmp by memcpy, memmove, memset, memcmp

Browse source 
* 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.
This commit is contained in:
Andreas Schwab 2010-07-08 00:18:28 +02:00
parent cb768704a4
commit 72af86bd8c
92 changed files with 801 additions and 761 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
ChangeLog
View file

@ -1,3 +1,8 @@
2010-07-07 Andreas Schwab <schwab@linux-m68k.org>
* configure.in: Don't check for bcopy, bcmp, bzero. Don't include
<strings.h> and don't define bcopy, bzero, BCMP in config.h.
2010-07-07 Dan Nicolaescu <dann@ics.uci.edu>
* configure.in (getenv): Remove K&R declaration.

8
admin/CPP-DEFINES
View file

@ -79,8 +79,6 @@ USER_FULL_NAME If defined, overrides the default pw->pw_gecos for getting at t
AIX
AMPERSAND_FULL_NAME
BCOPY_DOWNWARD_SAFE
BCOPY_UPWARD_SAFE
BITS_PER_EMACS_INT
BITS_PER_LONG
BITS_PER_CHAR
@ -118,7 +116,6 @@ EMACS_UINT
FILE_SYSTEM_CASE
FLOAT_CHECK_DOMAIN
FSCALE
GAP_USE_BCOPY
GC_LISP_OBJECT_ALIGNMENT
GC_MARK_SECONDARY_STACK
GC_MARK_STACK
@ -128,8 +125,6 @@ GNU_LIBRARY_PENDING_OUTPUT_COUNT
GNU_LINUX
GNU_MALLOC
HAVE_AIX_SMT_EXP
HAVE_BCMP
HAVE_BCOPY
HAVE_CBRT
HAVE_CLOSEDIR
HAVE_DUP2
@ -319,10 +314,7 @@ _start
abort
access
alloca
bcmp
bcopy
brk
bzero
calloc
chdir
chmod

6
admin/ChangeLog
View file

@ -1,3 +1,9 @@
2010-07-07 Andreas Schwab <schwab@linux-m68k.org>
* CPP-DEFINES (BCOPY_DOWNWARD_SAFE, BCOPY_UPWARD_SAFE)
(GAP_USE_BCOPY, HAVE_BCMP, HAVE_BCOPY, bcmp, bcopy, bzero):
Remove.
2010-06-12 Eli Zaretskii <eliz@gnu.org>
* unidata/bidimirror.awk: New file.

4
configure vendored
View file

@ -11168,12 +11168,12 @@ esac
for ac_func in gethostname getdomainname dup2 \
rename closedir mkdir rmdir sysinfo getrusage get_current_dir_name \
random lrand48 bcopy bcmp logb frexp fmod rint cbrt ftime setsid \
random lrand48 logb frexp fmod rint cbrt ftime setsid \
strerror fpathconf select mktime euidaccess getpagesize tzset setlocale \
utimes getrlimit setrlimit setpgid getcwd getwd shutdown getaddrinfo \
__fpending mblen mbrlen mbsinit strsignal setitimer ualarm index rindex \
sendto recvfrom getsockopt setsockopt getsockname getpeername \
gai_strerror mkstemp getline getdelim mremap memmove fsync sync bzero \
gai_strerror mkstemp getline getdelim mremap memmove fsync sync \
memset memcmp difftime memcpy mempcpy mblen mbrlen posix_memalign \
cfmakeraw cfsetspeed isnan copysign
do :

18
configure.in
View file

@ -2615,12 +2615,12 @@ AC_SUBST(BLESSMAIL_TARGET)
AC_CHECK_FUNCS(gethostname getdomainname dup2 \
rename closedir mkdir rmdir sysinfo getrusage get_current_dir_name \
random lrand48 bcopy bcmp logb frexp fmod rint cbrt ftime setsid \
random lrand48 logb frexp fmod rint cbrt ftime setsid \
strerror fpathconf select mktime euidaccess getpagesize tzset setlocale \
utimes getrlimit setrlimit setpgid getcwd getwd shutdown getaddrinfo \
__fpending mblen mbrlen mbsinit strsignal setitimer ualarm index rindex \
sendto recvfrom getsockopt setsockopt getsockname getpeername \
gai_strerror mkstemp getline getdelim mremap memmove fsync sync bzero \
gai_strerror mkstemp getline getdelim mremap memmove fsync sync \
memset memcmp difftime memcpy mempcpy mblen mbrlen posix_memalign \
cfmakeraw cfsetspeed isnan copysign)
@ -3574,10 +3574,6 @@ SYSTEM_PURESIZE_EXTRA seems like the least likely to cause problems. */
#include <string.h>
#endif
#ifdef HAVE_STRINGS_H
#include <strings.h> /* May be needed for bcopy & al. */
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
@ -3619,16 +3615,6 @@ typedef unsigned size_t;
# endif
#endif
#ifndef HAVE_BCOPY
#define bcopy(a,b,s) memcpy (b,a,s)
#endif
#ifndef HAVE_BZERO
#define bzero(a,s) memset (a,0,s)
#endif
#ifndef HAVE_BCMP
#define BCMP memcmp
#endif
#endif /* EMACS_CONFIG_H */
/*

6
lib-src/ChangeLog
View file

@ -1,3 +1,9 @@
2010-07-07 Andreas Schwab <schwab@linux-m68k.org>
* ebrowse.c (add_sym, make_namespace): Replace bcopy, bzero by
memcpy, memmove, memset.
* pop.c (pop_retrieve, socket_connection, pop_getline): Likewise.
2010-07-06 Andreas Schwab <schwab@linux-m68k.org>
* movemail.c: Add MAIL_USE_POP around prototypes.

4
lib-src/ebrowse.c
View file

@ -647,7 +647,7 @@ add_sym (char *name, struct sym *nested_in_class)
}
sym = (struct sym *) xmalloc (sizeof *sym + strlen (name));
bzero (sym, sizeof *sym);
memset (sym, 0, sizeof *sym);
strcpy (sym->name, name);
sym->namesp = scope;
sym->next = class_table[h];
@ -1042,7 +1042,7 @@ struct sym *
make_namespace (char *name, struct sym *context)
{
struct sym *s = (struct sym *) xmalloc (sizeof *s + strlen (name));
bzero (s, sizeof *s);
memset (s, 0, sizeof *s);
strcpy (s->name, name);
s->next = all_namespaces;
s->namesp = context;

14
lib-src/pop.c
View file

@ -612,7 +612,7 @@ pop_retrieve (popserver server, int message, int markfrom, char **msg_buf)
}
ptr[cp++] = '>';
}
bcopy (fromserver, &ptr[cp], ret);
memcpy (&ptr[cp], fromserver, ret);
cp += ret;
ptr[cp++] = '\n';
}
@ -1020,7 +1020,7 @@ socket_connection (char *host, int flags)
}
#endif
bzero ((char *) &addr, sizeof (addr));
memset (&addr, 0, sizeof (addr));
addr.sin_family = AF_INET;
/** "kpop" service is never used: look for 20060515 to see why **/
@ -1096,8 +1096,7 @@ socket_connection (char *host, int flags)
if (it->ai_addrlen == sizeof (addr))
{
struct sockaddr_in *in_a = (struct sockaddr_in *) it->ai_addr;
bcopy (&in_a->sin_addr, (char *) &addr.sin_addr,
sizeof (addr.sin_addr));
memcpy (&addr.sin_addr, &in_a->sin_addr, sizeof (addr.sin_addr));
if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
break;
}
@ -1125,8 +1124,7 @@ socket_connection (char *host, int flags)
while (*hostent->h_addr_list)
{
bcopy (*hostent->h_addr_list, (char *) &addr.sin_addr,
hostent->h_length);
memcpy (&addr.sin_addr, *hostent->h_addr_list, hostent->h_length);
if (! connect (sock, (struct sockaddr *) &addr, sizeof (addr)))
break;
hostent->h_addr_list++;
@ -1318,8 +1316,8 @@ pop_getline (popserver server, char **line)
}
else
{
bcopy (server->buffer + server->buffer_index,
server->buffer, server->data);
memmove (server->buffer, server->buffer + server->buffer_index,
server->data);
/* Record the fact that we've searched the data already in
the buffer for a CRLF, so that when we search below, we
don't have to search the same data twice. There's a "-

10
lwlib/ChangeLog
View file

@ -1,3 +1,13 @@
2010-07-07 Andreas Schwab <schwab@linux-m68k.org>
* 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.
2010-07-05 Jan Djärv <jan.h.d@swipnet.se>
* xlwmenu.c (XlwMenuSetValues, XlwMenuInitialize): Correct prototype.

4
lwlib/lwlib-utils.c
View file

@ -77,8 +77,8 @@ XtApplyToWidgets (Widget w, XtApplyToWidgetsProc proc, XtPointer arg)
int nkids = cw->composite.num_children;
Widget *kids = (Widget *) malloc (sizeof (Widget) * nkids);
int i;
lwlib_bcopy ((char *) cw->composite.children, (char *) kids,
sizeof (Widget) * nkids);
memcpy ((char *) kids, (char *) cw->composite.children,
sizeof (Widget) * nkids);
for (i = 0; i < nkids; i++)
/* This prevent us from using gadgets, why is it here? */
/* if (XtIsWidget (kids [i])) */

30
lwlib/lwlib.c
View file

@ -104,24 +104,6 @@ static void destroy_one_instance (widget_instance *);
static void lw_pop_all_widgets (LWLIB_ID, Boolean);
static Boolean get_one_value (widget_instance *, widget_value *);
static void show_one_widget_busy (Widget, Boolean);
void
lwlib_memset (char *address, int value, size_t length)
{
int i;
for (i = 0; i < length; i++)
address[i] = value;
}
void
lwlib_bcopy (char *from, char *to, int length)
{
int i;
for (i = 0; i < length; i++)
to[i] = from[i];
}
/* utility functions for widget_instance and widget_info */
char *
safe_strdup (const char *s)
@ -179,7 +161,7 @@ malloc_widget_value (void)
wv = (widget_value *) malloc (sizeof (widget_value));
malloc_cpt++;
}
lwlib_memset ((void*) wv, 0, sizeof (widget_value));
memset ((void*) wv, 0, sizeof (widget_value));
return wv;
}
@ -302,7 +284,7 @@ free_widget_info (widget_info *info)
safe_free_str (info->type);
safe_free_str (info->name);
free_widget_value_tree (info->val);
lwlib_memset ((void*)info, 0xDEADBEEF, sizeof (widget_info));
memset ((void*)info, 0xDEADBEEF, sizeof (widget_info));
free (info);
}
@ -331,7 +313,7 @@ allocate_widget_instance (info, parent, pop_up_p)
{
widget_instance* instance =
(widget_instance*)malloc (sizeof (widget_instance));
bzero (instance, sizeof *instance);
memset (instance, 0, sizeof *instance);
instance->parent = parent;
instance->pop_up_p = pop_up_p;
instance->info = info;
@ -348,7 +330,7 @@ allocate_widget_instance (info, parent, pop_up_p)
static void
free_widget_instance (widget_instance *instance)
{
lwlib_memset ((void*)instance, 0xDEADBEEF, sizeof (widget_instance));
memset ((void*)instance, 0xDEADBEEF, sizeof (widget_instance));
free (instance);
}
@ -1453,7 +1435,7 @@ lw_separator_p (char *label, enum menu_separator *type, int motif_p)
int separator_p = 0;
if (strlen (label) >= 3
&& bcmp (label, "--:", 3) == 0)
&& memcmp (label, "--:", 3) == 0)
{
static struct separator_table
{
@ -1496,7 +1478,7 @@ lw_separator_p (char *label, enum menu_separator *type, int motif_p)
}
}
else if (strlen (label) > 3
&& bcmp (label, "--", 2) == 0
&& memcmp (label, "--", 2) == 0
&& label[2] != '-')
{
/* Alternative, more Emacs-style names. */

2
lwlib/lwlib.h
View file

@ -189,8 +189,6 @@ void lw_set_main_areas (Widget parent,
int lw_separator_p (char *label, enum menu_separator *type,
int motif_p);
void lwlib_bcopy (char*, char*, int);
#endif /* LWLIB_H */
/* arch-tag: 44d818d5-7eb2-4d87-acd7-b992bb0d5d20

2
lwlib/xlwmenu.c
View file

@ -1861,7 +1861,7 @@ XlwMenuInitialize (Widget request, Widget w, ArgList args, Cardinal *num_args)
/* _XtCreate is freeing the object that was passed to us,
so make a copy that we will actually keep. */
lwlib_bcopy (mw->menu.contents, tem, sizeof (widget_value));
memcpy (tem, mw->menu.contents, sizeof (widget_value));
mw->menu.contents = tem;
#endif

5
msdos/ChangeLog
View file

@ -1,3 +1,8 @@
2010-07-07 Andreas Schwab <schwab@linux-m68k.org>
* sed2v2.inp (HAVE_MEMCPY, HAVE_MEMSET): Edit to 1.
(HAVE_BZERO): Don't edit.
2010-07-02 Eli Zaretskii <eliz@gnu.org>
* sed1v2.inp (LIB_GCC): Edit to empty.

10
msdos/sed2v2.inp
View file

@ -38,6 +38,8 @@
/^#undef HAVE_CBRT *$/s/^.*$/#define HAVE_CBRT 1/
/^#undef HAVE_DIFFTIME *$/s/^.*$/#define HAVE_DIFFTIME 1/
/^#undef HAVE_FPATHCONF *$/s/^.*$/#define HAVE_FPATHCONF 1/
/^#undef HAVE_MEMCPY *$/s/^.*$/#define HAVE_MEMCPY 1/
/^#undef HAVE_MEMSET *$/s/^.*$/#define HAVE_MEMSET 1/
/^#undef HAVE_MEMCMP *$/s/^.*$/#define HAVE_MEMCMP 1/
/^#undef HAVE_MEMMOVE *$/s/^.*$/#define HAVE_MEMMOVE 1/
/^#undef HAVE_SETRLIMIT *$/s/^.*$/#define HAVE_SETRLIMIT 1/
@ -84,14 +86,6 @@ s/^#undef POINTER_TYPE *$/#define POINTER_TYPE void/
#else\
#undef HAVE_STDINT_H\
#endif
# GCC 3.x has a built-in bzero, which conflicts with the define at
# the end of config.in
/^#undef HAVE_BZERO/c\
#if __GNUC__ >= 3\
#define HAVE_BZERO 1\
#else\
#undef HAVE_BZERO\
#endif
# Comment out any remaining undef directives, because some of them
# might be defined in sys/config.h we include at the top of config.h.

5
nt/ChangeLog
View file

@ -1,3 +1,8 @@
2010-07-07 Andreas Schwab <schwab@linux-m68k.org>
* config.nt (HAVE_BCOPY, HAVE_BCMP): Remove undefs.
(HAVE_MEMCPY, HAVE_MEMMOVE, HAVE_MEMSET, HAVE_MEMCMP): Add undefs.
2010-07-02 Juanma Barranquero <lekktu@gmail.com>
* config.nt (__P): Remove.

6
nt/config.nt
View file

@ -212,8 +212,10 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#undef HAVE_SYSINFO
#undef HAVE_RANDOM
#undef HAVE_LRAND48
#undef HAVE_BCOPY
#undef HAVE_BCMP
#undef HAVE_MEMCPY
#undef HAVE_MEMMOVE
#undef HAVE_MEMSET
#undef HAVE_MEMCMP
#undef HAVE_LOGB
#undef HAVE_FREXP
#undef HAVE_FMOD

171
src/ChangeLog
View file

@ -1,3 +1,174 @@
2010-07-07 Andreas Schwab <schwab@linux-m68k.org>
* 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.
2010-07-07 Jan Djärv <jan.h.d@swipnet.se>
* process.c (kbd_is_on_hold): New variable.

87
src/alloc.c
View file

@ -636,10 +636,12 @@ overrun_check_malloc (size)
val = (unsigned char *) malloc (size + overhead);
if (val && check_depth == 1)
{
bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
memcpy (val, xmalloc_overrun_check_header,
XMALLOC_OVERRUN_CHECK_SIZE - 4);
val += XMALLOC_OVERRUN_CHECK_SIZE;
XMALLOC_PUT_SIZE(val, size);
bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
memcpy (val + size, xmalloc_overrun_check_trailer,
XMALLOC_OVERRUN_CHECK_SIZE);
}
--check_depth;
return (POINTER_TYPE *)val;
@ -659,28 +661,29 @@ overrun_check_realloc (block, size)
if (val
&& check_depth == 1
&& bcmp (xmalloc_overrun_check_header,
val - XMALLOC_OVERRUN_CHECK_SIZE,
XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
&& memcmp (xmalloc_overrun_check_header,
val - XMALLOC_OVERRUN_CHECK_SIZE,
XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
{
size_t osize = XMALLOC_GET_SIZE (val);
if (bcmp (xmalloc_overrun_check_trailer,
val + osize,
XMALLOC_OVERRUN_CHECK_SIZE))
if (memcmp (xmalloc_overrun_check_trailer, val + osize,
XMALLOC_OVERRUN_CHECK_SIZE))
abort ();
bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
memset (val + osize, 0, XMALLOC_OVERRUN_CHECK_SIZE);
val -= XMALLOC_OVERRUN_CHECK_SIZE;
bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE);
}
val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + overhead);
if (val && check_depth == 1)
{
bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
memcpy (val, xmalloc_overrun_check_header,
XMALLOC_OVERRUN_CHECK_SIZE - 4);
val += XMALLOC_OVERRUN_CHECK_SIZE;
XMALLOC_PUT_SIZE(val, size);
bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
memcpy (val + size, xmalloc_overrun_check_trailer,
XMALLOC_OVERRUN_CHECK_SIZE);
}
--check_depth;
return (POINTER_TYPE *)val;
@ -697,22 +700,21 @@ overrun_check_free (block)
++check_depth;
if (val
&& check_depth == 1
&& bcmp (xmalloc_overrun_check_header,
val - XMALLOC_OVERRUN_CHECK_SIZE,
XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
&& memcmp (xmalloc_overrun_check_header,
val - XMALLOC_OVERRUN_CHECK_SIZE,
XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
{
size_t osize = XMALLOC_GET_SIZE (val);
if (bcmp (xmalloc_overrun_check_trailer,
val + osize,
XMALLOC_OVERRUN_CHECK_SIZE))
if (memcmp (xmalloc_overrun_check_trailer, val + osize,
XMALLOC_OVERRUN_CHECK_SIZE))
abort ();
#ifdef XMALLOC_CLEAR_FREE_MEMORY
val -= XMALLOC_OVERRUN_CHECK_SIZE;
memset (val, 0xff, osize + XMALLOC_OVERRUN_CHECK_SIZE*2);
#else
bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
memset (val + osize, 0, XMALLOC_OVERRUN_CHECK_SIZE);
val -= XMALLOC_OVERRUN_CHECK_SIZE;
bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE);
#endif
}
@ -799,7 +801,7 @@ xstrdup (const char *s)
{
size_t len = strlen (s) + 1;
char *p = (char *) xmalloc (len);
bcopy (s, p, len);
memcpy (p, s, len);
return p;
}
@ -1873,7 +1875,7 @@ allocate_string (void)
int i;
b = (struct string_block *) lisp_malloc (sizeof *b, MEM_TYPE_STRING);
bzero (b, sizeof *b);
memset (b, 0, sizeof *b);
b->next = string_blocks;
string_blocks = b;
++n_string_blocks;
@ -1897,7 +1899,7 @@ allocate_string (void)
MALLOC_UNBLOCK_INPUT;
/* Probably not strictly necessary, but play it safe. */
bzero (s, sizeof *s);
memset (s, 0, sizeof *s);
--total_free_strings;
++total_strings;
@ -2005,8 +2007,7 @@ allocate_string_data (struct Lisp_String *s, int nchars, int nbytes)
s->size_byte = nbytes;
s->data[nbytes] = '\0';
#ifdef GC_CHECK_STRING_OVERRUN
bcopy (string_overrun_cookie, (char *) data + needed,
GC_STRING_OVERRUN_COOKIE_SIZE);
memcpy (data + needed, string_overrun_cookie, GC_STRING_OVERRUN_COOKIE_SIZE);
#endif
/* If S had already data assigned, mark that as free by setting its
@ -2197,9 +2198,9 @@ compact_small_strings (void)
from_end = (struct sdata *) ((char *) from + nbytes + GC_STRING_EXTRA);
#ifdef GC_CHECK_STRING_OVERRUN
if (bcmp (string_overrun_cookie,
((char *) from_end) - GC_STRING_OVERRUN_COOKIE_SIZE,
GC_STRING_OVERRUN_COOKIE_SIZE))
if (memcmp (string_overrun_cookie,
(char *) from_end - GC_STRING_OVERRUN_COOKIE_SIZE,
GC_STRING_OVERRUN_COOKIE_SIZE))
abort ();
#endif
@ -2221,7 +2222,7 @@ compact_small_strings (void)
if (from != to)
{
xassert (tb != b || to <= from);
safe_bcopy ((char *) from, (char *) to, nbytes + GC_STRING_EXTRA);
memmove (to, from, nbytes + GC_STRING_EXTRA);
to->string->data = SDATA_DATA (to);
}
@ -2280,7 +2281,7 @@ INIT must be an integer that represents a character. */)
end = p + nbytes;
while (p != end)
{
bcopy (str, p, len);
memcpy (p, str, len);
p += len;
}
}
@ -2362,7 +2363,7 @@ make_unibyte_string (const char *contents, int length)
{
register Lisp_Object val;
val = make_uninit_string (length);
bcopy (contents, SDATA (val), length);
memcpy (SDATA (val), contents, length);
STRING_SET_UNIBYTE (val);
return val;
}
@ -2376,7 +2377,7 @@ make_multibyte_string (const char *contents, int nchars, int nbytes)
{
register Lisp_Object val;
val = make_uninit_multibyte_string (nchars, nbytes);
bcopy (contents, SDATA (val), nbytes);
memcpy (SDATA (val), contents, nbytes);
return val;
}
@ -2389,7 +2390,7 @@ make_string_from_bytes (const char *contents, int nchars, int nbytes)
{
register Lisp_Object val;
val = make_uninit_multibyte_string (nchars, nbytes);
bcopy (contents, SDATA (val), nbytes);
memcpy (SDATA (val), contents, nbytes);
if (SBYTES (val) == SCHARS (val))
STRING_SET_UNIBYTE (val);
return val;
@ -2414,7 +2415,7 @@ make_specified_string (const char *contents, int nchars, int nbytes, int multiby
nchars = nbytes;
}
val = make_uninit_multibyte_string (nchars, nbytes);
bcopy (contents, SDATA (val), nbytes);
memcpy (SDATA (val), contents, nbytes);
if (!multibyte)
STRING_SET_UNIBYTE (val);
return val;
@ -2587,7 +2588,7 @@ make_float (double float_value)
new = (struct float_block *) lisp_align_malloc (sizeof *new,
MEM_TYPE_FLOAT);
new->next = float_block;
bzero ((char *) new->gcmarkbits, sizeof new->gcmarkbits);
memset (new->gcmarkbits, 0, sizeof new->gcmarkbits);
float_block = new;
float_block_index = 0;
n_float_blocks++;
@ -2709,7 +2710,7 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
register struct cons_block *new;
new = (struct cons_block *) lisp_align_malloc (sizeof *new,
MEM_TYPE_CONS);
bzero ((char *) new->gcmarkbits, sizeof new->gcmarkbits);
memset (new->gcmarkbits, 0, sizeof new->gcmarkbits);
new->next = cons_block;
cons_block = new;
cons_block_index = 0;
@ -2950,8 +2951,8 @@ allocate_terminal (void)
struct terminal *t = ALLOCATE_PSEUDOVECTOR (struct terminal,
next_terminal, PVEC_TERMINAL);
/* Zero out the non-GC'd fields. FIXME: This should be made unnecessary. */
bzero (&(t->next_terminal),
((char*)(t+1)) - ((char*)&(t->next_terminal)));
memset (&t->next_terminal, 0,
(char*) (t + 1) - (char*) &t->next_terminal);
return t;
}
@ -2962,8 +2963,8 @@ allocate_frame (void)
struct frame *f = ALLOCATE_PSEUDOVECTOR (struct frame,
face_cache, PVEC_FRAME);
/* Zero out the non-GC'd fields. FIXME: This should be made unnecessary. */
bzero (&(f->face_cache),
((char*)(f+1)) - ((char*)&(f->face_cache)));
memset (&f->face_cache, 0,
(char *) (f + 1) - (char *) &f->face_cache);
return f;
}
@ -4713,7 +4714,7 @@ make_pure_string (const char *data, int nchars, int nbytes, int multibyte)
if (s->data == NULL)
{
s->data = (unsigned char *) pure_alloc (nbytes + 1, -1);
bcopy (data, s->data, nbytes);
memcpy (s->data, data, nbytes);
s->data[nbytes] = '\0';
}
s->size = nchars;
@ -4980,9 +4981,9 @@ returns nil, because real GC can't be done. */)
if (stack_copy)
{
if ((EMACS_INT) (&stack_top_variable - stack_bottom) > 0)
bcopy (stack_bottom, stack_copy, i);
memcpy (stack_copy, stack_bottom, i);
else
bcopy (&stack_top_variable, stack_copy, i);
memcpy (stack_copy, &stack_top_variable, i);
}
}
}

4
src/atimer.c
View file

@ -116,7 +116,7 @@ start_atimer (enum atimer_type type, EMACS_TIME time, atimer_callback fn,
t = (struct atimer *) xmalloc (sizeof *t);
/* Fill the atimer structure. */
bzero (t, sizeof *t);
memset (t, 0, sizeof *t);
t->type = type;
t->fn = fn;
t->client_data = client_data;
@ -308,7 +308,7 @@ set_alarm (void)
EMACS_SET_USECS (time, 1000);
}
bzero (&it, sizeof it);
memset (&it, 0, sizeof it);
it.it_value = time;
setitimer (ITIMER_REAL, &it, 0);
#else /* not HAVE_SETITIMER */

12
src/buffer.c
View file

@ -514,7 +514,7 @@ clone_per_buffer_values (struct buffer *from, struct buffer *to)
PER_BUFFER_VALUE (to, offset) = obj;
}
bcopy (from->local_flags, to->local_flags, sizeof to->local_flags);
memcpy (to->local_flags, from->local_flags, sizeof to->local_flags);
to->overlays_before = copy_overlays (to, from->overlays_before);
to->overlays_after = copy_overlays (to, from->overlays_after);
@ -4413,8 +4413,8 @@ report_overlay_modification (Lisp_Object start, Lisp_Object end, int after,
Lisp_Object *copy = (Lisp_Object *) alloca (size * sizeof (Lisp_Object));
int i;
bcopy (XVECTOR (last_overlay_modification_hooks)->contents,
copy, size * sizeof (Lisp_Object));
memcpy (copy, XVECTOR (last_overlay_modification_hooks)->contents,
size * sizeof (Lisp_Object));
gcpro1.var = copy;
gcpro1.nvars = size;
@ -4877,7 +4877,7 @@ mmap_realloc (var, nbytes)
}
else if (mmap_alloc (var, nbytes))
{
bcopy (old_ptr, *var, r->nbytes_specified);
memcpy (*var, old_ptr, r->nbytes_specified);
mmap_free_1 (MMAP_REGION (old_ptr));
result = *var;
r = MMAP_REGION (result);
@ -5058,7 +5058,7 @@ init_buffer_once (void)
{
int idx;
bzero (buffer_permanent_local_flags, sizeof buffer_permanent_local_flags);
memset (buffer_permanent_local_flags, 0, sizeof buffer_permanent_local_flags);
/* Make sure all markable slots in buffer_defaults
are initialized reasonably, so mark_buffer won't choke. */
@ -5146,7 +5146,7 @@ init_buffer_once (void)
if (sizeof (EMACS_INT) != sizeof (Lisp_Object)) abort ();
/* 0 means not a lisp var, -1 means always local, else mask */
bzero (&buffer_local_flags, sizeof buffer_local_flags);
memset (&buffer_local_flags, 0, sizeof buffer_local_flags);
XSETINT (buffer_local_flags.filename, -1);
XSETINT (buffer_local_flags.directory, -1);
XSETINT (buffer_local_flags.backed_up, -1);

3
src/callint.c
View file

@ -348,8 +348,7 @@ invoke it. If KEYS is omitted or nil, the return value of
/* Make a copy of string so that if a GC relocates specs,
`string' will still be valid. */
string = (unsigned char *) alloca (SBYTES (specs) + 1);
bcopy (SDATA (specs), string,
SBYTES (specs) + 1);
memcpy (string, SDATA (specs), SBYTES (specs) + 1);
}
else
{

14
src/callproc.c
View file

@ -775,10 +775,8 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS) */)
PT_BYTE + process_coding.produced);
carryover = process_coding.carryover_bytes;
if (carryover > 0)
/* As CARRYOVER should not be that large, we had
better avoid overhead of bcopy. */
BCOPY_SHORT (process_coding.carryover, buf,
process_coding.carryover_bytes);
memcpy (buf, process_coding.carryover,
process_coding.carryover_bytes);
}
}
@ -916,7 +914,7 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
tempfile = (char *) alloca (SBYTES (pattern) + 1);
bcopy (SDATA (pattern), tempfile, SBYTES (pattern) + 1);
memcpy (tempfile, SDATA (pattern), SBYTES (pattern) + 1);
coding_systems = Qt;
#ifdef HAVE_MKSTEMP
@ -1099,8 +1097,8 @@ child_setup (int in, int out, int err, register char **new_argv, int set_pgrp, L
pwd_var = (char *) alloca (i + 6);
#endif
temp = pwd_var + 4;
bcopy ("PWD=", pwd_var, 4);
bcopy (SDATA (current_dir), temp, i);
memcpy (pwd_var, "PWD=", 4);
memcpy (temp, SDATA (current_dir), i);
if (!IS_DIRECTORY_SEP (temp[i - 1])) temp[i++] = DIRECTORY_SEP;
temp[i] = 0;
@ -1325,7 +1323,7 @@ getenv_internal_1 (char *var, int varlen, char **value, int *valuelen, Lisp_Obje
/* NT environment variables are case insensitive. */
&& ! strnicmp (SDATA (entry), var, varlen)
#else /* not WINDOWSNT */
&& ! bcmp (SDATA (entry), var, varlen)
&& ! memcmp (SDATA (entry), var, varlen)
#endif /* not WINDOWSNT */
)
{

2
src/casefiddle.c
View file

@ -128,7 +128,7 @@ casify_object (enum case_action flag, Lisp_Object obj)
unsigned char *old_dst = dst;
o_size += o_size; /* Probably overkill, but extremely rare. */
SAFE_ALLOCA (dst, void *, o_size);
bcopy (old_dst, dst, o - old_dst);
memcpy (dst, old_dst, o - old_dst);
o = dst + (o - old_dst);
}
c = STRING_CHAR_AND_LENGTH (SDATA (obj) + i_byte, len);

6
src/ccl.c
View file

@ -1715,7 +1715,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
msglen = strlen (msg);
if (dst + msglen <= (dst_bytes ? dst_end : src))
{
bcopy (msg, dst, msglen);
memcpy (dst, msg, msglen);
dst += msglen;
}
@ -1728,7 +1728,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
msglen = strlen (msg);
if (dst + msglen > (dst_bytes ? dst_end : src))
break;
bcopy (msg, dst, msglen);
memcpy (dst, msg, msglen);
dst += msglen;
}
goto ccl_finish;
@ -1761,7 +1761,7 @@ ccl_driver (struct ccl_program *ccl, int *source, int *destination, int src_size
int i = src_end - src;
if (dst_bytes && (dst_end - dst) < i)
i = dst_end - dst;
bcopy (src, dst, i);
memcpy (dst, src, i);
src += i;
dst += i;
#else

4
src/character.c
View file

@ -668,7 +668,7 @@ str_as_multibyte (unsigned char *str, int len, int nbytes, int *nchars)
to = p;
nbytes = endp - p;
endp = str + len;
safe_bcopy ((char *) p, (char *) (endp - nbytes), nbytes);
memmove (endp - nbytes, p, nbytes);
p = endp - nbytes;
if (nbytes >= MAX_MULTIBYTE_LENGTH)
@ -746,7 +746,7 @@ str_to_multibyte (unsigned char *str, int len, int bytes)
to = p;
bytes = endp - p;
endp = str + len;
safe_bcopy ((char *) p, (char *) (endp - bytes), bytes);
memmove (endp - bytes, p, bytes);
p = endp - bytes;
while (p < endp)
{

12
src/character.h
View file

@ -636,18 +636,6 @@ extern Lisp_Object Vauto_fill_chars;
extern Lisp_Object Vchar_script_table;
extern Lisp_Object Vscript_representative_chars;
/* Copy LEN bytes from FROM to TO. This macro should be used only
when a caller knows that LEN is short and the obvious copy loop is
faster than calling bcopy which has some overhead. Copying a
multibyte sequence of a character is the typical case. */
#define BCOPY_SHORT(from, to, len) \
do { \
int i = len; \
unsigned char *from_p = from, *to_p = to; \
while (i--) *to_p++ = *from_p++; \
} while (0)
#define DEFSYM(sym, name) \
do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0)

16
src/charset.c
View file

@ -522,7 +522,7 @@ load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile, int co
SAFE_ALLOCA (head, struct charset_map_entries *,
sizeof (struct charset_map_entries));
entries = head;
bzero (entries, sizeof (struct charset_map_entries));
memset (entries, 0, sizeof (struct charset_map_entries));
n_entries = 0;
eof = 0;
@ -549,7 +549,7 @@ load_charset_map_from_file (struct charset *charset, Lisp_Object mapfile, int co
SAFE_ALLOCA (entries->next, struct charset_map_entries *,
sizeof (struct charset_map_entries));
entries = entries->next;
bzero (entries, sizeof (struct charset_map_entries));
memset (entries, 0, sizeof (struct charset_map_entries));
}
idx = n_entries % 0x10000;
entries->entry[idx].from = from;
@ -585,7 +585,7 @@ load_charset_map_from_vector (struct charset *charset, Lisp_Object vec, int cont
SAFE_ALLOCA (head, struct charset_map_entries *,
sizeof (struct charset_map_entries));
entries = head;
bzero (entries, sizeof (struct charset_map_entries));
memset (entries, 0, sizeof (struct charset_map_entries));
n_entries = 0;
for (i = 0; i < len; i += 2)
@ -622,7 +622,7 @@ load_charset_map_from_vector (struct charset *charset, Lisp_Object vec, int cont
SAFE_ALLOCA (entries->next, struct charset_map_entries *,
sizeof (struct charset_map_entries));
entries = entries->next;
bzero (entries, sizeof (struct charset_map_entries));
memset (entries, 0, sizeof (struct charset_map_entries));
}
idx = n_entries % 0x10000;
entries->entry[idx].from = from;
@ -935,7 +935,7 @@ usage: (define-charset-internal ...) */)
if (! charset.code_linear_p)
{
charset.code_space_mask = (unsigned char *) xmalloc (256);
bzero (charset.code_space_mask, 256);
memset (charset.code_space_mask, 0, 256);
for (i = 0; i < 4; i++)
for (j = charset.code_space[i * 4]; j <= charset.code_space[i * 4 + 1];
j++)
@ -1058,7 +1058,7 @@ usage: (define-charset-internal ...) */)
charset.unified_p = 0;
bzero (charset.fast_map, sizeof (charset.fast_map));
memset (charset.fast_map, 0, sizeof (charset.fast_map));
if (! NILP (args[charset_arg_code_offset]))
{
@ -1191,8 +1191,8 @@ usage: (define-charset-internal ...) */)
struct charset *new_table
= (struct charset *) xmalloc (sizeof (struct charset)
* (charset_table_size + 16));
bcopy (charset_table, new_table,
sizeof (struct charset) * charset_table_size);
memcpy (new_table, charset_table,
sizeof (struct charset) * charset_table_size);
charset_table_size += 16;
charset_table = new_table;
}

2
src/cm.c
View file

@ -430,7 +430,7 @@ cmgoto (struct tty_display_info *tty, int row, int col)
void
Wcm_clear (struct tty_display_info *tty)
{
bzero (tty->Wcm, sizeof (struct cm));
memset (tty->Wcm, 0, sizeof (struct cm));
UP = 0;
BC = 0;
}

12
src/coding.c
View file

@ -6550,7 +6550,7 @@ decode_eol (struct coding_system *coding)
for (p = pend - 2; p >= pbeg; p--)
if (*p == '\r')
{
safe_bcopy ((char *) (p + 1), (char *) p, pend-- - p - 1);
memmove (p, p + 1, pend-- - p - 1);
n++;
}
}
@ -7814,7 +7814,7 @@ decode_coding_object (struct coding_system *coding,
}
if (BEGV < GPT && GPT < BEGV + coding->produced_char)
move_gap_both (BEGV, BEGV_BYTE);
bcopy (BEGV_ADDR, destination, coding->produced);
memcpy (destination, BEGV_ADDR, coding->produced);
coding->destination = destination;
}
}
@ -9482,7 +9482,7 @@ usage: (set-coding-system-priority &rest coding-systems) */)
int changed[coding_category_max];
enum coding_category priorities[coding_category_max];
bzero (changed, sizeof changed);
memset (changed, 0, sizeof changed);
for (i = j = 0; i < nargs; i++)
{
@ -9517,7 +9517,7 @@ usage: (set-coding-system-priority &rest coding-systems) */)
priorities[i] = coding_priorities[j];
}
bcopy (priorities, coding_priorities, sizeof priorities);
memcpy (coding_priorities, priorities, sizeof priorities);
/* Update `coding-category-list'. */
Vcoding_category_list = Qnil;
@ -9568,11 +9568,11 @@ make_subsidiaries (Lisp_Object base)
char *buf = (char *) alloca (base_name_len + 6);
int i;
bcopy (SDATA (SYMBOL_NAME (base)), buf, base_name_len);
memcpy (buf, SDATA (SYMBOL_NAME (base)), base_name_len);
subsidiaries = Fmake_vector (make_number (3), Qnil);
for (i = 0; i < 3; i++)
{
bcopy (suffixes[i], buf + base_name_len, strlen (suffixes[i]) + 1);
memcpy (buf + base_name_len, suffixes[i], strlen (suffixes[i]) + 1);
ASET (subsidiaries, i, intern (buf));
}
return subsidiaries;

23
src/config.in
View file

@ -102,15 +102,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
/* Define to 1 if ALSA is available. */
#undef HAVE_ALSA
/* Define to 1 if you have the `bcmp' function. */
#undef HAVE_BCMP
/* Define to 1 if you have the `bcopy' function. */
#undef HAVE_BCOPY
/* Define to 1 if you have the `bzero' function. */
#undef HAVE_BZERO
/* Define to 1 if you have the `cbrt' function. */
#undef HAVE_CBRT
@ -1141,10 +1132,6 @@ SYSTEM_PURESIZE_EXTRA seems like the least likely to cause problems. */
#include <string.h>
#endif
#ifdef HAVE_STRINGS_H
#include <strings.h> /* May be needed for bcopy & al. */
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
@ -1186,16 +1173,6 @@ typedef unsigned size_t;
# endif
#endif
#ifndef HAVE_BCOPY
#define bcopy(a,b,s) memcpy (b,a,s)
#endif
#ifndef HAVE_BZERO
#define bzero(a,s) memset (a,0,s)
#endif
#ifndef HAVE_BCMP
#define BCMP memcmp
#endif
#endif /* EMACS_CONFIG_H */
/*

8
src/data.c
View file

@ -2264,13 +2264,13 @@ bool-vector. IDX starts at 0. */)
USE_SAFE_ALLOCA;
SAFE_ALLOCA (str, unsigned char *, nbytes);
bcopy (SDATA (array), str, nbytes);
memcpy (str, SDATA (array), nbytes);
allocate_string_data (XSTRING (array), nchars,
nbytes + new_bytes - prev_bytes);
bcopy (str, SDATA (array), idxval_byte);
memcpy (SDATA (array), str, idxval_byte);
p1 = SDATA (array) + idxval_byte;
bcopy (str + idxval_byte + prev_bytes, p1 + new_bytes,
nbytes - (idxval_byte + prev_bytes));
memcpy (p1 + new_bytes, str + idxval_byte + prev_bytes,
nbytes - (idxval_byte + prev_bytes));
SAFE_FREE ();
clear_string_char_byte_cache ();
}

13
src/dired.c
View file

@ -289,15 +289,14 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full, Lisp_Object m
int nchars;
fullname = make_uninit_multibyte_string (nbytes, nbytes);
bcopy (SDATA (directory), SDATA (fullname),
directory_nbytes);
memcpy (SDATA (fullname), SDATA (directory),
directory_nbytes);
if (needsep)
SSET (fullname, directory_nbytes, DIRECTORY_SEP);
bcopy (SDATA (name),
SDATA (fullname) + directory_nbytes + needsep,
len);
memcpy (SDATA (fullname) + directory_nbytes + needsep,
SDATA (name), len);
nchars = chars_in_text (SDATA (fullname), nbytes);
@ -857,11 +856,11 @@ file_name_completion_stat (Lisp_Object dirname, DIRENTRY *dp, struct stat *st_ad
_djstat_flags = _STAT_INODE | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
#endif /* MSDOS */
bcopy (SDATA (dirname), fullname, pos);
memcpy (fullname, SDATA (dirname), pos);
if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
fullname[pos++] = DIRECTORY_SEP;
bcopy (dp->d_name, fullname + pos, len);
memcpy (fullname + pos, dp->d_name, len);
fullname[pos + len] = 0;
#ifdef S_IFLNK

95
src/dispnew.c
View file

@ -436,62 +436,15 @@ DEFUN ("dump-redisplay-history", Fdump_redisplay_history,
#endif /* GLYPH_DEBUG == 0 */
/* Like bcopy except never gets confused by overlap. Let this be the
first function defined in this file, or change emacs.c where the
address of this function is used. */
#ifdef PROFILING
/* FIXME: only used to find text start for profiling. */
void
safe_bcopy (const char *from, char *to, int size)
{
if (size <= 0 || from == to)
return;
/* If the source and destination don't overlap, then bcopy can
handle it. If they do overlap, but the destination is lower in
memory than the source, we'll assume bcopy can handle that. */
if (to < from || from + size <= to)
bcopy (from, to, size);
/* Otherwise, we'll copy from the end. */
else
{
register const char *endf = from + size;
register char *endt = to + size;
/* If TO - FROM is large, then we should break the copy into
nonoverlapping chunks of TO - FROM bytes each. However, if
TO - FROM is small, then the bcopy function call overhead
makes this not worth it. The crossover point could be about
anywhere. Since I don't think the obvious copy loop is too
bad, I'm trying to err in its favor. */
if (to - from < 64)
{
do
*--endt = *--endf;
while (endf != from);
}
else
{
for (;;)
{
endt -= (to - from);
endf -= (to - from);
if (endt < to)
break;
bcopy (endf, endt, to - from);
}
/* If SIZE wasn't a multiple of TO - FROM, there will be a
little left over. The amount left over is (endt + (to -
from)) - to, which is endt - from. */
bcopy (from, to, endt - from);
}
}
abort ();
}
#endif
/***********************************************************************
Glyph Matrices
@ -510,7 +463,7 @@ new_glyph_matrix (struct glyph_pool *pool)
/* Allocate and clear. */
result = (struct glyph_matrix *) xmalloc (sizeof *result);
bzero (result, sizeof *result);
memset (result, 0, sizeof *result);
/* Increment number of allocated matrices. This count is used
to detect memory leaks. */
@ -655,8 +608,8 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
int size = dim.height * sizeof (struct glyph_row);
new_rows = dim.height - matrix->rows_allocated;
matrix->rows = (struct glyph_row *) xrealloc (matrix->rows, size);
bzero (matrix->rows + matrix->rows_allocated,
new_rows * sizeof *matrix->rows);
memset (matrix->rows + matrix->rows_allocated, 0,
new_rows * sizeof *matrix->rows);
matrix->rows_allocated = dim.height;
}
else
@ -1103,7 +1056,7 @@ clear_glyph_row (struct glyph_row *row)
returned by xmalloc. If flickering happens again, activate
the code below. If the flickering is gone with that, chances
are that the flickering has the same reason as here. */
bzero (p[0], (char *) p[LAST_AREA] - (char *) p[0]);
memset (p[0], 0, (char *) p[LAST_AREA] - (char *) p[0]);
#endif
}
@ -1237,13 +1190,13 @@ copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
struct glyph *pointers[1 + LAST_AREA];
/* Save glyph pointers of TO. */
bcopy (to->glyphs, pointers, sizeof to->glyphs);
memcpy (pointers, to->glyphs, sizeof to->glyphs);
/* Do a structure assignment. */
*to = *from;
/* Restore original pointers of TO. */
bcopy (pointers, to->glyphs, sizeof to->glyphs);
memcpy (to->glyphs, pointers, sizeof to->glyphs);
}
@ -1264,8 +1217,8 @@ copy_glyph_row_contents (struct glyph_row *to, struct glyph_row *from, int delta
/* Copy glyphs from FROM to TO. */
for (area = 0; area < LAST_AREA; ++area)
if (from->used[area])
bcopy (from->glyphs[area], to->glyphs[area],
from->used[area] * sizeof (struct glyph));
memcpy (to->glyphs[area], from->glyphs[area],
from->used[area] * sizeof (struct glyph));
/* Increment buffer positions in TO by DELTA. */
increment_row_positions (to, delta, delta_bytes);
@ -1524,7 +1477,7 @@ new_glyph_pool (void)
/* Allocate a new glyph_pool and clear it. */
result = (struct glyph_pool *) xmalloc (sizeof *result);
bzero (result, sizeof *result);
memset (result, 0, sizeof *result);
/* For memory leak and double deletion checking. */
++glyph_pool_count;
@ -1585,7 +1538,7 @@ realloc_glyph_pool (struct glyph_pool *pool, struct dim matrix_dim)
else
{
pool->glyphs = (struct glyph *) xmalloc (size);
bzero (pool->glyphs, size);
memset (pool->glyphs, 0, size);
}
pool->nglyphs = needed;
@ -2196,11 +2149,11 @@ save_current_matrix (struct frame *f)
struct glyph_matrix *saved;
saved = (struct glyph_matrix *) xmalloc (sizeof *saved);
bzero (saved, sizeof *saved);
memset (saved, 0, sizeof *saved);
saved->nrows = f->current_matrix->nrows;
saved->rows = (struct glyph_row *) xmalloc (saved->nrows
* sizeof *saved->rows);
bzero (saved->rows, saved->nrows * sizeof *saved->rows);
memset (saved->rows, 0, saved->nrows * sizeof *saved->rows);
for (i = 0; i < saved->nrows; ++i)
{
@ -2208,7 +2161,7 @@ save_current_matrix (struct frame *f)
struct glyph_row *to = saved->rows + i;
size_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
to->glyphs[TEXT_AREA] = (struct glyph *) xmalloc (nbytes);
bcopy (from->glyphs[TEXT_AREA], to->glyphs[TEXT_AREA], nbytes);
memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes);
to->used[TEXT_AREA] = from->used[TEXT_AREA];
}
@ -2229,7 +2182,7 @@ restore_current_matrix (struct frame *f, struct glyph_matrix *saved)
struct glyph_row *from = saved->rows + i;
struct glyph_row *to = f->current_matrix->rows + i;
size_t nbytes = from->used[TEXT_AREA] * sizeof (struct glyph);
bcopy (from->glyphs[TEXT_AREA], to->glyphs[TEXT_AREA], nbytes);
memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA], nbytes);
to->used[TEXT_AREA] = from->used[TEXT_AREA];
xfree (from->glyphs[TEXT_AREA]);
}
@ -2740,9 +2693,9 @@ build_frame_matrix_from_leaf_window (struct glyph_matrix *frame_matrix, struct w
if (current_row_p)
{
/* Copy window row to frame row. */
bcopy (window_row->glyphs[0],
frame_row->glyphs[TEXT_AREA] + window_matrix->matrix_x,
window_matrix->matrix_w * sizeof (struct glyph));
memcpy (frame_row->glyphs[TEXT_AREA] + window_matrix->matrix_x,
window_row->glyphs[0],
window_matrix->matrix_w * sizeof (struct glyph));
}
else
{
@ -2979,7 +2932,7 @@ mirrored_line_dance (matrix, unchanged_at_top, nlines, copy_from,
/* Make a copy of the original rows. */
old_rows = (struct glyph_row *) alloca (nlines * sizeof *old_rows);
bcopy (new_rows, old_rows, nlines * sizeof *old_rows);
memcpy (old_rows, new_rows, nlines * sizeof *old_rows);
/* Assign new rows, maybe clear lines. */
for (i = 0; i < nlines; ++i)
@ -3097,7 +3050,7 @@ mirror_line_dance (struct window *w, int unchanged_at_top, int nlines, int *copy
/* Make a copy of the original rows of matrix m. */
old_rows = (struct glyph_row *) alloca (m->nrows * sizeof *old_rows);
bcopy (m->rows, old_rows, m->nrows * sizeof *old_rows);
memcpy (old_rows, m->rows, m->nrows * sizeof *old_rows);
for (i = 0; i < nlines; ++i)
{
@ -4563,7 +4516,7 @@ scrolling_window (struct window *w, int header_line_p)
row_table_size = next_almost_prime (3 * n);
nbytes = row_table_size * sizeof *row_table;
row_table = (struct row_entry **) xrealloc (row_table, nbytes);
bzero (row_table, nbytes);
memset (row_table, 0, nbytes);
}
if (n > row_entry_pool_size)

10
src/doc.c
View file

@ -686,7 +686,7 @@ the same file name is found in the `doc-directory'. */)
}
pos += end - buf;
filled -= end - buf;
bcopy (end, buf, filled);
memcpy (buf, end, filled);
}
emacs_close (fd);
return Qnil;
@ -765,7 +765,7 @@ a new string, without any text properties, is returned. */)
if (len == 1)
*bufp = *strp;
else
bcopy (strp, bufp, len);
memcpy (bufp, strp, len);
strp += len;
bufp += len;
nchars++;
@ -817,7 +817,7 @@ a new string, without any text properties, is returned. */)
int offset = bufp - buf;
buf = (unsigned char *) xrealloc (buf, bsize += 4);
bufp = buf + offset;
bcopy ("M-x ", bufp, 4);
memcpy (bufp, "M-x ", 4);
bufp += 4;
nchars += 4;
if (multibyte)
@ -911,7 +911,7 @@ a new string, without any text properties, is returned. */)
int offset = bufp - buf;
buf = (unsigned char *) xrealloc (buf, bsize += length_byte);
bufp = buf + offset;
bcopy (start, bufp, length_byte);
memcpy (bufp, start, length_byte);
bufp += length_byte;
nchars += length;
/* Check STRING again in case gc relocated it. */
@ -928,7 +928,7 @@ a new string, without any text properties, is returned. */)
if (len == 1)
*bufp = *strp;
else
bcopy (strp, bufp, len);
memcpy (bufp, strp, len);
strp += len;
bufp += len;
nchars++;

4
src/doprnt.c
View file

@ -229,12 +229,12 @@ doprnt (char *buffer, register int bufsize, char *format, char *format_end, int
/* Truncate the string at character boundary. */
tem = bufsize;
while (!CHAR_HEAD_P (string[tem - 1])) tem--;
bcopy (string, bufptr, tem);
memcpy (bufptr, string, tem);
/* We must calculate WIDTH again. */
width = strwidth (bufptr, tem);
}
else
bcopy (string, bufptr, tem);
memcpy (bufptr, string, tem);
bufptr += tem;
bufsize -= tem;
if (minlen < 0)

49
src/editfns.c
View file

@ -1405,7 +1405,7 @@ name, or nil if there is no such user. */)
login = Fuser_login_name (make_number (pw->pw_uid));
r = (unsigned char *) alloca (strlen (p) + SCHARS (login) + 1);
bcopy (p, r, q - p);
memcpy (r, p, q - p);
r[q - p] = 0;
strcat (r, SDATA (login));
r[q - p] = UPCASE (r[q - p]);
@ -2418,8 +2418,7 @@ make_buffer_string_both (int start, int start_byte, int end, int end_byte, int p
result = make_uninit_multibyte_string (end - start, end_byte - start_byte);
else
result = make_uninit_string (end - start);
bcopy (BYTE_POS_ADDR (start_byte), SDATA (result),
end_byte - start_byte);
memcpy (SDATA (result), BYTE_POS_ADDR (start_byte), end_byte - start_byte);
/* If desired, update and copy the text properties. */
if (props)
@ -3437,7 +3436,7 @@ usage: (message-box FORMAT-STRING &rest ARGS) */)
message_length = SBYTES (val);
message_text = (char *)xrealloc (message_text, message_length);
}
bcopy (SDATA (val), message_text, SBYTES (val));
memcpy (message_text, SDATA (val), SBYTES (val));
message2 (message_text, SBYTES (val),
STRING_MULTIBYTE (val));
return val;
@ -3654,12 +3653,12 @@ usage: (format STRING &rest OBJECTS) */)
int i;
if (!info)
info = (struct info *) alloca (nbytes);
bzero (info, nbytes);
memset (info, 0, nbytes);
for (i = 0; i <= nargs; i++)
info[i].start = -1;
if (!discarded)
SAFE_ALLOCA (discarded, char *, SBYTES (args[0]));
bzero (discarded, SBYTES (args[0]));
memset (discarded, 0, SBYTES (args[0]));
}
/* Add to TOTAL enough space to hold the converted arguments. */
@ -3973,8 +3972,8 @@ usage: (format STRING &rest OBJECTS) */)
{
int this_nchars;
bcopy (this_format_start, this_format,
format - this_format_start);
memcpy (this_format, this_format_start,
format - this_format_start);
this_format[format - this_format_start] = 0;
if (format[-1] == 'e' || format[-1] == 'f' || format[-1] == 'g')
@ -4451,9 +4450,9 @@ Transposing beyond buffer boundaries is an error. */)
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start2_addr, temp, len2_byte);
bcopy (start1_addr, start1_addr + len2_byte, len1_byte);
bcopy (temp, start1_addr, len2_byte);
memcpy (temp, start2_addr, len2_byte);
memcpy (start1_addr + len2_byte, start1_addr, len1_byte);
memcpy (start1_addr, temp, len2_byte);
SAFE_FREE ();
}
else
@ -4464,9 +4463,9 @@ Transposing beyond buffer boundaries is an error. */)
SAFE_ALLOCA (temp, unsigned char *, len1_byte);
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start1_addr, temp, len1_byte);
bcopy (start2_addr, start1_addr, len2_byte);
bcopy (temp, start1_addr + len2_byte, len1_byte);
memcpy (temp, start1_addr, len1_byte);
memcpy (start1_addr, start2_addr, len2_byte);
memcpy (start1_addr + len2_byte, temp, len1_byte);
SAFE_FREE ();
}
graft_intervals_into_buffer (tmp_interval1, start1 + len2,
@ -4504,9 +4503,9 @@ Transposing beyond buffer boundaries is an error. */)
SAFE_ALLOCA (temp, unsigned char *, len1_byte);
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start1_addr, temp, len1_byte);
bcopy (start2_addr, start1_addr, len2_byte);
bcopy (temp, start2_addr, len1_byte);
memcpy (temp, start1_addr, len1_byte);
memcpy (start1_addr, start2_addr, len2_byte);
memcpy (start2_addr, temp, len1_byte);
SAFE_FREE ();
graft_intervals_into_buffer (tmp_interval1, start2,
@ -4534,10 +4533,10 @@ Transposing beyond buffer boundaries is an error. */)
SAFE_ALLOCA (temp, unsigned char *, len2_byte);
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start2_addr, temp, len2_byte);
bcopy (start1_addr, start1_addr + len_mid + len2_byte, len1_byte);
safe_bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
bcopy (temp, start1_addr, len2_byte);
memcpy (temp, start2_addr, len2_byte);
memcpy (start1_addr + len_mid + len2_byte, start1_addr, len1_byte);
memmove (start1_addr + len2_byte, start1_addr + len1_byte, len_mid);
memcpy (start1_addr, temp, len2_byte);
SAFE_FREE ();
graft_intervals_into_buffer (tmp_interval1, end2 - len1,
@ -4567,10 +4566,10 @@ Transposing beyond buffer boundaries is an error. */)
SAFE_ALLOCA (temp, unsigned char *, len1_byte);
start1_addr = BYTE_POS_ADDR (start1_byte);
start2_addr = BYTE_POS_ADDR (start2_byte);
bcopy (start1_addr, temp, len1_byte);
bcopy (start2_addr, start1_addr, len2_byte);
bcopy (start1_addr + len1_byte, start1_addr + len2_byte, len_mid);
bcopy (temp, start1_addr + len2_byte + len_mid, len1_byte);
memcpy (temp, start1_addr, len1_byte);
memcpy (start1_addr, start2_addr, len2_byte);
memcpy (start1_addr + len2_byte, start1_addr + len1_byte, len_mid);
memcpy (start1_addr + len2_byte + len_mid, temp, len1_byte);
SAFE_FREE ();
graft_intervals_into_buffer (tmp_interval1, end2 - len1,

5
src/emacs.c
View file

@ -1761,13 +1761,14 @@ main (int argc, char **argv)
extern char etext;
#endif
extern void safe_bcopy ();
extern void dump_opcode_frequencies ();
atexit (_mcleanup);
/* This uses safe_bcopy because that function comes first in the
Emacs executable. It might be better to use something that
gives the start of the text segment, but start_of_text is not
defined on all systems now. */
/* FIXME: Does not work on architectures with function
descriptors. */
monstartup (safe_bcopy, &etext);
}
else
@ -2058,7 +2059,7 @@ sort_args (int argc, char **argv)
while (to < argc)
new[to++] = 0;
bcopy (new, argv, sizeof (char *) * argc);
memcpy (argv, new, sizeof (char *) * argc);
xfree (options);
xfree (new);

4
src/eval.c
View file

@ -2529,7 +2529,7 @@ usage: (apply FUNCTION &rest ARGUMENTS) */)
gcpro1.nvars = 1 + numargs;
}
bcopy (args, funcall_args, nargs * sizeof (Lisp_Object));
memcpy (funcall_args, args, nargs * sizeof (Lisp_Object));
/* Spread the last arg we got. Its first element goes in
the slot that it used to occupy, hence this value of I. */
i = nargs - 1;
@ -3018,7 +3018,7 @@ usage: (funcall FUNCTION &rest ARGUMENTS) */)
if (XSUBR (fun)->max_args > numargs)
{
internal_args = (Lisp_Object *) alloca (XSUBR (fun)->max_args * sizeof (Lisp_Object));
bcopy (args + 1, internal_args, numargs * sizeof (Lisp_Object));
memcpy (internal_args, args + 1, numargs * sizeof (Lisp_Object));
for (i = numargs; i < XSUBR (fun)->max_args; i++)
internal_args[i] = Qnil;
}

24
src/fileio.c
View file

@ -425,7 +425,7 @@ Given a Unix syntax file name, returns a string ending in slash. */)
filename = FILE_SYSTEM_CASE (filename);
#ifdef DOS_NT
beg = (unsigned char *) alloca (SBYTES (filename) + 1);
bcopy (SDATA (filename), beg, SBYTES (filename) + 1);
memcpy (beg, SDATA (filename), SBYTES (filename) + 1);
#else
beg = SDATA (filename);
#endif
@ -725,10 +725,10 @@ make_temp_name (Lisp_Object prefix, int base64_p)
if (!STRING_MULTIBYTE (prefix))
STRING_SET_UNIBYTE (val);
data = SDATA (val);
bcopy(SDATA (prefix), data, len);
memcpy (data, SDATA (prefix), len);
p = data + len;
bcopy (pidbuf, p, pidlen);
memcpy (p, pidbuf, pidlen);
p += pidlen;
/* Here we try to minimize useless stat'ing when this function is
@ -939,7 +939,7 @@ filesystem tree, not (expand-file-name ".." dirname). */)
/* Make a local copy of nm[] to protect it from GC in DECODE_FILE below. */
nm = (unsigned char *) alloca (SBYTES (name) + 1);
bcopy (SDATA (name), nm, SBYTES (name) + 1);
memcpy (nm, SDATA (name), SBYTES (name) + 1);
#ifdef DOS_NT
/* Note if special escape prefix is present, but remove for now. */
@ -1093,7 +1093,7 @@ filesystem tree, not (expand-file-name ".." dirname). */)
unsigned char *o, *p;
for (p = nm; *p && (!IS_DIRECTORY_SEP (*p)); p++);
o = alloca (p - nm + 1);
bcopy ((char *) nm, o, p - nm);
memcpy (o, nm, p - nm);
o [p - nm] = 0;
BLOCK_INPUT;
@ -1244,7 +1244,7 @@ filesystem tree, not (expand-file-name ".." dirname). */)
)
{
unsigned char *temp = (unsigned char *) alloca (length);
bcopy (newdir, temp, length - 1);
memcpy (temp, newdir, length - 1);
temp[length - 1] = 0;
newdir = temp;
}
@ -1467,7 +1467,7 @@ See also the function `substitute-in-file-name'.")
int len = ptr ? ptr - user : strlen (user);
/* Copy the user name into temp storage. */
o = (unsigned char *) alloca (len + 1);
bcopy ((char *) user, o, len);
memcpy (o, user, len);
o[len] = 0;
/* Look up the user name. */
@ -1583,7 +1583,7 @@ search_embedded_absfilename (unsigned char *nm, unsigned char *endp)
{
unsigned char *o = alloca (s - p + 1);
struct passwd *pw;
bcopy (p, o, s - p);
memcpy (o, p, s - p);
o [s - p] = 0;
/* If we have ~user and `user' exists, discard
@ -1640,7 +1640,7 @@ those `/' is discarded. */)
decode of environment variables, causing the original Lisp_String
data to be relocated. */
nm = (unsigned char *) alloca (SBYTES (filename) + 1);
bcopy (SDATA (filename), nm, SBYTES (filename) + 1);
memcpy (nm, SDATA (filename), SBYTES (filename) + 1);
#ifdef DOS_NT
dostounix_filename (nm);
@ -2733,7 +2733,7 @@ points to a nonexistent file. */)
{
bufsize *= 2;
buf = (char *) xrealloc (buf, bufsize);
bzero (buf, bufsize);
memset (buf, 0, bufsize);
errno = 0;
valsize = readlink (SDATA (filename), buf, bufsize);
@ -3837,7 +3837,7 @@ variable `last-coding-system-used' to the coding system actually used. */)
conversion_buffer);
unprocessed = coding.carryover_bytes;
if (coding.carryover_bytes > 0)
bcopy (coding.carryover, read_buf, unprocessed);
memcpy (read_buf, coding.carryover, unprocessed);
}
UNGCPRO;
emacs_close (fd);
@ -5245,7 +5245,7 @@ auto_save_error (Lisp_Object error)
GCPRO1 (msg);
nbytes = SBYTES (msg);
SAFE_ALLOCA (msgbuf, char *, nbytes);
bcopy (SDATA (msg), msgbuf, nbytes);
memcpy (msgbuf, SDATA (msg), nbytes);
for (i = 0; i < 3; ++i)
{

32
src/fns.c
View file

@ -233,7 +233,7 @@ Symbols are also allowed; their print names are used instead. */)
if (SCHARS (s1) != SCHARS (s2)
|| SBYTES (s1) != SBYTES (s2)
|| bcmp (SDATA (s1), SDATA (s2), SBYTES (s1)))
|| memcmp (SDATA (s1), SDATA (s2), SBYTES (s1)))
return Qnil;
return Qt;
}
@ -469,8 +469,8 @@ with the original. */)
/ BOOL_VECTOR_BITS_PER_CHAR);
val = Fmake_bool_vector (Flength (arg), Qnil);
bcopy (XBOOL_VECTOR (arg)->data, XBOOL_VECTOR (val)->data,
size_in_chars);
memcpy (XBOOL_VECTOR (val)->data, XBOOL_VECTOR (arg)->data,
size_in_chars);
return val;
}
@ -637,8 +637,7 @@ concat (int nargs, Lisp_Object *args, enum Lisp_Type target_type, int last_speci
{
int thislen_byte = SBYTES (this);
bcopy (SDATA (this), SDATA (val) + toindex_byte,
SBYTES (this));
memcpy (SDATA (val) + toindex_byte, SDATA (this), SBYTES (this));
if (! NULL_INTERVAL_P (STRING_INTERVALS (this)))
{
textprops[num_textprops].argnum = argnum;
@ -953,7 +952,7 @@ string_to_multibyte (Lisp_Object string)
return make_multibyte_string (SDATA (string), nbytes, nbytes);
SAFE_ALLOCA (buf, unsigned char *, nbytes);
bcopy (SDATA (string), buf, SBYTES (string));
memcpy (buf, SDATA (string), SBYTES (string));
str_to_multibyte (buf, nbytes, SBYTES (string));
ret = make_multibyte_string (buf, SCHARS (string), nbytes);
@ -1039,7 +1038,7 @@ If STRING is multibyte and contains a character of charset
int bytes = SBYTES (string);
unsigned char *str = (unsigned char *) xmalloc (bytes);
bcopy (SDATA (string), str, bytes);
memcpy (str, SDATA (string), bytes);
bytes = str_as_unibyte (str, bytes);
string = make_unibyte_string (str, bytes);
xfree (str);
@ -1076,8 +1075,7 @@ If you're not sure, whether to use `string-as-multibyte' or
SBYTES (string),
&nchars, &nbytes);
new_string = make_uninit_multibyte_string (nchars, nbytes);
bcopy (SDATA (string), SDATA (new_string),
SBYTES (string));
memcpy (SDATA (new_string), SDATA (string), SBYTES (string));
if (nbytes != SBYTES (string))
str_as_multibyte (SDATA (new_string), nbytes,
SBYTES (string), NULL);
@ -2170,8 +2168,8 @@ internal_equal (register Lisp_Object o1, register Lisp_Object o2, int depth, int
if (XBOOL_VECTOR (o1)->size != XBOOL_VECTOR (o2)->size)
return 0;
if (bcmp (XBOOL_VECTOR (o1)->data, XBOOL_VECTOR (o2)->data,
size_in_chars))
if (memcmp (XBOOL_VECTOR (o1)->data, XBOOL_VECTOR (o2)->data,
size_in_chars))
return 0;
return 1;
}
@ -2205,8 +2203,7 @@ internal_equal (register Lisp_Object o1, register Lisp_Object o2, int depth, int
return 0;
if (SBYTES (o1) != SBYTES (o2))
return 0;
if (bcmp (SDATA (o1), SDATA (o2),
SBYTES (o1)))
if (memcmp (SDATA (o1), SDATA (o2), SBYTES (o1)))
return 0;
if (props && !compare_string_intervals (o1, o2))
return 0;
@ -2304,7 +2301,7 @@ This makes STRING unibyte and may change its length. */)
int len;
CHECK_STRING (string);
len = SBYTES (string);
bzero (SDATA (string), len);
memset (SDATA (string), 0, len);
STRING_SET_CHARS (string, len);
STRING_SET_UNIBYTE (string);
return Qnil;
@ -3709,8 +3706,7 @@ larger_vector (Lisp_Object vec, int new_size, Lisp_Object init)
xassert (new_size >= old_size);
v = allocate_vector (new_size);
bcopy (XVECTOR (vec)->contents, v->contents,
old_size * sizeof *v->contents);
memcpy (v->contents, XVECTOR (vec)->contents, old_size * sizeof *v->contents);
for (i = old_size; i < new_size; ++i)
v->contents[i] = init;
XSETVECTOR (vec, v);
@ -3947,7 +3943,7 @@ copy_hash_table (struct Lisp_Hash_Table *h1)
h2 = allocate_hash_table ();
next = h2->vec_next;
bcopy (h1, h2, sizeof *h2);
memcpy (h2, h1, sizeof *h2);
h2->vec_next = next;
h2->key_and_value = Fcopy_sequence (h1->key_and_value);
h2->hash = Fcopy_sequence (h1->hash);
@ -4553,7 +4549,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS) */)
/* The vector `used' is used to keep track of arguments that
have been consumed. */
used = (char *) alloca (nargs * sizeof *used);
bzero (used, nargs * sizeof *used);
memset (used, 0, nargs * sizeof *used);
/* See if there's a `:test TEST' among the arguments. */
i = get_key_arg (QCtest, nargs, args, used);

2
src/fringe.c
View file

@ -1493,7 +1493,7 @@ If BITMAP already exists, the existing definition is replaced. */)
xfb = (struct fringe_bitmap *) xmalloc (sizeof fb
+ fb.height * BYTES_PER_BITMAP_ROW);
fb.bits = b = (unsigned short *) (xfb + 1);
bzero (b, fb.height);
memset (b, 0, fb.height);
j = 0;
while (j < fb.height)

2
src/ftfont.c
View file

@ -1365,7 +1365,7 @@ ftfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct
if (ftfont_info->ft_size != ft_face->size)
FT_Activate_Size (ftfont_info->ft_size);
if (metrics)
bzero (metrics, sizeof (struct font_metrics));
memset (metrics, 0, sizeof (struct font_metrics));
for (i = 0, first = 1; i < nglyphs; i++)
{
if (FT_Load_Glyph (ft_face, code[i], FT_LOAD_DEFAULT) == 0)

2
src/getloadavg.c
View file

@ -713,7 +713,7 @@ getloadavg (loadavg, nelem)
for (i = 0; i < conf.config_maxclass; ++i)
{
struct class_stats stats;
bzero ((char *) &stats, sizeof stats);
memset (&stats, 0, sizeof stats);
desc.sd_type = CPUTYPE_CLASS;
desc.sd_objid = i;

64
src/image.c
View file

@ -625,7 +625,7 @@ define_image_type (struct image_type *type, int loaded)
/* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
The initialized data segment is read-only. */
struct image_type *p = (struct image_type *) xmalloc (sizeof *p);
bcopy (type, p, sizeof *p);
memcpy (p, type, sizeof *p);
p->next = image_types;
image_types = p;
success = Qt;
@ -1020,7 +1020,7 @@ make_image (Lisp_Object spec, unsigned int hash)
Lisp_Object file = image_spec_value (spec, QCfile, NULL);
xassert (valid_image_p (spec));
bzero (img, sizeof *img);
memset (img, 0, sizeof *img);
img->dependencies = NILP (file) ? Qnil : list1 (file);
img->type = lookup_image_type (image_spec_value (spec, QCtype, NULL));
xassert (img->type != NULL);
@ -1424,12 +1424,12 @@ make_image_cache (void)
struct image_cache *c = (struct image_cache *) xmalloc (sizeof *c);
int size;
bzero (c, sizeof *c);
memset (c, 0, sizeof *c);
c->size = 50;
c->images = (struct image **) xmalloc (c->size * sizeof *c->images);
size = IMAGE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
c->buckets = (struct image **) xmalloc (size);
bzero (c->buckets, size);
memset (c->buckets, 0, size);
return c;
}
@ -2048,8 +2048,8 @@ x_create_x_image_and_pixmap (struct frame *f, int width, int height, int depth,
return 0;
}
header = &((*ximg)->info.bmiHeader);
bzero (&((*ximg)->info), sizeof (BITMAPINFO));
header = &(*ximg)->info.bmiHeader;
memset (&(*ximg)->info, 0, sizeof (BITMAPINFO));
header->biSize = sizeof (*header);
header->biWidth = width;
header->biHeight = -height; /* negative indicates a top-down bitmap. */
@ -2353,7 +2353,7 @@ xbm_image_p (Lisp_Object object)
{
struct image_keyword kw[XBM_LAST];
bcopy (xbm_format, kw, sizeof kw);
memcpy (kw, xbm_format, sizeof kw);
if (!parse_image_spec (object, kw, XBM_LAST, Qxbm))
return 0;
@ -2543,7 +2543,7 @@ w32_create_pixmap_from_bitmap_data (int width, int height, char *data)
w1 = (width + 7) / 8; /* nb of 8bits elt in X bitmap */
w2 = ((width + 15) / 16) * 2; /* nb of 16bits elt in W32 bitmap */
bits = (unsigned char *) alloca (height * w2);
bzero (bits, height * w2);
memset (bits, 0, height * w2);
for (i = 0; i < height; i++)
{
p = bits + i*w2;
@ -2918,7 +2918,7 @@ xbm_load (struct frame *f, struct image *img)
in_memory_file_p = xbm_file_p (data);
/* Parse the image specification. */
bcopy (xbm_format, fmt, sizeof fmt);
memcpy (fmt, xbm_format, sizeof fmt);
parsed_p = parse_image_spec (img->spec, fmt, XBM_LAST, Qxbm);
xassert (parsed_p);
@ -2964,9 +2964,9 @@ xbm_load (struct frame *f, struct image *img)
{
Lisp_Object line = XVECTOR (data)->contents[i];
if (STRINGP (line))
bcopy (SDATA (line), p, nbytes);
memcpy (p, SDATA (line), nbytes);
else
bcopy (XBOOL_VECTOR (line)->data, p, nbytes);
memcpy (p, XBOOL_VECTOR (line)->data, nbytes);
}
}
else if (STRINGP (data))
@ -3248,7 +3248,7 @@ xpm_lookup_color (struct frame *f, char *color_name, XColor *color)
with transparency, and it's useful. */
else if (strcmp ("opaque", color_name) == 0)
{
bzero (color, sizeof (XColor)); /* Is this necessary/correct? */
memset (color, 0, sizeof (XColor)); /* Is this necessary/correct? */
color->pixel = FRAME_FOREGROUND_PIXEL (f);
p = xpm_cache_color (f, color_name, color, h);
}
@ -3337,7 +3337,7 @@ static int
xpm_image_p (Lisp_Object object)
{
struct image_keyword fmt[XPM_LAST];
bcopy (xpm_format, fmt, sizeof fmt);
memcpy (fmt, xpm_format, sizeof fmt);
return (parse_image_spec (object, fmt, XPM_LAST, Qxpm)
/* Either `:file' or `:data' must be present. */
&& fmt[XPM_FILE].count + fmt[XPM_DATA].count == 1
@ -3358,7 +3358,7 @@ x_create_bitmap_from_xpm_data (struct frame *f, char **bits)
XpmAttributes attrs;
Pixmap bitmap, mask;
bzero (&attrs, sizeof attrs);
memset (&attrs, 0, sizeof attrs);
attrs.visual = FRAME_X_VISUAL (f);
attrs.colormap = FRAME_X_COLORMAP (f);
@ -3406,7 +3406,7 @@ xpm_load (struct frame *f, struct image *img)
/* Configure the XPM lib. Use the visual of frame F. Allocate
close colors. Return colors allocated. */
bzero (&attrs, sizeof attrs);
memset (&attrs, 0, sizeof attrs);
#ifndef HAVE_NTGUI
attrs.visual = FRAME_X_VISUAL (f);
@ -3453,7 +3453,7 @@ xpm_load (struct frame *f, struct image *img)
/* Allocate an XpmColorSymbol array. */
size = attrs.numsymbols * sizeof *xpm_syms;
xpm_syms = (XpmColorSymbol *) alloca (size);
bzero (xpm_syms, size);
memset (xpm_syms, 0, size);
attrs.colorsymbols = xpm_syms;
/* Fill the color symbol array. */
@ -4152,7 +4152,7 @@ init_color_table (void)
{
int size = CT_SIZE * sizeof (*ct_table);
ct_table = (struct ct_color **) xmalloc (size);
bzero (ct_table, size);
memset (ct_table, 0, size);
ct_colors_allocated = 0;
}
@ -4848,7 +4848,7 @@ x_build_heuristic_mask (struct frame *f, struct image *img, Lisp_Object how)
/* Create the bit array serving as mask. */
row_width = (img->width + 7) / 8;
mask_img = xmalloc (row_width * img->height);
bzero (mask_img, row_width * img->height);
memset (mask_img, 0, row_width * img->height);
/* Create a memory device context for IMG->pixmap. */
frame_dc = get_frame_dc (f);
@ -5000,7 +5000,7 @@ pbm_image_p (Lisp_Object object)
{
struct image_keyword fmt[PBM_LAST];
bcopy (pbm_format, fmt, sizeof fmt);
memcpy (fmt, pbm_format, sizeof fmt);
if (!parse_image_spec (object, fmt, PBM_LAST, Qpbm))
return 0;
@ -5212,7 +5212,7 @@ pbm_load (struct frame *f, struct image *img)
unsigned long bg = FRAME_BACKGROUND_PIXEL (f);
/* Parse the image specification. */
bcopy (pbm_format, fmt, sizeof fmt);
memcpy (fmt, pbm_format, sizeof fmt);
parse_image_spec (img->spec, fmt, PBM_LAST, Qpbm);
/* Get foreground and background colors, maybe allocate colors. */
@ -5415,7 +5415,7 @@ static int
png_image_p (Lisp_Object object)
{
struct image_keyword fmt[PNG_LAST];
bcopy (png_format, fmt, sizeof fmt);
memcpy (fmt, png_format, sizeof fmt);
if (!parse_image_spec (object, fmt, PNG_LAST, Qpng))
return 0;
@ -5554,7 +5554,7 @@ png_read_from_memory (png_structp png_ptr, png_bytep data, png_size_t length)
if (length > tbr->len - tbr->index)
fn_png_error (png_ptr, "Read error");
bcopy (tbr->bytes + tbr->index, data, length);
memcpy (data, tbr->bytes + tbr->index, length);
tbr->index = tbr->index + length;
}
@ -5756,7 +5756,7 @@ png_load (struct frame *f, struct image *img)
{
png_color_16 user_bg;
bzero (&user_bg, sizeof user_bg);
memset (&user_bg, 0, sizeof user_bg);
user_bg.red = color.red >> shift;
user_bg.green = color.green >> shift;
user_bg.blue = color.blue >> shift;
@ -5776,7 +5776,7 @@ png_load (struct frame *f, struct image *img)
color.pixel = FRAME_BACKGROUND_PIXEL (f);
x_query_color (f, &color);
bzero (&frame_background, sizeof frame_background);
memset (&frame_background, 0, sizeof frame_background);
frame_background.red = color.red >> shift;
frame_background.green = color.green >> shift;
frame_background.blue = color.blue >> shift;
@ -6005,7 +6005,7 @@ jpeg_image_p (Lisp_Object object)
{
struct image_keyword fmt[JPEG_LAST];
bcopy (jpeg_format, fmt, sizeof fmt);
memcpy (fmt, jpeg_format, sizeof fmt);
if (!parse_image_spec (object, fmt, JPEG_LAST, Qjpeg))
return 0;
@ -6561,7 +6561,7 @@ static int
tiff_image_p (Lisp_Object object)
{
struct image_keyword fmt[TIFF_LAST];
bcopy (tiff_format, fmt, sizeof fmt);
memcpy (fmt, tiff_format, sizeof fmt);
if (!parse_image_spec (object, fmt, TIFF_LAST, Qtiff))
return 0;
@ -6644,7 +6644,7 @@ tiff_read_from_memory (thandle_t data, tdata_t buf, tsize_t size)
if (size > src->len - src->index)
return (size_t) -1;
bcopy (src->bytes + src->index, buf, size);
memcpy (buf, src->bytes + src->index, size);
src->index += size;
return size;
}
@ -6999,7 +6999,7 @@ static int
gif_image_p (Lisp_Object object)
{
struct image_keyword fmt[GIF_LAST];
bcopy (gif_format, fmt, sizeof fmt);
memcpy (fmt, gif_format, sizeof fmt);
if (!parse_image_spec (object, fmt, GIF_LAST, Qgif))
return 0;
@ -7086,7 +7086,7 @@ gif_read_from_memory (GifFileType *file, GifByteType *buf, int len)
if (len > src->len - src->index)
return -1;
bcopy (src->bytes + src->index, buf, len);
memcpy (buf, src->bytes + src->index, len);
src->index += len;
return len;
}
@ -7222,7 +7222,7 @@ gif_load (struct frame *f, struct image *img)
if (!gif_color_map)
gif_color_map = gif->SColorMap;
init_color_table ();
bzero (pixel_colors, sizeof pixel_colors);
memset (pixel_colors, 0, sizeof pixel_colors);
if (gif_color_map)
for (i = 0; i < gif_color_map->ColorCount; ++i)
@ -7432,7 +7432,7 @@ static int
svg_image_p (Lisp_Object object)
{
struct image_keyword fmt[SVG_LAST];
bcopy (svg_format, fmt, sizeof fmt);
memcpy (fmt, svg_format, sizeof fmt);
if (!parse_image_spec (object, fmt, SVG_LAST, Qsvg))
return 0;
@ -7839,7 +7839,7 @@ gs_image_p (Lisp_Object object)
Lisp_Object tem;
int i;
bcopy (gs_format, fmt, sizeof fmt);
memcpy (fmt, gs_format, sizeof fmt);
if (!parse_image_spec (object, fmt, GS_LAST, Qpostscript))
return 0;

4
src/indent.c
View file

@ -546,7 +546,7 @@ scan_for_column (EMACS_INT *endpos, EMACS_INT *goalcol, EMACS_INT *prevcol)
w = ! NILP (window) ? XWINDOW (window) : NULL;
if (tab_width <= 0 || tab_width > 1000) tab_width = 8;
bzero (&cmp_it, sizeof cmp_it);
memset (&cmp_it, 0, sizeof cmp_it);
cmp_it.id = -1;
composition_compute_stop_pos (&cmp_it, scan, scan_byte, end, Qnil);
@ -1214,7 +1214,7 @@ compute_motion (EMACS_INT from, EMACS_INT fromvpos, EMACS_INT fromhpos, int did_
pos_byte = prev_pos_byte = CHAR_TO_BYTE (from);
contin_hpos = 0;
prev_tab_offset = tab_offset;
bzero (&cmp_it, sizeof cmp_it);
memset (&cmp_it, 0, sizeof cmp_it);
cmp_it.id = -1;
composition_compute_stop_pos (&cmp_it, pos, pos_byte, to, Qnil);

62
src/insdel.c
View file

@ -164,28 +164,9 @@ gap_left (EMACS_INT charpos, EMACS_INT bytepos, int newgap)
/* Move at most 32000 chars before checking again for a quit. */
if (i > 32000)
i = 32000;
#ifdef GAP_USE_BCOPY
if (i >= 128
/* bcopy is safe if the two areas of memory do not overlap
or on systems where bcopy is always safe for moving upward. */
&& (BCOPY_UPWARD_SAFE
|| to - from >= 128))
{
/* If overlap is not safe, avoid it by not moving too many
characters at once. */
if (!BCOPY_UPWARD_SAFE && i > to - from)
i = to - from;
new_s1 -= i;
from -= i, to -= i;
bcopy (from, to, i);
}
else
#endif
{
new_s1 -= i;
while (--i >= 0)
*--to = *--from;
}
new_s1 -= i;
from -= i, to -= i;
memmove (to, from, i);
}
/* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
@ -238,28 +219,9 @@ gap_right (EMACS_INT charpos, EMACS_INT bytepos)
/* Move at most 32000 chars before checking again for a quit. */
if (i > 32000)
i = 32000;
#ifdef GAP_USE_BCOPY
if (i >= 128
/* bcopy is safe if the two areas of memory do not overlap
or on systems where bcopy is always safe for moving downward. */
&& (BCOPY_DOWNWARD_SAFE
|| from - to >= 128))
{
/* If overlap is not safe, avoid it by not moving too many
characters at once. */
if (!BCOPY_DOWNWARD_SAFE && i > from - to)
i = from - to;
new_s1 += i;
bcopy (from, to, i);
from += i, to += i;
}
else
#endif
{
new_s1 += i;
while (--i >= 0)
*to++ = *from++;
}
new_s1 += i;
memmove (to, from, i);
from += i, to += i;
}
adjust_markers_gap_motion (GPT_BYTE + GAP_SIZE, bytepos + GAP_SIZE,
@ -585,7 +547,7 @@ make_gap_smaller (EMACS_INT nbytes_removed)
/* Pretend that the last unwanted part of the gap is the entire gap,
and that the first desired part of the gap is part of the buffer
text. */
bzero (GPT_ADDR, new_gap_size);
memset (GPT_ADDR, 0, new_gap_size);
GPT += new_gap_size;
GPT_BYTE += new_gap_size;
Z += new_gap_size;
@ -636,7 +598,7 @@ copy_text (const unsigned char *from_addr, unsigned char *to_addr,
{
if (from_multibyte == to_multibyte)
{
bcopy (from_addr, to_addr, nbytes);
memcpy (to_addr, from_addr, nbytes);
return nbytes;
}
else if (from_multibyte)
@ -966,7 +928,7 @@ insert_1_both (const unsigned char *string,
MODIFF++;
CHARS_MODIFF = MODIFF;
bcopy (string, GPT_ADDR, nbytes);
memcpy (GPT_ADDR, string, nbytes);
GAP_SIZE -= nbytes;
GPT += nchars;
@ -1007,7 +969,7 @@ insert_1_both (const unsigned char *string,
copy them into the buffer.
It does not work to use `insert' for this, because a GC could happen
before we bcopy the stuff into the buffer, and relocate the string
before we copy the stuff into the buffer, and relocate the string
without insert noticing. */
void
@ -1182,7 +1144,7 @@ insert_from_gap (EMACS_INT nchars, EMACS_INT nbytes)
into the current buffer.
It does not work to use `insert' for this, because a malloc could happen
and relocate BUF's text before the bcopy happens. */
and relocate BUF's text before the copy happens. */
void
insert_from_buffer (struct buffer *buf,
@ -1712,7 +1674,7 @@ replace_range_2 (EMACS_INT from, EMACS_INT from_byte,
make_gap (insbytes - GAP_SIZE);
/* Copy the replacement text into the buffer. */
bcopy (ins, GPT_ADDR, insbytes);
memcpy (GPT_ADDR, ins, insbytes);
#ifdef BYTE_COMBINING_DEBUG
/* We have copied text into the gap, but we have not marked

4
src/intervals.c
View file

@ -1558,7 +1558,7 @@ reproduce_tree (INTERVAL source, INTERVAL parent)
{
register INTERVAL t = make_interval ();
bcopy (source, t, INTERVAL_SIZE);
memcpy (t, source, INTERVAL_SIZE);
copy_properties (source, t);
SET_INTERVAL_PARENT (t, parent);
if (! NULL_LEFT_CHILD (source))
@ -1574,7 +1574,7 @@ reproduce_tree_obj (INTERVAL source, Lisp_Object parent)
{
register INTERVAL t = make_interval ();
bcopy (source, t, INTERVAL_SIZE);
memcpy (t, source, INTERVAL_SIZE);
copy_properties (source, t);
SET_INTERVAL_OBJECT (t, parent);
if (! NULL_LEFT_CHILD (source))

59
src/keyboard.c
View file

@ -716,7 +716,7 @@ echo_char (Lisp_Object c)
ptr = buffer + offset;
}
bcopy (text, ptr, len);
memcpy (ptr, text, len);
ptr += len;
}
@ -3481,13 +3481,13 @@ print_help (Lisp_Object object)
static void
save_getcjmp (jmp_buf temp)
{
bcopy (getcjmp, temp, sizeof getcjmp);
memcpy (temp, getcjmp, sizeof getcjmp);
}
static void
restore_getcjmp (jmp_buf temp)
{
bcopy (temp, getcjmp, sizeof getcjmp);
memcpy (getcjmp, temp, sizeof getcjmp);
}
/* Low level keyboard/mouse input.
@ -3675,7 +3675,7 @@ kbd_buffer_store_event_hold (register struct input_event *event,
if (hold_quit)
{
bcopy (event, (char *) hold_quit, sizeof (*event));
memcpy (hold_quit, event, sizeof (*event));
return;
}
@ -6336,8 +6336,8 @@ apply_modifiers_uncached (int modifiers, char *base, int base_len, int base_len_
new_name = make_uninit_multibyte_string (mod_len + base_len,
mod_len + base_len_byte);
bcopy (new_mods, SDATA (new_name), mod_len);
bcopy (base, SDATA (new_name) + mod_len, base_len_byte);
memcpy (SDATA (new_name), new_mods, mod_len);
memcpy (SDATA (new_name) + mod_len, base, base_len_byte);
return Fintern (new_name, Qnil);
}
@ -7448,7 +7448,7 @@ store_user_signal_events (void)
if (nstored == 0)
{
bzero (&buf, sizeof buf);
memset (&buf, 0, sizeof buf);
buf.kind = USER_SIGNAL_EVENT;
buf.frame_or_window = selected_frame;
}
@ -7552,7 +7552,7 @@ menu_bar_items (Lisp_Object old)
nmaps = 0;
if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
maps[nmaps++] = tem;
bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
nmaps += nminor;
maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
}
@ -7593,9 +7593,9 @@ menu_bar_items (Lisp_Object old)
tem2 = XVECTOR (menu_bar_items_vector)->contents[i + 2];
tem3 = XVECTOR (menu_bar_items_vector)->contents[i + 3];
if (end > i + 4)
bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
&XVECTOR (menu_bar_items_vector)->contents[i],
(end - i - 4) * sizeof (Lisp_Object));
memmove (&XVECTOR (menu_bar_items_vector)->contents[i],
&XVECTOR (menu_bar_items_vector)->contents[i + 4],
(end - i - 4) * sizeof (Lisp_Object));
XVECTOR (menu_bar_items_vector)->contents[end - 4] = tem0;
XVECTOR (menu_bar_items_vector)->contents[end - 3] = tem1;
XVECTOR (menu_bar_items_vector)->contents[end - 2] = tem2;
@ -7640,9 +7640,9 @@ menu_bar_item (Lisp_Object key, Lisp_Object item, Lisp_Object dummy1, void *dumm
if (EQ (key, XVECTOR (menu_bar_items_vector)->contents[i]))
{
if (menu_bar_items_index > i + 4)
bcopy (&XVECTOR (menu_bar_items_vector)->contents[i + 4],
&XVECTOR (menu_bar_items_vector)->contents[i],
(menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
memmove (&XVECTOR (menu_bar_items_vector)->contents[i],
&XVECTOR (menu_bar_items_vector)->contents[i + 4],
(menu_bar_items_index - i - 4) * sizeof (Lisp_Object));
menu_bar_items_index -= 4;
}
}
@ -8090,7 +8090,7 @@ tool_bar_items (Lisp_Object reuse, int *nitems)
nmaps = 0;
if (tem = get_local_map (PT, current_buffer, Qkeymap), !NILP (tem))
maps[nmaps++] = tem;
bcopy (tmaps, (void *) (maps + nmaps), nminor * sizeof (maps[0]));
memcpy (maps + nmaps, tmaps, nminor * sizeof (maps[0]));
nmaps += nminor;
maps[nmaps++] = get_local_map (PT, current_buffer, Qlocal_map);
}
@ -8140,9 +8140,9 @@ process_tool_bar_item (Lisp_Object key, Lisp_Object def, Lisp_Object data, void
if (EQ (key, v[TOOL_BAR_ITEM_KEY]))
{
if (ntool_bar_items > i + TOOL_BAR_ITEM_NSLOTS)
bcopy (v + TOOL_BAR_ITEM_NSLOTS, v,
((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
* sizeof (Lisp_Object)));
memmove (v, v + TOOL_BAR_ITEM_NSLOTS,
((ntool_bar_items - i - TOOL_BAR_ITEM_NSLOTS)
* sizeof (Lisp_Object)));
ntool_bar_items -= TOOL_BAR_ITEM_NSLOTS;
break;
}
@ -8425,7 +8425,7 @@ append_tool_bar_item (void)
tool_bar_items_vector. */
to = XVECTOR (tool_bar_items_vector)->contents + ntool_bar_items;
from = XVECTOR (tool_bar_item_properties)->contents;
bcopy (from, to, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
memcpy (to, from, TOOL_BAR_ITEM_NSLOTS * sizeof *to);
ntool_bar_items += TOOL_BAR_ITEM_NSLOTS;
}
@ -8718,7 +8718,7 @@ read_char_minibuf_menu_prompt (int commandflag, int nmaps, Lisp_Object *maps)
thiswidth = SCHARS (desc);
if (thiswidth + i > width)
thiswidth = width - i;
bcopy (SDATA (desc), menu + i, thiswidth);
memcpy (menu + i, SDATA (desc), thiswidth);
i += thiswidth;
strcpy (menu + i, " = ");
i += 3;
@ -8728,7 +8728,7 @@ read_char_minibuf_menu_prompt (int commandflag, int nmaps, Lisp_Object *maps)
thiswidth = SCHARS (s);
if (thiswidth + i > width)
thiswidth = width - i;
bcopy (SDATA (s), menu + i, thiswidth);
memcpy (menu + i, SDATA (s), thiswidth);
i += thiswidth;
menu[i] = 0;
}
@ -9212,8 +9212,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
if (!NILP (orig_keymap))
submaps[nmaps++] = orig_keymap;
bcopy (maps, (void *) (submaps + nmaps),
nminor * sizeof (submaps[0]));
memcpy (submaps + nmaps, maps, nminor * sizeof (submaps[0]));
nmaps += nminor;
@ -10147,7 +10146,7 @@ will read just one key sequence. */)
specbind (Qinput_method_use_echo_area,
(NILP (command_loop) ? Qt : Qnil));
bzero (keybuf, sizeof keybuf);
memset (keybuf, 0, sizeof keybuf);
GCPRO1 (keybuf[0]);
gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
@ -10207,7 +10206,7 @@ DEFUN ("read-key-sequence-vector", Fread_key_sequence_vector,
specbind (Qinput_method_use_echo_area,
(NILP (command_loop) ? Qt : Qnil));
bzero (keybuf, sizeof keybuf);
memset (keybuf, 0, sizeof keybuf);
GCPRO1 (keybuf[0]);
gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
@ -10597,12 +10596,10 @@ DEFUN ("recent-keys", Frecent_keys, Srecent_keys, 0, 0, 0,
else
{
val = Fvector (NUM_RECENT_KEYS, keys);
bcopy (keys + recent_keys_index,
XVECTOR (val)->contents,
(NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
bcopy (keys,
XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
recent_keys_index * sizeof (Lisp_Object));
memcpy (XVECTOR (val)->contents, keys + recent_keys_index,
(NUM_RECENT_KEYS - recent_keys_index) * sizeof (Lisp_Object));
memcpy (XVECTOR (val)->contents + NUM_RECENT_KEYS - recent_keys_index,
keys, recent_keys_index * sizeof (Lisp_Object));
return val;
}
}

14
src/keymap.c
View file

@ -1534,7 +1534,8 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
{
if (cmm_modes)
{
bcopy (cmm_modes, newmodes, cmm_size * sizeof cmm_modes[0]);
memcpy (newmodes, cmm_modes,
cmm_size * sizeof cmm_modes[0]);
free (cmm_modes);
}
cmm_modes = newmodes;
@ -1545,7 +1546,8 @@ current_minor_maps (Lisp_Object **modeptr, Lisp_Object **mapptr)
{
if (cmm_maps)
{
bcopy (cmm_maps, newmaps, cmm_size * sizeof cmm_maps[0]);
memcpy (newmaps, cmm_maps,
cmm_size * sizeof cmm_maps[0]);
free (cmm_maps);
}
cmm_maps = newmaps;
@ -3100,12 +3102,12 @@ You type Translation\n\
*p++ = '\f';
*p++ = '\n';
*p++ = '`';
bcopy (SDATA (SYMBOL_NAME (modes[i])), p,
SCHARS (SYMBOL_NAME (modes[i])));
memcpy (p, SDATA (SYMBOL_NAME (modes[i])),
SCHARS (SYMBOL_NAME (modes[i])));
p += SCHARS (SYMBOL_NAME (modes[i]));
*p++ = '\'';
bcopy (" Minor Mode Bindings", p, sizeof (" Minor Mode Bindings") - 1);
p += sizeof (" Minor Mode Bindings") - 1;
memcpy (p, " Minor Mode Bindings", strlen (" Minor Mode Bindings"));
p += strlen (" Minor Mode Bindings");
*p = 0;
describe_map_tree (maps[i], 1, shadow, prefix,

15
src/lisp.h
View file

@ -647,7 +647,7 @@ extern size_t pure_size;
(XSTRING (string)->size = (newsize))
#define STRING_COPYIN(string, index, new, count) \
bcopy (new, SDATA (string) + index, count)
memcpy (SDATA (string) + index, new, count)
/* Type checking. */
@ -2628,7 +2628,6 @@ EXFUN (Fredisplay, 1);
extern Lisp_Object sit_for (Lisp_Object, int, int);
extern void init_display (void);
extern void syms_of_display (void);
extern void safe_bcopy (const char *, char *, int);
/* Defined in xdisp.c */
extern Lisp_Object Qinhibit_point_motion_hooks;
@ -3400,6 +3399,18 @@ extern int emacs_open (const char *, int, int);
extern int emacs_close (int);
extern int emacs_read (int, char *, unsigned int);
extern int emacs_write (int, const char *, unsigned int);
#ifndef HAVE_MEMSET
extern void *memset P_ ((void *, int, size_t));
#endif
#ifndef HAVE_MEMCPY
extern void *memcpy P_ ((void *, void *, size_t));
#endif
#ifndef HAVE_MEMMOVE
extern void *memmove P_ ((void *, void *, size_t));
#endif
#ifndef HAVE_MEMCMP
extern int memcmp P_ ((void *, void *, size_t));
#endif
/* Defined in filelock.c */
EXFUN (Funlock_buffer, 0);

8
src/lread.c
View file

@ -1125,8 +1125,7 @@ Return t if the file exists and loads successfully. */)
specbind (Qold_style_backquotes, Qnil);
record_unwind_protect (load_warn_old_style_backquotes, file);
if (!bcmp (SDATA (found) + SBYTES (found) - 4,
".elc", 4)
if (!memcmp (SDATA (found) + SBYTES (found) - 4, ".elc", 4)
|| (fd >= 0 && (version = safe_to_load_p (fd)) > 0))
/* Load .elc files directly, but not when they are
remote and have no handler! */
@ -2430,8 +2429,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
invalid_syntax ("#&...", 5);
val = Fmake_bool_vector (length, Qnil);
bcopy (SDATA (tmp), XBOOL_VECTOR (val)->data,
size_in_chars);
memcpy (XBOOL_VECTOR (val)->data, SDATA (tmp), size_in_chars);
/* Clear the extraneous bits in the last byte. */
if (XINT (length) != size_in_chars * BOOL_VECTOR_BITS_PER_CHAR)
XBOOL_VECTOR (val)->data[size_in_chars - 1]
@ -3786,7 +3784,7 @@ oblookup (Lisp_Object obarray, register const char *ptr, int size, int size_byte
{
if (SBYTES (SYMBOL_NAME (tail)) == size_byte
&& SCHARS (SYMBOL_NAME (tail)) == size
&& !bcmp (SDATA (SYMBOL_NAME (tail)), ptr, size_byte))
&& !memcmp (SDATA (SYMBOL_NAME (tail)), ptr, size_byte))
return tail;
else if (XSYMBOL (tail)->next == 0)
break;

12
src/msdos.c
View file

@ -35,7 +35,7 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <sys/time.h>
#include <dos.h>
#include <errno.h>
#include <string.h> /* for bzero and string functions */
#include <string.h> /* for memset and string functions */
#include <sys/stat.h> /* for _fixpath */
#include <unistd.h> /* for chdir, dup, dup2, etc. */
#include <dir.h> /* for getdisk */
@ -2929,12 +2929,10 @@ and then the scan code. */)
else
{
val = Fvector (NUM_RECENT_DOSKEYS, keys);
bcopy (keys + recent_doskeys_index,
XVECTOR (val)->contents,
(NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object));
bcopy (keys,
XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index,
recent_doskeys_index * sizeof (Lisp_Object));
memcpy (XVECTOR (val)->contents, keys + recent_doskeys_index,
(NUM_RECENT_DOSKEYS - recent_doskeys_index) * sizeof (Lisp_Object));
memcpy (XVECTOR (val)->contents + NUM_RECENT_DOSKEYS - recent_doskeys_index,
keys, recent_doskeys_index * sizeof (Lisp_Object));
return val;
}
}

2
src/nsfns.m
View file

@ -1159,7 +1159,7 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side
f->output_method = output_ns;
f->output_data.ns = (struct ns_output *)xmalloc (sizeof *(f->output_data.ns));
bzero (f->output_data.ns, sizeof (*(f->output_data.ns)));
memset (f->output_data.ns, 0, sizeof (*(f->output_data.ns)));
FRAME_FONTSET (f) = -1;

12
src/nsfont.m
View file

@ -776,8 +776,8 @@ when setting family in ns_spec_to_descriptor(). */
xmalloc (0x100 * sizeof (struct font_metrics *));
if (!font_info->glyphs || !font_info->metrics)
return Qnil;
bzero (font_info->glyphs, 0x100 * sizeof (unsigned short *));
bzero (font_info->metrics, 0x100 * sizeof (struct font_metrics *));
memset (font_info->glyphs, 0, 0x100 * sizeof (unsigned short *));
memset (font_info->metrics, 0, 0x100 * sizeof (struct font_metrics *));
BLOCK_INPUT;
@ -816,8 +816,8 @@ when setting family in ns_spec_to_descriptor(). */
[font_info->nsfont retain];
/* set up ns_font (defined in nsgui.h) */
font_info->name = (char *)xmalloc (strlen (fontName) + 1);
bcopy (fontName, font_info->name, strlen (fontName) + 1);
font_info->name = (char *)xmalloc (strlen (fontName)+1);
strcpy (font_info->name, fontName);
font_info->bold = [fontMgr traitsOfFont: nsfont] & NSBoldFontMask;
font_info->ital =
synthItal || ([fontMgr traitsOfFont: nsfont] & NSItalicFontMask);
@ -972,7 +972,7 @@ that causes need for cache in nsfont_open () */
int totalWidth = 0;
int i;
bzero (metrics, sizeof (struct font_metrics));
memset (metrics, 0, sizeof (struct font_metrics));
for (i =0; i<nglyphs; i++)
{
@ -1395,7 +1395,7 @@ WITH_BACKGROUND is zero when (FROM > 0 || TO < S->nchars). */
sfont = [font_info->nsfont screenFont];
font_info->metrics[block] = xmalloc (0x100 * sizeof (struct font_metrics));
bzero (font_info->metrics[block], 0x100 * sizeof (struct font_metrics));
memset (font_info->metrics[block], 0, 0x100 * sizeof (struct font_metrics));
if (!(font_info->metrics[block]))
abort ();

8
src/nsimage.m
View file

@ -315,9 +315,9 @@ - (void)dealloc
[self addRepresentation: bmRep];
bzero (planes[0], w*h);
bzero (planes[1], w*h);
bzero (planes[2], w*h);
memset (planes[0], 0, w*h);
memset (planes[1], 0, w*h);
memset (planes[2], 0, w*h);
[self setXBMColor: [NSColor blackColor]];
return self;
}
@ -379,7 +379,7 @@ - (void)dealloc
[bmRep getBitmapDataPlanes: pixmapData];
for (i =0; i<4; i++)
bzero (pixmapData[i], width*height);
memset (pixmapData[i], 0, width*height);
[self addRepresentation: bmRep];
return self;
}

4
src/nsmenu.m
View file

@ -219,8 +219,8 @@
/* Save the frame's previous menu bar contents data */
if (previous_menu_items_used)
bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
previous_menu_items_used * sizeof (Lisp_Object));
memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
previous_menu_items_used * sizeof (Lisp_Object));
/* parse stage 1: extract from lisp */
save_menu_items ();

6
src/nsterm.m
View file

@ -2163,11 +2163,11 @@ Free a pool and temporary objects it refers to (callable from C)
{
EmacsImage **newBimgs
= xmalloc (max_used_fringe_bitmap * sizeof (EmacsImage *));
bzero (newBimgs, max_used_fringe_bitmap * sizeof (EmacsImage *));
memset (newBimgs, 0, max_used_fringe_bitmap * sizeof (EmacsImage *));
if (nBimgs)
{
bcopy (bimgs, newBimgs, nBimgs * sizeof (EmacsImage *));
memcpy (newBimgs, bimgs, nBimgs * sizeof (EmacsImage *));
xfree (bimgs);
}
@ -3707,7 +3707,7 @@ Needs to be here because ns_initialize_display_info () uses AppKit classes.
name: nil object: nil]; */
dpyinfo = (struct ns_display_info *)xmalloc (sizeof (struct ns_display_info));
bzero (dpyinfo, sizeof (struct ns_display_info));
memset (dpyinfo, 0, sizeof (struct ns_display_info));
ns_initialize_display_info (dpyinfo);
terminal = ns_create_terminal (dpyinfo);

12
src/print.c
View file

@ -289,7 +289,7 @@ int print_output_debug_flag = 1;
static Lisp_Object
print_unwind (Lisp_Object saved_text)
{
bcopy (SDATA (saved_text), print_buffer, SCHARS (saved_text));
memcpy (print_buffer, SDATA (saved_text), SCHARS (saved_text));
return Qnil;
}
@ -316,7 +316,7 @@ printchar (unsigned int ch, Lisp_Object fun)
if (print_buffer_pos_byte + len >= print_buffer_size)
print_buffer = (char *) xrealloc (print_buffer,
print_buffer_size *= 2);
bcopy (str, print_buffer + print_buffer_pos_byte, len);
memcpy (print_buffer + print_buffer_pos_byte, str, len);
print_buffer_pos += 1;
print_buffer_pos_byte += len;
}
@ -364,7 +364,7 @@ strout (const char *ptr, int size, int size_byte, Lisp_Object printcharfun,
print_buffer = (char *) xrealloc (print_buffer,
print_buffer_size);
}
bcopy (ptr, print_buffer + print_buffer_pos_byte, size_byte);
memcpy (print_buffer + print_buffer_pos_byte, ptr, size_byte);
print_buffer_pos += size;
print_buffer_pos_byte += size_byte;
}
@ -461,7 +461,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
if (chars < bytes)
{
newstr = make_uninit_multibyte_string (chars, bytes);
bcopy (SDATA (string), SDATA (newstr), chars);
memcpy (SDATA (newstr), SDATA (string), chars);
str_to_multibyte (SDATA (newstr), bytes, chars);
string = newstr;
}
@ -480,7 +480,7 @@ print_string (Lisp_Object string, Lisp_Object printcharfun)
USE_SAFE_ALLOCA;
SAFE_ALLOCA (buffer, char *, nbytes);
bcopy (SDATA (string), buffer, nbytes);
memcpy (buffer, SDATA (string), nbytes);
strout (buffer, chars, SBYTES (string),
printcharfun, STRING_MULTIBYTE (string));
@ -1032,7 +1032,7 @@ print_error_message (Lisp_Object data, Lisp_Object stream, char *context, Lisp_O
{
Lisp_Object cname = SYMBOL_NAME (caller);
char *name = alloca (SBYTES (cname));
bcopy (SDATA (cname), name, SBYTES (cname));
memcpy (name, SDATA (cname), SBYTES (cname));
message_dolog (name, SBYTES (cname), 0, 0);
message_dolog (": ", 2, 0, 0);
}

52
src/process.c
View file

@ -2440,7 +2440,7 @@ conv_lisp_to_sockaddr (int family, Lisp_Object address, struct sockaddr *sa, int
register unsigned char *cp = NULL;
register int i;
bzero (sa, len);
memset (sa, 0, len);
if (VECTORP (address))
{
@ -2635,12 +2635,12 @@ set_socket_option (int s, Lisp_Object opt, Lisp_Object val)
/* This is broken, at least in the Linux 2.4 kernel.
To unbind, the arg must be a zero integer, not the empty string.
This should work on all systems. KFS. 2003-09-23. */
bzero (devname, sizeof devname);
memset (devname, 0, sizeof devname);
if (STRINGP (val))
{
char *arg = (char *) SDATA (val);
int len = min (strlen (arg), IFNAMSIZ);
bcopy (arg, devname, len);
memcpy (devname, arg, len);
}
else if (!NILP (val))
error ("Bad option value for %s", name);
@ -3349,7 +3349,7 @@ usage: (make-network-process &rest ARGS) */)
host = Qnil;
}
CHECK_STRING (service);
bzero (&address_un, sizeof address_un);
memset (&address_un, 0, sizeof address_un);
address_un.sun_family = AF_LOCAL;
strncpy (address_un.sun_path, SDATA (service), sizeof address_un.sun_path);
ai.ai_addr = (struct sockaddr *) &address_un;
@ -3433,7 +3433,7 @@ usage: (make-network-process &rest ARGS) */)
port = svc_info->s_port;
}
bzero (&address_in, sizeof address_in);
memset (&address_in, 0, sizeof address_in);
address_in.sin_family = family;
address_in.sin_addr.s_addr = INADDR_ANY;
address_in.sin_port = port;
@ -3457,8 +3457,8 @@ usage: (make-network-process &rest ARGS) */)
if (host_info_ptr)
{
bcopy (host_info_ptr->h_addr, (char *) &address_in.sin_addr,
host_info_ptr->h_length);
memcpy (&address_in.sin_addr, host_info_ptr->h_addr,
host_info_ptr->h_length);
family = host_info_ptr->h_addrtype;
address_in.sin_family = family;
}
@ -3470,8 +3470,8 @@ usage: (make-network-process &rest ARGS) */)
if (numeric_addr == -1)
error ("Unknown host \"%s\"", SDATA (host));
bcopy ((char *)&numeric_addr, (char *) &address_in.sin_addr,
sizeof (address_in.sin_addr));
memcpy (&address_in.sin_addr, &numeric_addr,
sizeof (address_in.sin_addr));
}
}
@ -3655,7 +3655,7 @@ usage: (make-network-process &rest ARGS) */)
if (is_server)
{
Lisp_Object remote;
bzero (datagram_address[s].sa, lres->ai_addrlen);
memset (datagram_address[s].sa, 0, lres->ai_addrlen);
if (remote = Fplist_get (contact, QCremote), !NILP (remote))
{
int rfamily, rlen;
@ -3666,7 +3666,7 @@ usage: (make-network-process &rest ARGS) */)
}
}
else
bcopy (lres->ai_addr, datagram_address[s].sa, lres->ai_addrlen);
memcpy (datagram_address[s].sa, lres->ai_addr, lres->ai_addrlen);
}
#endif
contact = Fplist_put (contact, QCaddress,
@ -3933,7 +3933,7 @@ format; see the description of ADDRESS in `make-network-process'. */)
char namebuf[sizeof (ifq->ifr_name) + 1];
if (ifq->ifr_addr.sa_family != AF_INET)
continue;
bcopy (ifq->ifr_name, namebuf, sizeof (ifq->ifr_name));
memcpy (namebuf, ifq->ifr_name, sizeof (ifq->ifr_name));
namebuf[sizeof (ifq->ifr_name)] = 0;
res = Fcons (Fcons (build_string (namebuf),
conv_sockaddr_to_lisp (&ifq->ifr_addr,
@ -4036,7 +4036,7 @@ FLAGS is the current flags of the interface. */)
CHECK_STRING (ifname);
bzero (rq.ifr_name, sizeof rq.ifr_name);
memset (rq.ifr_name, 0, sizeof rq.ifr_name);
strncpy (rq.ifr_name, SDATA (ifname), sizeof (rq.ifr_name));
s = socket (AF_INET, SOCK_STREAM, 0);
@ -5277,7 +5277,7 @@ read_process_output (Lisp_Object proc, register int channel)
chars = (char *) alloca (carryover + readmax);
if (carryover)
/* See the comment above. */
bcopy (SDATA (p->decoding_buf), chars, carryover);
memcpy (chars, SDATA (p->decoding_buf), carryover);
#ifdef DATAGRAM_SOCKETS
/* We have a working select, so proc_buffered_char is always -1. */
@ -5421,8 +5421,8 @@ read_process_output (Lisp_Object proc, register int channel)
{
if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
p->decoding_buf = make_uninit_string (coding->carryover_bytes);
bcopy (coding->carryover, SDATA (p->decoding_buf),
coding->carryover_bytes);
memcpy (SDATA (p->decoding_buf), coding->carryover,
coding->carryover_bytes);
p->decoding_carryover = coding->carryover_bytes;
}
if (SBYTES (text) > 0)
@ -5513,8 +5513,8 @@ read_process_output (Lisp_Object proc, register int channel)
{
if (SCHARS (p->decoding_buf) < coding->carryover_bytes)
p->decoding_buf = make_uninit_string (coding->carryover_bytes);
bcopy (coding->carryover, SDATA (p->decoding_buf),
coding->carryover_bytes);
memcpy (SDATA (p->decoding_buf), coding->carryover,
coding->carryover_bytes);
p->decoding_carryover = coding->carryover_bytes;
}
/* Adjust the multibyteness of TEXT to that of the buffer. */
@ -6517,11 +6517,11 @@ process has been transmitted to the serial port. */)
if (!proc_encode_coding_system[new_outfd])
proc_encode_coding_system[new_outfd]
= (struct coding_system *) xmalloc (sizeof (struct coding_system));
bcopy (proc_encode_coding_system[old_outfd],
proc_encode_coding_system[new_outfd],
sizeof (struct coding_system));
bzero (proc_encode_coding_system[old_outfd],
sizeof (struct coding_system));
memcpy (proc_encode_coding_system[new_outfd],
proc_encode_coding_system[old_outfd],
sizeof (struct coding_system));
memset (proc_encode_coding_system[old_outfd], 0,
sizeof (struct coding_system));
XPROCESS (proc)->outfd = new_outfd;
}
@ -7234,10 +7234,10 @@ init_process (void)
chan_process[i] = Qnil;
proc_buffered_char[i] = -1;
}
bzero (proc_decode_coding_system, sizeof proc_decode_coding_system);
bzero (proc_encode_coding_system, sizeof proc_encode_coding_system);
memset (proc_decode_coding_system, 0, sizeof proc_decode_coding_system);
memset (proc_encode_coding_system, 0, sizeof proc_encode_coding_system);
#ifdef DATAGRAM_SOCKETS
bzero (datagram_address, sizeof datagram_address);
memset (datagram_address, 0, sizeof datagram_address);
#endif
#ifdef HAVE_SOCKETS

28
src/ralloc.c
View file

@ -37,11 +37,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
typedef POINTER_TYPE *POINTER;
typedef size_t SIZE;
/* Declared in dispnew.c, this version doesn't screw up if regions
overlap. */
extern void safe_bcopy (const char *, char *, int);
#ifdef DOUG_LEA_MALLOC
#define M_TOP_PAD -2
extern int mallopt (int, int);
@ -61,9 +56,6 @@ typedef void *POINTER;
#include <unistd.h>
#include <malloc.h>
#define safe_bcopy(x, y, z) memmove (y, x, z)
#define bzero(x, len) memset (x, 0, len)
#endif /* not emacs */
@ -676,7 +668,7 @@ resize_bloc (bloc_ptr bloc, SIZE size)
}
else
{
safe_bcopy (b->data, b->new_data, b->size);
memmove (b->new_data, b->data, b->size);
*b->variable = b->data = b->new_data;
}
}
@ -687,8 +679,8 @@ resize_bloc (bloc_ptr bloc, SIZE size)
}
else
{
safe_bcopy (bloc->data, bloc->new_data, old_size);
bzero ((char *) bloc->new_data + old_size, size - old_size);
memmove (bloc->new_data, bloc->data, old_size);
memset (bloc->new_data + old_size, 0, size - old_size);
*bloc->variable = bloc->data = bloc->new_data;
}
}
@ -703,7 +695,7 @@ resize_bloc (bloc_ptr bloc, SIZE size)
}
else
{
safe_bcopy (b->data, b->new_data, b->size);
memmove (b->new_data, b->data, b->size);
*b->variable = b->data = b->new_data;
}
}
@ -856,7 +848,7 @@ r_alloc_sbrk (long int size)
header. */
for (b = last_bloc; b != NIL_BLOC; b = b->prev)
{
safe_bcopy (b->data, b->new_data, b->size);
memmove (b->new_data, b->data, b->size);
*b->variable = b->data = b->new_data;
}
@ -883,7 +875,7 @@ r_alloc_sbrk (long int size)
last_heap = first_heap;
}
bzero (address, size);
memset (address, 0, size);
}
else /* size < 0 */
{
@ -902,7 +894,7 @@ r_alloc_sbrk (long int size)
for (b = first_bloc; b != NIL_BLOC; b = b->next)
{
safe_bcopy (b->data, b->new_data, b->size);
memmove (b->new_data, b->data, b->size);
*b->variable = b->data = b->new_data;
}
}
@ -1082,7 +1074,7 @@ r_alloc_thaw (void)
abort ();
/* This frees all unused blocs. It is not too inefficient, as the resize
and bcopy is done only once. Afterwards, all unreferenced blocs are
and memcpy is done only once. Afterwards, all unreferenced blocs are
already shrunk to zero size. */
if (!r_alloc_freeze_level)
{
@ -1292,8 +1284,8 @@ r_alloc_init (void)
even though it is after the sbrk value. */
/* Doubly true, with the additional call that explicitly adds the
rest of that page to the address space. */
bzero (first_heap->start,
(char *) first_heap->end - (char *) first_heap->start);
memset (first_heap->start, 0,
(char *) first_heap->end - (char *) first_heap->start);
virtual_break_value = break_value = first_heap->bloc_start = first_heap->end;
#endif

45
src/regex.c
View file

@ -248,37 +248,16 @@ xrealloc (block, size)
# endif
# define realloc xrealloc
/* When used in Emacs's lib-src, we need to get bzero and bcopy somehow.
If nothing else has been done, use the method below. */
# ifdef INHIBIT_STRING_HEADER
# if !(defined HAVE_BZERO && defined HAVE_BCOPY)
# if !defined bzero && !defined bcopy
# undef INHIBIT_STRING_HEADER
# endif
/* This is the normal way of making sure we have memcpy, memcmp and memset. */
# if defined HAVE_STRING_H || defined STDC_HEADERS || defined _LIBC
# include <string.h>
# else
# include <strings.h>
# ifndef memcmp
# define memcmp(s1, s2, n) bcmp (s1, s2, n)
# endif
# endif
/* This is the normal way of making sure we have memcpy, memcmp and bzero.
This is used in most programs--a few other programs avoid this
by defining INHIBIT_STRING_HEADER. */
# ifndef INHIBIT_STRING_HEADER
# if defined HAVE_STRING_H || defined STDC_HEADERS || defined _LIBC
# include <string.h>
# ifndef bzero
# ifndef _LIBC
# define bzero(s, n) (memset (s, '\0', n), (s))
# else
# define bzero(s, n) __bzero (s, n)
# endif
# endif
# else
# include <strings.h>
# ifndef memcmp
# define memcmp(s1, s2, n) bcmp (s1, s2, n)
# endif
# ifndef memcpy
# define memcpy(d, s, n) (bcopy (s, d, n), (d))
# endif
# ifndef memcpy
# define memcpy(d, s, n) (bcopy (s, d, n), (d))
# endif
# endif
@ -464,7 +443,7 @@ init_syntax_once ()
if (done)
return;
bzero (re_syntax_table, sizeof re_syntax_table);
memset (re_syntax_table, 0, sizeof re_syntax_table);
for (c = 0; c < CHAR_SET_SIZE; ++c)
if (ISALNUM (c))
@ -2948,7 +2927,7 @@ regex_compile (const re_char *pattern, size_t size, reg_syntax_t syntax, struct
BUF_PUSH ((1 << BYTEWIDTH) / BYTEWIDTH);
/* Clear the whole map. */
bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH);
memset (b, 0, (1 << BYTEWIDTH) / BYTEWIDTH);
/* charset_not matches newline according to a syntax bit. */
if ((re_opcode_t) b[-2] == charset_not
@ -4303,7 +4282,7 @@ re_compile_fastmap (struct re_pattern_buffer *bufp)
assert (fastmap && bufp->buffer);
bzero (fastmap, 1 << BYTEWIDTH); /* Assume nothing's valid. */
memset (fastmap, 0, 1 << BYTEWIDTH); /* Assume nothing's valid. */
bufp->fastmap_accurate = 1; /* It will be when we're done. */
analysis = analyse_first (bufp->buffer, bufp->buffer + bufp->used,

15
src/s/ms-w32.h
View file

@ -63,15 +63,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
for received packets, so datagrams are broken too. */
#define BROKEN_DATAGRAM_SOCKETS 1
#define bzero(b, l) memset(b, 0, l)
#define bcopy(s, d, l) memmove(d, s, l)
#define bcmp(a, b, l) memcmp(a, b, l)
/* bcopy (aka memmove aka memcpy at least on x86) under MSVC is quite safe. */
#define GAP_USE_BCOPY 1
#define BCOPY_UPWARD_SAFE 1
#define BCOPY_DOWNWARD_SAFE 1
/* If your system uses COFF (Common Object File Format) then define the
preprocessor symbol "COFF". */
#define COFF 1
@ -153,8 +144,10 @@ struct sigaction {
#define HAVE_RANDOM 1
#undef HAVE_SYSINFO
#undef HAVE_LRAND48
#define HAVE_BCOPY 1
#define HAVE_BCMP 1
#define HAVE_MEMCMP 1
#define HAVE_MEMCPY 1
#define HAVE_MEMMOVE 1
#define HAVE_MEMSET 1
#define HAVE_LOGB 1
#define HAVE_FREXP 1
#define HAVE_FMOD 1

4
src/s/msdos.h
View file

@ -104,10 +104,6 @@ You lose; /* Emacs for DOS must be compiled with DJGPP */
#define IS_DIRECTORY_SEP(_c_) ((_c_) == '/' || (_c_) == '\\')
#define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_) || IS_DEVICE_SEP (_c_))
/* bcopy under djgpp is quite safe. */
#define GAP_USE_BCOPY
#define BCOPY_UPWARD_SAFE 1
#define BCOPY_DOWNWARD_SAFE 1
/* Mode line description of a buffer's type. */
#define MODE_LINE_BINARY_TEXT(buf) (NILP(buf->buffer_file_type) ? "T" : "B")

6
src/scroll.c
View file

@ -258,7 +258,7 @@ do_scrolling (struct frame *frame, struct glyph_matrix *current_matrix, struct m
int *copy_from = (int *) alloca (window_size * sizeof (int));
/* Zero means line is empty. */
bzero (retained_p, window_size * sizeof (char));
memset (retained_p, 0, window_size * sizeof (char));
for (k = 0; k < window_size; ++k)
copy_from[k] = -1;
@ -677,7 +677,7 @@ do_direct_scrolling (frame, current_matrix, cost_matrix,
old matrix. Lines not retained are empty. */
char *retained_p = (char *) alloca (window_size * sizeof (char));
bzero (retained_p, window_size * sizeof (char));
memset (retained_p, 0, window_size * sizeof (char));
/* Perform some sanity checks when GLYPH_DEBUG is on. */
CHECK_MATRIX (current_matrix);
@ -855,7 +855,7 @@ scrolling_max_lines_saved (int start, int end, int *oldhash, int *newhash, int *
avg_length /= end - start;
threshold = avg_length / 4;
bzero (lines, sizeof lines);
memset (lines, 0, sizeof lines);
/* Put new lines' hash codes in hash table. Ignore lines shorter
than the threshold. Thus, if the lines that are in common are

7
src/search.c
View file

@ -1404,7 +1404,7 @@ search_buffer (string, pos, pos_byte, lim, lim_byte, n,
}
/* Store this character into the translated pattern. */
bcopy (str, pat, charlen);
memcpy (pat, str, charlen);
pat += charlen;
base_pat += in_charlen;
len_byte -= in_charlen;
@ -2178,8 +2178,7 @@ wordify (Lisp_Object string, int lax)
if (SYNTAX (c) == Sword)
{
bcopy (SDATA (string) + i_byte_orig, o,
i_byte - i_byte_orig);
memcpy (o, SDATA (string) + i_byte_orig, i_byte - i_byte_orig);
o += i_byte - i_byte_orig;
}
else if (i > 0 && SYNTAX (prev_c) == Sword && --word_count)
@ -2774,7 +2773,7 @@ since only regular expressions have distinguished subexpressions. */)
/* Now add to the end of SUBSTED. */
if (add_stuff)
{
bcopy (add_stuff, substed + substed_len, add_len);
memcpy (substed + substed_len, add_stuff, add_len);
substed_len += add_len;
}
}

11
src/sound.c
View file

@ -550,7 +550,7 @@ wav_init (struct sound *s)
struct wav_header *header = (struct wav_header *) s->header;
if (s->header_size < sizeof *header
|| bcmp (s->header, "RIFF", 4) != 0)
|| memcmp (s->header, "RIFF", 4) != 0)
return 0;
/* WAV files are in little-endian order. Convert the header
@ -658,7 +658,7 @@ au_init (struct sound *s)
struct au_header *header = (struct au_header *) s->header;
if (s->header_size < sizeof *header
|| bcmp (s->header, ".snd", 4) != 0)
|| memcmp (s->header, ".snd", 4) != 0)
return 0;
header->magic_number = be2hl (header->magic_number);
@ -1380,9 +1380,9 @@ Internal use only, use `play-sound' instead. */)
file = Qnil;
GCPRO2 (sound, file);
current_sound_device = (struct sound_device *) xmalloc (sizeof (struct sound_device));
bzero (current_sound_device, sizeof (struct sound_device));
memset (current_sound_device, 0, sizeof (struct sound_device));
current_sound = (struct sound *) xmalloc (sizeof (struct sound));
bzero (current_sound, sizeof (struct sound));
memset (current_sound, 0, sizeof (struct sound));
record_unwind_protect (sound_cleanup, Qnil);
current_sound->header = (char *) alloca (MAX_SOUND_HEADER_BYTES);
@ -1405,7 +1405,8 @@ Internal use only, use `play-sound' instead. */)
{
current_sound->data = attrs[SOUND_DATA];
current_sound->header_size = min (MAX_SOUND_HEADER_BYTES, SBYTES (current_sound->data));
bcopy (SDATA (current_sound->data), current_sound->header, current_sound->header_size);
memcpy (current_sound->header, SDATA (current_sound->data),
current_sound->header_size);
}
/* Find out the type of sound. Give up if we can't tell. */

14
src/syntax.c
View file

@ -1422,7 +1422,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
&& (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
string_multibyte = SBYTES (string) > SCHARS (string);
bzero (fastmap, sizeof fastmap);
memset (fastmap, 0, sizeof fastmap);
str = SDATA (string);
size_byte = SBYTES (string);
@ -1471,7 +1471,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
|| *class_end != ':' || class_end[1] != ']')
goto not_a_class_name;
bcopy (class_beg, class_name, class_end - class_beg);
memcpy (class_name, class_beg, class_end - class_beg);
class_name[class_end - class_beg] = 0;
cc = re_wctype (class_name);
@ -1532,8 +1532,8 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
unsigned char fastmap2[0400];
int range_start_byte, range_start_char;
bcopy (fastmap2 + 0200, fastmap + 0200, 0200);
bzero (fastmap + 0200, 0200);
memcpy (fastmap + 0200, fastmap2 + 0200, 0200);
memset (fastmap + 0200, 0, 0200);
/* We are sure that this loop stops. */
for (i = 0200; ! fastmap2[i]; i++);
c = BYTE8_TO_CHAR (i);
@ -1593,7 +1593,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
|| *class_end != ':' || class_end[1] != ']')
goto not_a_class_name_multibyte;
bcopy (class_beg, class_name, class_end - class_beg);
memcpy (class_name, class_beg, class_end - class_beg);
class_name[class_end - class_beg] = 0;
cc = re_wctype (class_name);
@ -1678,7 +1678,7 @@ skip_chars (int forwardp, Lisp_Object string, Lisp_Object lim, int handle_iso_cl
if (! multibyte && n_char_ranges > 0)
{
bzero (fastmap + 0200, 0200);
memset (fastmap + 0200, 0, 0200);
for (i = 0; i < n_char_ranges; i += 2)
{
int c1 = char_ranges[i];
@ -1907,7 +1907,7 @@ skip_syntaxes (int forwardp, Lisp_Object string, Lisp_Object lim)
multibyte = (!NILP (current_buffer->enable_multibyte_characters)
&& (XINT (lim) - PT != CHAR_TO_BYTE (XINT (lim)) - PT_BYTE));
bzero (fastmap, sizeof fastmap);
memset (fastmap, 0, sizeof fastmap);
if (SBYTES (string) > SCHARS (string))
/* As this is very rare case (syntax spec is ASCII only), don't

59
src/sysdep.c
View file

@ -623,7 +623,7 @@ sys_subshell (void)
dir = expand_and_dir_to_file (Funhandled_file_name_directory (dir), Qnil);
str = (unsigned char *) alloca (SCHARS (dir) + 2);
len = SCHARS (dir);
bcopy (SDATA (dir), str, len);
memcpy (str, SDATA (dir), len);
if (str[len - 1] != '/') str[len++] = '/';
str[len] = 0;
xyzzy:
@ -855,7 +855,7 @@ emacs_get_tty (int fd, struct emacs_tty *settings)
/* Retrieve the primary parameters - baud rate, character size, etcetera. */
#ifdef HAVE_TCATTR
/* We have those nifty POSIX tcmumbleattr functions. */
bzero (&settings->main, sizeof (settings->main));
memset (&settings->main, 0, sizeof (settings->main));
if (tcgetattr (fd, &settings->main) < 0)
return -1;
@ -922,7 +922,7 @@ emacs_set_tty (int fd, struct emacs_tty *settings, int flushp)
{
struct termios new;
bzero (&new, sizeof (new));
memset (&new, 0, sizeof (new));
/* Get the current settings, and see if they're what we asked for. */
tcgetattr (fd, &new);
/* We cannot use memcmp on the whole structure here because under
@ -2714,6 +2714,59 @@ rmdir (char *dpath)
}
#endif /* !HAVE_RMDIR */
#ifndef HAVE_MEMSET
void *
memset (void *b, int n, size_t length)
{
unsigned char *p = b;
while (length-- > 0)
*p++ = n;
return b;
}
#endif /* !HAVE_MEMSET */
#ifndef HAVE_MEMCPY
void *
memcpy (void *b1, void *b2, size_t length)
{
unsigned char *p1 = b1, *p2 = b2;
while (length-- > 0)
*p1++ = *p2++;
return b1;
}
#endif /* !HAVE_MEMCPY */
#ifndef HAVE_MEMMOVE
void *
memmove (void *b1, void *b2, size_t length)
{
unsigned char *p1 = b1, *p2 = b2;
if (p1 < p2 || p1 >= p2 + length)
while (length-- > 0)
*p1++ = *p2++;
else
{
p1 += length;
p2 += length;
while (length-- > 0)
*--p1 = *--p2;
}
return b1;
}
#endif /* !HAVE_MEMCPY */
#ifndef HAVE_MEMCMP
int
memcmp (void *b1, void *b2, size_t length)
{
unsigned char *p1 = b1, *p2 = b2;
while (length-- > 0)
if (*p1++ != *p2++)
return p1[-1] < p2[-1] ? -1 : 1;
return 0;
}
#endif /* !HAVE_MEMCMP */
#ifndef HAVE_STRSIGNAL
char *

14
src/term.c
View file

@ -720,7 +720,7 @@ encode_terminal_code (struct glyph *src, int src_len, struct coding_system *codi
encode_terminal_src_size);
buf = encode_terminal_src + nbytes;
}
bcopy (SDATA (string), buf, SBYTES (string));
memcpy (buf, SDATA (string), SBYTES (string));
buf += SBYTES (string);
nchars += SCHARS (string);
}
@ -1225,8 +1225,8 @@ calculate_costs (struct frame *frame)
= (int *) xmalloc (sizeof (int)
+ 2 * max_frame_cols * sizeof (int));
bzero (char_ins_del_vector, (sizeof (int)
+ 2 * max_frame_cols * sizeof (int)));
memset (char_ins_del_vector, 0,
(sizeof (int) + 2 * max_frame_cols * sizeof (int)));
if (f && (!tty->TS_ins_line && !tty->TS_del_line))
@ -1893,7 +1893,7 @@ produce_special_glyphs (struct it *it, enum display_element_type what)
temp_it.what = IT_CHARACTER;
temp_it.len = 1;
temp_it.object = make_number (0);
bzero (&temp_it.current, sizeof temp_it.current);
memset (&temp_it.current, 0, sizeof temp_it.current);
if (what == IT_CONTINUATION)
{
@ -3229,7 +3229,7 @@ create_tty_output (struct frame *f)
abort ();
t = xmalloc (sizeof (struct tty_output));
bzero (t, sizeof (struct tty_output));
memset (t, 0, sizeof (struct tty_output));
t->display_info = FRAME_TERMINAL (f)->display_info.tty;
@ -3436,7 +3436,7 @@ init_tty (char *name, char *terminal_type, int must_succeed)
#else
tty = (struct tty_display_info *) xmalloc (sizeof (struct tty_display_info));
#endif
bzero (tty, sizeof (struct tty_display_info));
memset (tty, 0, sizeof (struct tty_display_info));
tty->next = tty_list;
tty_list = tty;
@ -4028,7 +4028,7 @@ delete_tty (struct terminal *terminal)
xfree (tty->termcap_strings_buffer);
xfree (tty->termcap_term_buffer);
bzero (tty, sizeof (struct tty_display_info));
memset (tty, 0, sizeof (struct tty_display_info));
xfree (tty);
}

9
src/termcap.c
View file

@ -46,11 +46,6 @@ char *malloc ();
char *realloc ();
#endif
/* Do this after the include, in case string.h prototypes bcopy. */
#if (defined(HAVE_STRING_H) || defined(STDC_HEADERS)) && !defined(bcopy)
#define bcopy(s, d, n) memcpy ((d), (s), (n))
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
@ -315,7 +310,7 @@ tgetst1 (char *ptr, char **area)
cut[last_p_param].len = r - cut[last_p_param].beg;
for (i = 0, wp = ret; i <= last_p_param; wp += cut[i++].len)
bcopy (cut[i].beg, wp, cut[i].len);
memcpy (wp, cut[i].beg, cut[i].len);
r = wp;
}
}
@ -739,7 +734,7 @@ gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end)
else
{
append_end -= bufp->ptr - buf;
bcopy (bufp->ptr, buf, bufp->full -= bufp->ptr - buf);
memcpy (buf, bufp->ptr, bufp->full -= bufp->ptr - buf);
bufp->ptr = buf;
}
if (!(nread = read (fd, buf + bufp->full, bufp->size - bufp->full)))

2
src/termhooks.h
View file

@ -255,7 +255,7 @@ struct input_event
Lisp_Object arg;
};
#define EVENT_INIT(event) bzero (&(event), sizeof (struct input_event))
#define EVENT_INIT(event) memset (&(event), 0, sizeof (struct input_event))
/* Bits in the modifiers member of the input_event structure.
Note that reorder_modifiers assumes that the bits are in canonical

7
src/tparam.c
View file

@ -35,11 +35,6 @@ char *malloc ();
char *realloc ();
#endif
/* Do this after the include, in case string.h prototypes bcopy. */
#if (defined(HAVE_STRING_H) || defined(STDC_HEADERS)) && !defined(bcopy)
#define bcopy(s, d, n) memcpy ((d), (s), (n))
#endif
#endif /* not emacs */
#ifndef NULL
@ -151,7 +146,7 @@ tparam1 (char *string, char *outstring, int len, char *up, char *left, register
{
outlen = len + 40;
new = (char *) xmalloc (outlen);
bcopy (outstring, new, offset);
memcpy (new, outstring, offset);
}
else
{

6
src/unexalpha.c
View file

@ -260,7 +260,7 @@ unexec (new_name, a_name, data_start, bss_start, entry_address)
Brk = brk;
bcopy (data_section, &old_data_scnhdr, sizeof (old_data_scnhdr));
memcpy (&old_data_scnhdr, data_section, sizeof (old_data_scnhdr));
nhdr.aout.dsize = brk - DATA_START;
nhdr.aout.bsize = 0;
@ -328,7 +328,7 @@ unexec (new_name, a_name, data_start, bss_start, entry_address)
#ifdef _GOT
if (got_section != NULL)
{
bcopy (got_section, buffer, sizeof (struct scnhdr));
memcpy (buffer, got_section, sizeof (struct scnhdr));
got_section->s_vaddr = vaddr;
got_section->s_paddr = vaddr;
@ -376,7 +376,7 @@ unexec (new_name, a_name, data_start, bss_start, entry_address)
* Construct new symbol table header
*/
bcopy (oldptr + nhdr.fhdr.f_symptr, buffer, cbHDRR);
memcpy (buffer, oldptr + nhdr.fhdr.f_symptr, cbHDRR);
#define symhdr ((pHDRR)buffer)
newsyms = nhdr.aout.tsize + nhdr.aout.dsize;

2
src/unexec.c
View file

@ -472,7 +472,7 @@ write_segment (new, ptr, end)
int pagesize = getpagesize ();
char zeros[1 << 13];
bzero (zeros, sizeof (zeros));
memset (zeros, 0, sizeof (zeros));
for (i = 0; ptr < end;)
{

2
src/unexmacosx.c
View file

@ -218,7 +218,7 @@ unexec_write_zero (off_t dest, size_t count)
char buf[UNEXEC_COPY_BUFSZ];
ssize_t bytes;
bzero (buf, UNEXEC_COPY_BUFSZ);
memset (buf, 0, UNEXEC_COPY_BUFSZ);
if (lseek (outfd, dest, SEEK_SET) != dest)
return 0;

12
src/w32fns.c
View file

@ -2746,7 +2746,7 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT paintStruct;
RECT update_rect;
bzero (&update_rect, sizeof (update_rect));
memset (&update_rect, 0, sizeof (update_rect));
f = x_window_to_frame (dpyinfo, hwnd);
if (f == 0)
@ -4275,7 +4275,7 @@ This function is an internal primitive--use `make-frame' instead. */)
f->output_method = output_w32;
f->output_data.w32 =
(struct w32_output *) xmalloc (sizeof (struct w32_output));
bzero (f->output_data.w32, sizeof (struct w32_output));
memset (f->output_data.w32, 0, sizeof (struct w32_output));
FRAME_FONTSET (f) = -1;
f->icon_name
@ -5388,7 +5388,7 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
f->output_method = output_w32;
f->output_data.w32 =
(struct w32_output *) xmalloc (sizeof (struct w32_output));
bzero (f->output_data.w32, sizeof (struct w32_output));
memset (f->output_data.w32, 0, sizeof (struct w32_output));
FRAME_FONTSET (f) = -1;
f->icon_name = Qnil;
@ -6046,7 +6046,7 @@ If ONLY-DIR-P is non-nil, the user can only select directories. */)
specbind (Qinhibit_redisplay, Qt);
BLOCK_INPUT;
bzero (&new_file_details, sizeof (new_file_details));
memset (&new_file_details, 0, sizeof (new_file_details));
/* Apparently NT4 crashes if you give it an unexpected size.
I'm not sure about Windows 9x, so play it safe. */
if (w32_major_version > 4 && w32_major_version < 95)
@ -6157,10 +6157,10 @@ DEFUN ("system-move-file-to-trash", Fsystem_move_file_to_trash,
/* On Windows, write permission is required to delete/move files. */
_chmod (path, 0666);
bzero (tmp_path, sizeof (tmp_path));
memset (tmp_path, 0, sizeof (tmp_path));
strcpy (tmp_path, path);
bzero (&file_op, sizeof (file_op));
memset (&file_op, 0, sizeof (file_op));
file_op.hwnd = HWND_DESKTOP;
file_op.wFunc = FO_DELETE;
file_op.pFrom = tmp_path;

30
src/w32font.c
View file

@ -225,7 +225,7 @@ w32font_list_family (Lisp_Object frame)
HDC dc;
FRAME_PTR f = XFRAME (frame);
bzero (&font_match_pattern, sizeof (font_match_pattern));
memset (&font_match_pattern, 0, sizeof (font_match_pattern));
font_match_pattern.lfCharSet = DEFAULT_CHARSET;
dc = get_frame_dc (f);
@ -373,7 +373,7 @@ w32font_text_extents (struct font *font, unsigned *code,
if (metrics)
{
bzero (metrics, sizeof (struct font_metrics));
memset (metrics, 0, sizeof (struct font_metrics));
metrics->ascent = font->ascent;
metrics->descent = font->descent;
@ -394,9 +394,9 @@ w32font_text_extents (struct font *font, unsigned *code,
= xrealloc (w32_font->cached_metrics,
(block + 1)
* sizeof (struct w32_metric_cache *));
bzero (w32_font->cached_metrics + w32_font->n_cache_blocks,
((block + 1 - w32_font->n_cache_blocks)
* sizeof (struct w32_metric_cache *)));
memset (w32_font->cached_metrics + w32_font->n_cache_blocks, 0,
((block + 1 - w32_font->n_cache_blocks)
* sizeof (struct w32_metric_cache *)));
w32_font->n_cache_blocks = block + 1;
}
@ -404,8 +404,8 @@ w32font_text_extents (struct font *font, unsigned *code,
{
w32_font->cached_metrics[block]
= xmalloc (CACHE_BLOCKSIZE * sizeof (struct w32_metric_cache));
bzero (w32_font->cached_metrics[block],
CACHE_BLOCKSIZE * sizeof (struct w32_metric_cache));
memset (w32_font->cached_metrics[block], 0,
CACHE_BLOCKSIZE * sizeof (struct w32_metric_cache));
}
char_metric = w32_font->cached_metrics[block] + pos_in_block;
@ -706,7 +706,7 @@ w32font_list_internal (Lisp_Object frame, Lisp_Object font_spec, int opentype_on
match_data.list = Qnil;
match_data.frame = frame;
bzero (&match_data.pattern, sizeof (LOGFONT));
memset (&match_data.pattern, 0, sizeof (LOGFONT));
fill_in_logfont (f, &match_data.pattern, font_spec);
/* If the charset is unrecognized, then we won't find a font, so don't
@ -759,7 +759,7 @@ w32font_match_internal (Lisp_Object frame, Lisp_Object font_spec, int opentype_o
match_data.frame = frame;
match_data.list = Qnil;
bzero (&match_data.pattern, sizeof (LOGFONT));
memset (&match_data.pattern, 0, sizeof (LOGFONT));
fill_in_logfont (f, &match_data.pattern, font_spec);
match_data.opentype_only = opentype_only;
@ -795,7 +795,7 @@ w32font_open_internal (FRAME_PTR f, Lisp_Object font_entity,
if (!font)
return 0;
bzero (&logfont, sizeof (logfont));
memset (&logfont, 0, sizeof (logfont));
fill_in_logfont (f, &logfont, font_entity);
/* Prefer truetype fonts, to avoid known problems with type1 fonts, and
@ -824,8 +824,8 @@ w32font_open_internal (FRAME_PTR f, Lisp_Object font_entity,
{
metrics = (OUTLINETEXTMETRICW *) alloca (len);
if (GetOutlineTextMetricsW (dc, len, metrics))
bcopy (&metrics->otmTextMetrics, &w32_font->metrics,
sizeof (TEXTMETRICW));
memcpy (&w32_font->metrics, &metrics->otmTextMetrics,
sizeof (TEXTMETRICW));
else
metrics = NULL;
}
@ -2306,7 +2306,7 @@ compute_metrics (HDC dc, struct w32font_info *w32_font, unsigned int code,
if (w32_font->glyph_idx)
options |= GGO_GLYPH_INDEX;
bzero (&transform, sizeof (transform));
memset (&transform, 0, sizeof (transform));
transform.eM11.value = 1;
transform.eM22.value = 1;
@ -2340,8 +2340,8 @@ in the font selection dialog. */)
HANDLE oldobj;
char buf[100];
bzero (&cf, sizeof (cf));
bzero (&lf, sizeof (lf));
memset (&cf, 0, sizeof (cf));
memset (&lf, 0, sizeof (lf));
cf.lStructSize = sizeof (cf);
cf.hwndOwner = FRAME_W32_WINDOW (f);

10
src/w32menu.c
View file

@ -450,8 +450,8 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
/* Save the frame's previous menu bar contents data. */
if (previous_menu_items_used)
bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
previous_menu_items_used * sizeof (Lisp_Object));
memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
previous_menu_items_used * sizeof (Lisp_Object));
/* Fill in menu_items with the current menu bar contents.
This can evaluate Lisp code. */
@ -1522,7 +1522,7 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
if (set_menu_item_info)
{
MENUITEMINFO info;
bzero (&info, sizeof (info));
memset (&info, 0, sizeof (info));
info.cbSize = sizeof (info);
info.fMask = MIIM_DATA;
@ -1605,7 +1605,7 @@ w32_menu_display_help (HWND owner, HMENU menu, UINT item, UINT flags)
{
MENUITEMINFO info;
bzero (&info, sizeof (info));
memset (&info, 0, sizeof (info));
info.cbSize = sizeof (info);
info.fMask = MIIM_DATA;
get_menu_item_info (menu, item, FALSE, &info);
@ -1642,7 +1642,7 @@ w32_free_submenu_strings (HMENU menu)
for (i = 0; i < num; i++)
{
MENUITEMINFO info;
bzero (&info, sizeof (info));
memset (&info, 0, sizeof (info));
info.cbSize = sizeof (info);
info.fMask = MIIM_DATA | MIIM_TYPE | MIIM_SUBMENU;

4
src/w32term.c
View file

@ -323,7 +323,7 @@ XGCValues *
XCreateGC (void *ignore, Window window, unsigned long mask, XGCValues *xgcv)
{
XGCValues *gc = (XGCValues *) xmalloc (sizeof (XGCValues));
bzero (gc, sizeof (XGCValues));
memset (gc, 0, sizeof (XGCValues));
XChangeGC (ignore, gc, mask, xgcv);
@ -5826,7 +5826,7 @@ w32_initialize_display_info (Lisp_Object display_name)
{
struct w32_display_info *dpyinfo = &one_w32_display_info;
bzero (dpyinfo, sizeof (*dpyinfo));
memset (dpyinfo, 0, sizeof (*dpyinfo));
/* Put it on w32_display_name_list. */
w32_display_name_list = Fcons (Fcons (display_name, Qnil),

2
src/w32uniscribe.c
View file

@ -97,7 +97,7 @@ uniscribe_list_family (Lisp_Object frame)
HDC dc;
FRAME_PTR f = XFRAME (frame);
bzero (&font_match_pattern, sizeof (font_match_pattern));
memset (&font_match_pattern, 0, sizeof (font_match_pattern));
/* Limit enumerated fonts to outline fonts to save time. */
font_match_pattern.lfOutPrecision = OUT_OUTLINE_PRECIS;

6
src/w32xfns.c
View file

@ -178,7 +178,7 @@ get_next_msg (W32Msg * lpmsg, BOOL bWait)
if (nQueue)
{
bcopy (&(lpHead->w32msg), lpmsg, sizeof (W32Msg));
memcpy (lpmsg, &lpHead->w32msg, sizeof (W32Msg));
{
int_msg * lpCur = lpHead;
@ -250,7 +250,7 @@ post_msg (W32Msg * lpmsg)
if (!lpNew)
return (FALSE);
bcopy (lpmsg, &(lpNew->w32msg), sizeof (W32Msg));
memcpy (&lpNew->w32msg, lpmsg, sizeof (W32Msg));
lpNew->lpNext = NULL;
enter_crit ();
@ -280,7 +280,7 @@ prepend_msg (W32Msg *lpmsg)
if (!lpNew)
return (FALSE);
bcopy (lpmsg, &(lpNew->w32msg), sizeof (W32Msg));
memcpy (&lpNew->w32msg, lpmsg, sizeof (W32Msg));
enter_crit ();

16
src/window.c
View file

@ -243,9 +243,9 @@ make_window (void)
p->dedicated = Qnil;
p->window_parameters = Qnil;
p->pseudo_window_p = 0;
bzero (&p->cursor, sizeof (p->cursor));
bzero (&p->last_cursor, sizeof (p->last_cursor));
bzero (&p->phys_cursor, sizeof (p->phys_cursor));
memset (&p->cursor, 0, sizeof (p->cursor));
memset (&p->last_cursor, 0, sizeof (p->last_cursor));
memset (&p->phys_cursor, 0, sizeof (p->phys_cursor));
p->desired_matrix = p->current_matrix = 0;
p->nrows_scale_factor = p->ncols_scale_factor = 1;
p->phys_cursor_type = -1;
@ -1557,9 +1557,9 @@ replace_window (Lisp_Object old, Lisp_Object replacement)
p->total_lines = o->total_lines;
p->desired_matrix = p->current_matrix = 0;
p->vscroll = 0;
bzero (&p->cursor, sizeof (p->cursor));
bzero (&p->last_cursor, sizeof (p->last_cursor));
bzero (&p->phys_cursor, sizeof (p->phys_cursor));
memset (&p->cursor, 0, sizeof (p->cursor));
memset (&p->last_cursor, 0, sizeof (p->last_cursor));
memset (&p->phys_cursor, 0, sizeof (p->phys_cursor));
p->phys_cursor_type = -1;
p->phys_cursor_width = -1;
p->must_be_updated_p = 0;
@ -3481,7 +3481,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
XSETFASTINT (w->window_end_pos, 0);
XSETFASTINT (w->window_end_vpos, 0);
bzero (&w->last_cursor, sizeof w->last_cursor);
memset (&w->last_cursor, 0, sizeof w->last_cursor);
w->window_end_valid = Qnil;
if (!(keep_margins_p && samebuf))
{ /* If we're not actually changing the buffer, don't reset hscroll and
@ -3948,7 +3948,7 @@ See Info node `(elisp)Splitting Windows' for more details and examples. */)
p->parent = o->parent;
p->buffer = Qt;
p->window_end_valid = Qnil;
bzero (&p->last_cursor, sizeof p->last_cursor);
memset (&p->last_cursor, 0, sizeof p->last_cursor);
/* Duplicate special geometry settings. */

22
src/xdisp.c
View file

@ -2576,7 +2576,7 @@ init_iterator (struct it *it, struct window *w,
}
/* Clear IT. */
bzero (it, sizeof *it);
memset (it, 0, sizeof *it);
it->current.overlay_string_index = -1;
it->current.dpvec_index = -1;
it->base_face_id = remapped_base_face_id;
@ -4912,7 +4912,7 @@ load_overlay_strings (struct it *it, int charpos)
entries = \
(struct overlay_entry *) alloca (new_size \
* sizeof *entries); \
bcopy (old, entries, size * sizeof *entries); \
memcpy (entries, old, size * sizeof *entries); \
size = new_size; \
} \
\
@ -5630,7 +5630,7 @@ reseat_to_string (struct it *it, unsigned char *s, Lisp_Object string,
it->stop_charpos = -1;
/* Set iterator position and end position. */
bzero (&it->current, sizeof it->current);
memset (&it->current, 0, sizeof it->current);
it->current.overlay_string_index = -1;
it->current.dpvec_index = -1;
xassert (charpos >= 0);
@ -7999,7 +7999,7 @@ add_to_log (char *format, Lisp_Object arg1, Lisp_Object arg2)
len = SBYTES (msg) + 1;
SAFE_ALLOCA (buffer, char *, len);
bcopy (SDATA (msg), buffer, len);
memcpy (buffer, SDATA (msg), len);
message_dolog (buffer, len - 1, 1, 0);
SAFE_FREE ();
@ -8328,7 +8328,7 @@ message3 (Lisp_Object m, int nbytes, int multibyte)
USE_SAFE_ALLOCA;
SAFE_ALLOCA (buffer, char *, nbytes);
bcopy (SDATA (m), buffer, nbytes);
memcpy (buffer, SDATA (m), nbytes);
message_dolog (buffer, nbytes, 1, multibyte);
SAFE_FREE ();
}
@ -9754,7 +9754,7 @@ x_consider_frame_title (Lisp_Object frame)
higher level than this.) */
if (! STRINGP (f->name)
|| SBYTES (f->name) != len
|| bcmp (title, SDATA (f->name), len) != 0)
|| memcmp (title, SDATA (f->name), len) != 0)
x_implicitly_set_name (f, make_string (title, len), Qnil);
}
}
@ -16763,7 +16763,7 @@ append_space_for_newline (struct it *it, int default_face_p)
saved_pos = it->position;
it->what = IT_CHARACTER;
bzero (&it->position, sizeof it->position);
memset (&it->position, 0, sizeof it->position);
it->object = make_number (0);
it->c = ' ';
it->len = 1;
@ -16883,7 +16883,7 @@ extend_face_to_end_of_line (struct it *it)
(((it->ascent + it->descent)
* FONT_BASE (font)) / FONT_HEIGHT (font));
saved_pos = it->position;
bzero (&it->position, sizeof it->position);
memset (&it->position, 0, sizeof it->position);
saved_avoid_cursor = it->avoid_cursor_p;
it->avoid_cursor_p = 1;
saved_face_id = it->face_id;
@ -16916,7 +16916,7 @@ extend_face_to_end_of_line (struct it *it)
saved_pos = it->position;
it->what = IT_CHARACTER;
bzero (&it->position, sizeof it->position);
memset (&it->position, 0, sizeof it->position);
it->object = make_number (0);
it->c = ' ';
it->len = 1;
@ -19259,7 +19259,7 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_
eol_str = invalid_eol_type;
eol_str_len = sizeof (invalid_eol_type) - 1;
}
bcopy (eol_str, buf, eol_str_len);
memcpy (buf, eol_str, eol_str_len);
buf += eol_str_len;
}
@ -20397,7 +20397,7 @@ init_glyph_string (struct glyph_string *s,
XChar2b *char2b, struct window *w, struct glyph_row *row,
enum glyph_row_area area, int start, enum draw_glyphs_face hl)
{
bzero (s, sizeof *s);
memset (s, 0, sizeof *s);
s->w = w;
s->f = XFRAME (w->frame);
#ifdef HAVE_NTGUI

54
src/xfaces.c
View file

@ -764,7 +764,7 @@ x_create_gc (f, mask, xgcv)
{
GC gc = xmalloc (sizeof (*gc));
if (gc)
bcopy (xgcv, gc, sizeof (XGCValues));
memcpy (gc, xgcv, sizeof (XGCValues));
return gc;
}
@ -2190,8 +2190,8 @@ get_lface_attributes_no_remap (struct frame *f, Lisp_Object face_name, Lisp_Obje
lface = lface_from_face_name_no_resolve (f, face_name, signal_p);
if (! NILP (lface))
bcopy (XVECTOR (lface)->contents, attrs,
LFACE_VECTOR_SIZE * sizeof *attrs);
memcpy (attrs, XVECTOR (lface)->contents,
LFACE_VECTOR_SIZE * sizeof *attrs);
return !NILP (lface);
}
@ -2861,8 +2861,8 @@ The value is TO. */)
copy = Finternal_make_lisp_face (to, new_frame);
}
bcopy (XVECTOR (lface)->contents, XVECTOR (copy)->contents,
LFACE_VECTOR_SIZE * sizeof (Lisp_Object));
memcpy (XVECTOR (copy)->contents, XVECTOR (lface)->contents,
LFACE_VECTOR_SIZE * sizeof (Lisp_Object));
/* Changing a named face means that all realized faces depending on
that face are invalid. Since we cannot tell which realized faces
@ -3890,9 +3890,9 @@ Default face attributes override any local face attributes. */)
{
/* Ensure that the face vector is fully specified by merging
the previously-cached vector. */
bcopy (oldface->lface, attrs, sizeof attrs);
memcpy (attrs, oldface->lface, sizeof attrs);
merge_face_vectors (f, lvec, attrs, 0);
bcopy (attrs, lvec, sizeof attrs);
memcpy (lvec, attrs, sizeof attrs);
newface = realize_face (c, lvec, DEFAULT_FACE_ID);
if ((! UNSPECIFIEDP (gvec[LFACE_FAMILY_INDEX])
@ -3997,7 +3997,7 @@ face_attr_equal_p (Lisp_Object v1, Lisp_Object v2)
if (SBYTES (v1) != SBYTES (v2))
return 0;
return bcmp (SDATA (v1), SDATA (v2), SBYTES (v1)) == 0;
return memcmp (SDATA (v1), SDATA (v2), SBYTES (v1)) == 0;
case_Lisp_Int:
case Lisp_Symbol:
@ -4169,9 +4169,9 @@ static struct face *
make_realized_face (Lisp_Object *attr)
{
struct face *face = (struct face *) xmalloc (sizeof *face);
bzero (face, sizeof *face);
memset (face, 0, sizeof *face);
face->ascii_face = face;
bcopy (attr, face->lface, sizeof face->lface);
memcpy (face->lface, attr, sizeof face->lface);
return face;
}
@ -4316,10 +4316,10 @@ make_face_cache (struct frame *f)
int size;
c = (struct face_cache *) xmalloc (sizeof *c);
bzero (c, sizeof *c);
memset (c, 0, sizeof *c);
size = FACE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
c->buckets = (struct face **) xmalloc (size);
bzero (c->buckets, size);
memset (c->buckets, 0, size);
c->size = 50;
c->faces_by_id = (struct face **) xmalloc (c->size * sizeof *c->faces_by_id);
c->f = f;
@ -4383,7 +4383,7 @@ free_realized_faces (struct face_cache *c)
c->used = 0;
size = FACE_CACHE_BUCKETS_SIZE * sizeof *c->buckets;
bzero (c->buckets, size);
memset (c->buckets, 0, size);
/* Must do a thorough redisplay the next time. Mark current
matrices as invalid because they will reference faces freed
@ -4680,7 +4680,7 @@ lookup_named_face (struct frame *f, Lisp_Object symbol, int signal_p)
if (! get_lface_attributes (f, symbol, symbol_attrs, signal_p, 0))
return -1;
bcopy (default_face->lface, attrs, sizeof attrs);
memcpy (attrs, default_face->lface, sizeof attrs);
merge_face_vectors (f, symbol_attrs, attrs, 0);
return lookup_face (f, attrs);
@ -4781,7 +4781,7 @@ smaller_face (struct frame *f, int face_id, int steps)
steps = eabs (steps);
face = FACE_FROM_ID (f, face_id);
bcopy (face->lface, attrs, sizeof attrs);
memcpy (attrs, face->lface, sizeof attrs);
pt = last_pt = XFASTINT (attrs[LFACE_HEIGHT_INDEX]);
new_face_id = face_id;
last_height = FONT_HEIGHT (face->font);
@ -4832,7 +4832,7 @@ face_with_height (struct frame *f, int face_id, int height)
return face_id;
face = FACE_FROM_ID (f, face_id);
bcopy (face->lface, attrs, sizeof attrs);
memcpy (attrs, face->lface, sizeof attrs);
attrs[LFACE_HEIGHT_INDEX] = make_number (height);
font_clear_prop (attrs, FONT_SIZE_INDEX);
face_id = lookup_face (f, attrs);
@ -4862,7 +4862,7 @@ lookup_derived_face (struct frame *f, Lisp_Object symbol, int face_id, int signa
if (!get_lface_attributes (f, symbol, symbol_attrs, signal_p, 0))
return -1;
bcopy (default_face->lface, attrs, sizeof attrs);
memcpy (attrs, default_face->lface, sizeof attrs);
merge_face_vectors (f, symbol_attrs, attrs, 0);
return lookup_face (f, attrs);
}
@ -4953,7 +4953,7 @@ x_supports_face_attributes_p (struct frame *f, Lisp_Object *attrs, struct face *
Lisp_Object merged_attrs[LFACE_VECTOR_SIZE];
int i;
bcopy (def_attrs, merged_attrs, sizeof merged_attrs);
memcpy (merged_attrs, def_attrs, sizeof merged_attrs);
merge_face_vectors (f, attrs, merged_attrs, 0);
@ -5274,7 +5274,7 @@ Value is ORDER. */)
int indices[DIM (font_sort_order)];
CHECK_LIST (order);
bzero (indices, sizeof indices);
memset (indices, 0, sizeof indices);
i = 0;
for (list = order;
@ -5306,9 +5306,9 @@ Value is ORDER. */)
if (indices[i] == 0)
signal_error ("Invalid font sort order", order);
if (bcmp (indices, font_sort_order, sizeof indices) != 0)
if (memcmp (indices, font_sort_order, sizeof indices) != 0)
{
bcopy (indices, font_sort_order, sizeof font_sort_order);
memcpy (font_sort_order, indices, sizeof font_sort_order);
free_all_realized_faces (Qnil);
}
@ -5553,7 +5553,7 @@ realize_default_face (struct frame *f)
/* Realize the face; it must be fully-specified now. */
xassert (lface_fully_specified_p (XVECTOR (lface)->contents));
check_lface (lface);
bcopy (XVECTOR (lface)->contents, attrs, sizeof attrs);
memcpy (attrs, XVECTOR (lface)->contents, sizeof attrs);
face = realize_face (c, attrs, DEFAULT_FACE_ID);
#ifdef HAVE_WINDOW_SYSTEM
@ -6074,7 +6074,7 @@ compute_char_face (struct frame *f, int ch, Lisp_Object prop)
{
Lisp_Object attrs[LFACE_VECTOR_SIZE];
struct face *default_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
bcopy (default_face->lface, attrs, sizeof attrs);
memcpy (attrs, default_face->lface, sizeof attrs);
merge_face_ref (f, prop, attrs, 1, 0);
face_id = lookup_face (f, attrs);
}
@ -6163,7 +6163,7 @@ face_at_buffer_position (w, pos, region_beg, region_end,
return default_face->id;
/* Begin with attributes from the default face. */
bcopy (default_face->lface, attrs, sizeof attrs);
memcpy (attrs, default_face->lface, sizeof attrs);
/* Merge in attributes specified via text properties. */
if (!NILP (prop))
@ -6257,7 +6257,7 @@ face_for_overlay_string (w, pos, region_beg, region_end,
return DEFAULT_FACE_ID;
/* Begin with attributes from the default face. */
bcopy (default_face->lface, attrs, sizeof attrs);
memcpy (attrs, default_face->lface, sizeof attrs);
/* Merge in attributes specified via text properties. */
if (!NILP (prop))
@ -6358,7 +6358,7 @@ face_at_string_position (w, string, pos, bufpos, region_beg,
return base_face->id;
/* Begin with attributes from the base face. */
bcopy (base_face->lface, attrs, sizeof attrs);
memcpy (attrs, base_face->lface, sizeof attrs);
/* Merge in attributes specified via text properties. */
if (!NILP (prop))
@ -6413,7 +6413,7 @@ merge_faces (struct frame *f, Lisp_Object face_name, int face_id, int base_face_
}
/* Begin with attributes from the base face. */
bcopy (base_face->lface, attrs, sizeof attrs);
memcpy (attrs, base_face->lface, sizeof attrs);
if (!NILP (face_name))
{

30
src/xfns.c
View file

@ -1925,7 +1925,7 @@ xic_create_fontsetname (char *base_fontname, int motif)
{ /* There is no base font name, use the default. */
int len = strlen (base_fontname) + 2;
fontsetname = xmalloc (len);
bzero (fontsetname, len);
memset (fontsetname, 0, len);
strcpy (fontsetname, base_fontname);
}
else
@ -1946,7 +1946,7 @@ xic_create_fontsetname (char *base_fontname, int motif)
Use the specified font plus the default. */
int len = strlen (base_fontname) + strlen (xic_defaut_fontset) + 3;
fontsetname = xmalloc (len);
bzero (fontsetname, len);
memset (fontsetname, 0, len);
strcpy (fontsetname, base_fontname);
strcat (fontsetname, sep);
strcat (fontsetname, xic_defaut_fontset);
@ -1983,7 +1983,7 @@ xic_create_fontsetname (char *base_fontname, int motif)
int diff = (p2 - p3) - 2;
base = alloca (strlen (base_fontname) + 1);
bcopy (base_fontname, base, p3 - base_fontname);
memcpy (base, base_fontname, p3 - base_fontname);
base[p3 - base_fontname] = '*';
base[(p3 - base_fontname) + 1] = '-';
strcpy (base + (p3 - base_fontname) + 2, p2);
@ -1996,33 +1996,33 @@ xic_create_fontsetname (char *base_fontname, int motif)
/* Build the font spec that matches all charsets. */
len = p - base_fontname + strlen (allcs) + 1;
font_allcs = (char *) alloca (len);
bzero (font_allcs, len);
bcopy (base_fontname, font_allcs, p - base_fontname);
memset (font_allcs, 0, len);
memcpy (font_allcs, base_fontname, p - base_fontname);
strcat (font_allcs, allcs);
/* Build the font spec that matches all families and
add-styles. */
len = p - p1 + strlen (allcs) + strlen (allfamilies) + 1;
font_allfamilies = (char *) alloca (len);
bzero (font_allfamilies, len);
memset (font_allfamilies, 0, len);
strcpy (font_allfamilies, allfamilies);
bcopy (p1, font_allfamilies + strlen (allfamilies), p - p1);
memcpy (font_allfamilies + strlen (allfamilies), p1, p - p1);
strcat (font_allfamilies, allcs);
/* Build the font spec that matches all. */
len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
font_all = (char *) alloca (len);
bzero (font_all, len);
memset (font_all, 0, len);
strcpy (font_all, allfamilies);
strcat (font_all, all);
bcopy (p2, font_all + strlen (all) + strlen (allfamilies), p - p2);
memcpy (font_all + strlen (all) + strlen (allfamilies), p2, p - p2);
strcat (font_all, allcs);
/* Build the actual font set name. */
len = strlen (base_fontname) + strlen (font_allcs)
+ strlen (font_allfamilies) + strlen (font_all) + 5;
fontsetname = xmalloc (len);
bzero (fontsetname, len);
memset (fontsetname, 0, len);
strcpy (fontsetname, base_fontname);
strcat (fontsetname, sep);
strcat (fontsetname, font_allcs);
@ -3194,7 +3194,7 @@ This function is an internal primitive--use `make-frame' instead. */)
f->output_method = output_x_window;
f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
bzero (f->output_data.x, sizeof (struct x_output));
memset (f->output_data.x, 0, sizeof (struct x_output));
f->output_data.x->icon_bitmap = -1;
FRAME_FONTSET (f) = -1;
f->output_data.x->scroll_bar_foreground_pixel = -1;
@ -4431,7 +4431,7 @@ no value of TYPE. */)
elements."
This applies even if long is more than 32 bits, the X library
converts from 32 bit elements received from the X server to long
and passes the long array to us. Thus, for that case bcopy can not
and passes the long array to us. Thus, for that case memcpy can not
be used. We convert to a 32 bit type here, because so much code
assume on that.
@ -4687,7 +4687,7 @@ x_create_tip_frame (struct x_display_info *dpyinfo, Lisp_Object parms, Lisp_Obje
counts etc. */
f->output_method = output_x_window;
f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
bzero (f->output_data.x, sizeof (struct x_output));
memset (f->output_data.x, 0, sizeof (struct x_output));
f->output_data.x->icon_bitmap = -1;
FRAME_FONTSET (f) = -1;
f->output_data.x->scroll_bar_foreground_pixel = -1;
@ -5729,9 +5729,9 @@ present and mapped to the usual X keysyms. */)
/* The XKB symbolic key names can be seen most easily in
the PS file generated by `xkbprint -label name
$DISPLAY'. */
if (bcmp ("DELE", kb->names->keys[i].name, 4) == 0)
if (memcmp ("DELE", kb->names->keys[i].name, 4) == 0)
delete_keycode = i;
else if (bcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
else if (memcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
backspace_keycode = i;
}

8
src/xfont.c
View file

@ -562,7 +562,7 @@ xfont_list (Lisp_Object frame, Lisp_Object spec)
val = assq_no_quit (QCname, AREF (spec, FONT_EXTRA_INDEX));
if (CONSP (val) && STRINGP (XCDR (val)) && SBYTES (XCDR (val)) < 512)
{
bcopy (SDATA (XCDR (val)), name, SBYTES (XCDR (val)) + 1);
memcpy (name, SDATA (XCDR (val)), SBYTES (XCDR (val)) + 1);
if (xfont_encode_coding_xlfd (name) < 0)
return Qnil;
list = xfont_list_pattern (display, name, registry, script);
@ -590,7 +590,7 @@ xfont_match (Lisp_Object frame, Lisp_Object spec)
return Qnil;
}
else if (SBYTES (XCDR (val)) < 512)
bcopy (SDATA (XCDR (val)), name, SBYTES (XCDR (val)) + 1);
memcpy (name, SDATA (XCDR (val)), SBYTES (XCDR (val)) + 1);
else
return Qnil;
if (xfont_encode_coding_xlfd (name) < 0)
@ -669,7 +669,7 @@ xfont_list_family (Lisp_Object frame)
if (! *p1 || p1 == p0)
continue;
if (last_len == p1 - p0
&& bcmp (last_family, p0, last_len) == 0)
&& memcmp (last_family, p0, last_len) == 0)
continue;
last_len = p1 - p0;
last_family = p0;
@ -980,7 +980,7 @@ xfont_text_extents (struct font *font, unsigned int *code, int nglyphs, struct f
int i, first, x;
if (metrics)
bzero (metrics, sizeof (struct font_metrics));
memset (metrics, 0, sizeof (struct font_metrics));
for (i = 0, x = 0, first = 1; i < nglyphs; i++)
{
XChar2b char2b;

10
src/xmenu.c
View file

@ -1067,8 +1067,8 @@ set_frame_menubar (FRAME_PTR f, int first_time, int deep_p)
/* Save the frame's previous menu bar contents data. */
if (previous_menu_items_used)
bcopy (XVECTOR (f->menu_bar_vector)->contents, previous_items,
previous_menu_items_used * sizeof (Lisp_Object));
memcpy (previous_items, XVECTOR (f->menu_bar_vector)->contents,
previous_menu_items_used * sizeof (Lisp_Object));
/* Fill in menu_items with the current menu bar contents.
This can evaluate Lisp code. */
@ -2452,12 +2452,10 @@ xmenu_show (f, x, y, for_click, keymaps, title, error, timestamp)
item_data
= (unsigned char *) alloca (maxwidth
+ SBYTES (descrip) + 1);
bcopy (SDATA (item_name), item_data,
SBYTES (item_name));
memcpy (item_data, SDATA (item_name), SBYTES (item_name));
for (j = SCHARS (item_name); j < maxwidth; j++)
item_data[j] = ' ';
bcopy (SDATA (descrip), item_data + j,
SBYTES (descrip));
memcpy (item_data + j, SDATA (descrip), SBYTES (descrip));
item_data[j + SBYTES (descrip)] = 0;
}
else

6
src/xrdb.c
View file

@ -233,7 +233,7 @@ magic_file_p (char *string, int string_len, char *class, char *escaped_suffix, c
path = (char *) realloc (path, path_size);
}
bcopy (next, path + path_len, next_len);
memcpy (path + path_len, next, next_len);
path_len += next_len;
p++;
@ -259,7 +259,7 @@ magic_file_p (char *string, int string_len, char *class, char *escaped_suffix, c
path = (char *) realloc (path, path_size);
}
bcopy (suffix, path + path_len, suffix_len);
memcpy (path + path_len, suffix, suffix_len);
path_len += suffix_len;
}
@ -644,7 +644,7 @@ x_get_resource (XrmDatabase rdb, char *name, char *class, XrmRepresentation expe
if (type == x_rm_string)
ret_value->addr = (char *) value.addr;
else
bcopy (value.addr, ret_value->addr, ret_value->size);
memcpy (ret_value->addr, value.addr, ret_value->size);
return value.size;
}

8
src/xselect.c
View file

@ -191,7 +191,7 @@ x_queue_event (struct input_event *event)
This only happens for large requests which uses the incremental protocol. */
for (queue_tmp = selection_queue; queue_tmp; queue_tmp = queue_tmp->next)
{
if (!bcmp (&queue_tmp->event, event, sizeof (*event)))
if (!memcmp (&queue_tmp->event, event, sizeof (*event)))
{
TRACE1 ("DECLINE DUP SELECTION EVENT %08lx", (unsigned long)queue_tmp);
x_decline_selection_request (event);
@ -1534,7 +1534,7 @@ x_get_window_property (display, window, property, data_ret, bytes_ret,
elements."
This applies even if long is more than 32 bits, the X library
converts from 32 bit elements received from the X server to long
and passes the long array to us. Thus, for that case bcopy can not
and passes the long array to us. Thus, for that case memcpy can not
be used. We convert to a 32 bit type here, because so much code
assume on that.
@ -1556,7 +1556,7 @@ x_get_window_property (display, window, property, data_ret, bytes_ret,
else
{
*actual_size_ret *= *actual_format_ret / 8;
bcopy (tmp_data, (*data_ret) + offset, *actual_size_ret);
memcpy ((*data_ret) + offset, tmp_data, *actual_size_ret);
offset += *actual_size_ret;
}
@ -1658,7 +1658,7 @@ receive_incremental_selection (display, window, property, target_type,
*data_ret = (unsigned char *) xrealloc (*data_ret, *size_bytes_ret);
}
bcopy (tmp_data, (*data_ret) + offset, tmp_size_bytes);
memcpy ((*data_ret) + offset, tmp_data, tmp_size_bytes);
offset += tmp_size_bytes;
/* Use xfree, not XFree, because x_get_window_property

2
src/xsmfns.c
View file

@ -154,7 +154,7 @@ x_session_check_input (struct input_event *bufp)
/* Check if smc_interact_CB was called and we shall generate a
SAVE_SESSION_EVENT. */
if (emacs_event.kind != NO_EVENT)
bcopy (&emacs_event, bufp, sizeof (struct input_event));
memcpy (bufp, &emacs_event, sizeof (struct input_event));
return emacs_event.kind != NO_EVENT ? 1 : 0;
}

16
src/xterm.c
View file

@ -4131,7 +4131,7 @@ x_send_scroll_bar_event (Lisp_Object window, int part, int portion, int whole)
scroll_bar_windows = (struct window **) xrealloc (scroll_bar_windows,
nbytes);
bzero (&scroll_bar_windows[i], nbytes - old_nbytes);
memset (&scroll_bar_windows[i], 0, nbytes - old_nbytes);
scroll_bar_windows_size = new_size;
}
@ -5608,7 +5608,7 @@ static struct x_display_info *next_noop_dpyinfo;
if (f->output_data.x->saved_menu_event == 0) \
f->output_data.x->saved_menu_event \
= (XEvent *) xmalloc (sizeof (XEvent)); \
bcopy (&event, f->output_data.x->saved_menu_event, size); \
memcpy (f->output_data.x->saved_menu_event, &event, size); \
inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
XSETFRAME (inev.ie.frame_or_window, f); \
} \
@ -6245,7 +6245,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventp, int *finish,
this enables ComposeCharacter to work whether or
not it is combined with Meta. */
if (modifiers & dpyinfo->meta_mod_mask)
bzero (&compose_status, sizeof (compose_status));
memset (&compose_status, 0, sizeof (compose_status));
#ifdef HAVE_X_I18N
if (FRAME_XIC (f))
@ -6293,7 +6293,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventp, int *finish,
if (compose_status.chars_matched > 0 && nbytes == 0)
break;
bzero (&compose_status, sizeof (compose_status));
memset (&compose_status, 0, sizeof (compose_status));
orig_keysym = keysym;
/* Common for all keysym input events. */
@ -6707,7 +6707,7 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventp, int *finish,
by the rest of Emacs, we put it here. */
int tool_bar_p = 0;
bzero (&compose_status, sizeof (compose_status));
memset (&compose_status, 0, sizeof (compose_status));
last_mouse_glyph_frame = 0;
last_user_time = event.xbutton.time;
@ -7553,7 +7553,7 @@ x_check_errors (Display *dpy, char *format)
if (x_error_message->string[0])
{
char string[X_ERROR_MESSAGE_SIZE];
bcopy (x_error_message->string, string, X_ERROR_MESSAGE_SIZE);
memcpy (string, x_error_message->string, X_ERROR_MESSAGE_SIZE);
x_uncatch_errors ();
error (format, string);
}
@ -8077,7 +8077,7 @@ xim_initialize (struct x_display_info *dpyinfo, char *resource_name)
xim_inst->dpyinfo = dpyinfo;
len = strlen (resource_name);
xim_inst->resource_name = (char *) xmalloc (len + 1);
bcopy (resource_name, xim_inst->resource_name, len + 1);
memcpy (xim_inst->resource_name, resource_name, len + 1);
XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
resource_name, EMACS_CLASS,
xim_instantiate_callback,
@ -9929,7 +9929,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
/* We have definitely succeeded. Record the new connection. */
dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
bzero (dpyinfo, sizeof *dpyinfo);
memset (dpyinfo, 0, sizeof *dpyinfo);
terminal = x_create_terminal (dpyinfo);