emacs: src/ralloc.c comparison

comparison src/ralloc.c @ 109126:aec1143e8d85

Convert (most) functions in src to standard C. * src/alloc.c: Convert function definitions to standard C. * src/atimer.c: * src/bidi.c: * src/bytecode.c: * src/callint.c: * src/callproc.c: * src/casefiddle.c: * src/casetab.c: * src/category.c: * src/ccl.c: * src/character.c: * src/charset.c: * src/chartab.c: * src/cmds.c: * src/coding.c: * src/composite.c: * src/data.c: * src/dbusbind.c: * src/dired.c: * src/dispnew.c: * src/doc.c: * src/doprnt.c: * src/ecrt0.c: * src/editfns.c: * src/fileio.c: * src/filelock.c: * src/filemode.c: * src/fns.c: * src/font.c: * src/fontset.c: * src/frame.c: * src/fringe.c: * src/ftfont.c: * src/ftxfont.c: * src/gtkutil.c: * src/indent.c: * src/insdel.c: * src/intervals.c: * src/keymap.c: * src/lread.c: * src/macros.c: * src/marker.c: * src/md5.c: * src/menu.c: * src/minibuf.c: * src/prefix-args.c: * src/print.c: * src/ralloc.c: * src/regex.c: * src/region-cache.c: * src/scroll.c: * src/search.c: * src/sound.c: * src/strftime.c: * src/syntax.c: * src/sysdep.c: * src/termcap.c: * src/terminal.c: * src/terminfo.c: * src/textprop.c: * src/tparam.c: * src/undo.c: * src/unexelf.c: * src/window.c: * src/xfaces.c: * src/xfns.c: * src/xfont.c: * src/xftfont.c: * src/xgselect.c: * src/xmenu.c: * src/xrdb.c: * src/xselect.c: * src/xsettings.c: * src/xsmfns.c: * src/xterm.c: Likewise.

author	Dan Nicolaescu <dann@ics.uci.edu>
date	Sun, 04 Jul 2010 00:50:25 -0700
parents	1d1d5d9bd884
children	750db9f3e6d8

comparison

equal deleted inserted replaced

-:12b02558bf51
+:aec1143e8d85
 typedef size_t SIZE;
 /* Declared in dispnew.c, this version doesn't screw up if regions
 overlap.  */
-extern void safe_bcopy ();
+extern void safe_bcopy (const char *, char *, int);
 #ifdef DOUG_LEA_MALLOC
 #define M_TOP_PAD           -2
-extern int mallopt ();
+extern int mallopt (int, int);
 #else /* not DOUG_LEA_MALLOC */
 #ifndef SYSTEM_MALLOC
 extern size_t __malloc_extra_blocks;
 #endif /* SYSTEM_MALLOC */
 #endif /* not DOUG_LEA_MALLOC */
 automatic variable, and loses its value each time Emacs is started
 up.  */
 static int r_alloc_initialized = 0;
-static void r_alloc_init ();
+static void r_alloc_init (void);
 /* Declarations for working with the malloc, ralloc, and system breaks.  */
 /* Function to set the real break value.  */
 /* Functions to get and return memory from the system.  */
 /* Find the heap that ADDRESS falls within.  */
 static heap_ptr
-find_heap (address)
+find_heap (POINTER address)
-POINTER address;
 {
 heap_ptr heap;
 for (heap = last_heap; heap; heap = heap->prev)
 {
 Return the address of the space if all went well, or zero if we couldn't
 allocate the memory.  */
 static POINTER
-obtain (address, size)
+obtain (POINTER address, SIZE size)
-POINTER address;
-SIZE size;
 {
 heap_ptr heap;
 SIZE already_available;
 /* Find the heap that ADDRESS falls within.  */
 if there is a lot of unused space now.
 This can make the last heap smaller;
 it can also eliminate the last heap entirely.  */
 static void
-relinquish ()
+relinquish (void)
 {
 register heap_ptr h;
 long excess = 0;
 /* Add the amount of space beyond break_value
 /* Return the total size in use by relocating allocator,
 above where malloc gets space.  */
 long
-r_alloc_size_in_use ()
+r_alloc_size_in_use (void)
 {
 return (char *) break_value - (char *) virtual_break_value;
 }
 /* The meat - allocating, freeing, and relocating blocs.  */
 /* Find the bloc referenced by the address in PTR.  Returns a pointer
 to that block.  */
 static bloc_ptr
-find_bloc (ptr)
+find_bloc (POINTER *ptr)
-POINTER *ptr;
 {
 register bloc_ptr p = first_bloc;
 while (p != NIL_BLOC)
 {
 /* Allocate a bloc of SIZE bytes and append it to the chain of blocs.
 Returns a pointer to the new bloc, or zero if we couldn't allocate
 memory for the new block.  */
 static bloc_ptr
-get_bloc (size)
+get_bloc (SIZE size)
-SIZE size;
 {
 register bloc_ptr new_bloc;
 register heap_ptr heap;
 if (! (new_bloc = (bloc_ptr) malloc (BLOC_PTR_SIZE))
 Store the new location of each bloc in its new_data field.
 Do not touch the contents of blocs or break_value.  */
 static int
-relocate_blocs (bloc, heap, address)
+relocate_blocs (bloc_ptr bloc, heap_ptr heap, POINTER address)
-bloc_ptr bloc;
-heap_ptr heap;
-POINTER address;
 {
 register bloc_ptr b = bloc;
 /* No need to ever call this if arena is frozen, bug somewhere!  */
 if (r_alloc_freeze_level)
 /* Reorder the bloc BLOC to go before bloc BEFORE in the doubly linked list.
 This is necessary if we put the memory of space of BLOC
 before that of BEFORE.  */
 static void
-reorder_bloc (bloc, before)
+reorder_bloc (bloc_ptr bloc, bloc_ptr before)
-bloc_ptr bloc, before;
 {
 bloc_ptr prev, next;
 /* Splice BLOC out from where it is.  */
 prev = bloc->prev;
 /* Update the records of which heaps contain which blocs, starting
 with heap HEAP and bloc BLOC.  */
 static void
-update_heap_bloc_correspondence (bloc, heap)
+update_heap_bloc_correspondence (bloc_ptr bloc, heap_ptr heap)
-bloc_ptr bloc;
-heap_ptr heap;
 {
 register bloc_ptr b;
 /* Initialize HEAP's status to reflect blocs before BLOC.  */
 if (bloc != NIL_BLOC && bloc->prev != NIL_BLOC && bloc->prev->heap == heap)
 /* Resize BLOC to SIZE bytes.  This relocates the blocs
 that come after BLOC in memory.  */
 static int
-resize_bloc (bloc, size)
+resize_bloc (bloc_ptr bloc, SIZE size)
-bloc_ptr bloc;
-SIZE size;
 {
 register bloc_ptr b;
 heap_ptr heap;
 POINTER address;
 SIZE old_size;
 /* Free BLOC from the chain of blocs, relocating any blocs above it.
 This may return space to the system.  */
 static void
-free_bloc (bloc)
+free_bloc (bloc_ptr bloc)
-bloc_ptr bloc;
 {
 heap_ptr heap = bloc->heap;
 if (r_alloc_freeze_level)
 {
 If we're out of memory, we should return zero, to imitate the other
 __morecore hook values - in particular, __default_morecore in the
 GNU malloc package.  */
 POINTER
-r_alloc_sbrk (size)
+r_alloc_sbrk (long int size)
-long size;
 {
 register bloc_ptr b;
 POINTER address;
 if (! r_alloc_initialized)
 If we can't allocate the necessary memory, set *PTR to zero, and
 return zero.  */
 POINTER
-r_alloc (ptr, size)
+r_alloc (POINTER *ptr, SIZE size)
-POINTER *ptr;
-SIZE size;
 {
 register bloc_ptr new_bloc;
 if (! r_alloc_initialized)
 r_alloc_init ();
 /* Free a bloc of relocatable storage whose data is pointed to by PTR.
 Store 0 in *PTR to show there's no block allocated.  */
 void
-r_alloc_free (ptr)
+r_alloc_free (register POINTER *ptr)
-register POINTER *ptr;
 {
 register bloc_ptr dead_bloc;
 if (! r_alloc_initialized)
 r_alloc_init ();
 If more memory cannot be allocated, then leave *PTR unchanged, and
 return zero.  */
 POINTER
-r_re_alloc (ptr, size)
+r_re_alloc (POINTER *ptr, SIZE size)
-POINTER *ptr;
-SIZE size;
 {
 register bloc_ptr bloc;
 if (! r_alloc_initialized)
 r_alloc_init ();
 of non-relocatable heap if possible.  The relocatable blocs are
 guaranteed to hold still until thawed, even if this means that
 malloc must return a null pointer.  */
 void
-r_alloc_freeze (size)
+r_alloc_freeze (long int size)
-long size;
 {
 if (! r_alloc_initialized)
 r_alloc_init ();
 /* If already frozen, we can't make any more room, so don't try.  */
 if (size > 0)
 r_alloc_sbrk (-size);
 }
 void
-r_alloc_thaw ()
+r_alloc_thaw (void)
 {
 if (! r_alloc_initialized)
 r_alloc_init ();
 #if defined (emacs) && defined (DOUG_LEA_MALLOC)
 /* Reinitialize the morecore hook variables after restarting a dumped
 Emacs.  This is needed when using Doug Lea's malloc from GNU libc.  */
 void
-r_alloc_reinit ()
+r_alloc_reinit (void)
 {
 /* Only do this if the hook has been reset, so that we don't get an
 infinite loop, in case Emacs was linked statically.  */
 if (__morecore != r_alloc_sbrk)
 {
 Used by buffer-swap-text in Emacs to restore consistency after it
 swaps the buffer text between two buffer objects.  The OLD pointer
 is checked to ensure that memory corruption does not occur due to
 misuse.  */
 void
-r_alloc_reset_variable (old, new)
+r_alloc_reset_variable (POINTER *old, POINTER *new)
-POINTER *old, *new;
 {
 bloc_ptr bloc = first_bloc;
 /* Find the bloc that corresponds to the data pointed to by pointer.
 find_bloc cannot be used, as it has internal consistency checks
 ***********************************************************************/
 /* Initialize various things for memory allocation.  */
 static void
-r_alloc_init ()
+r_alloc_init (void)
 {
 if (r_alloc_initialized)
 return;
 r_alloc_initialized = 1;

Mercurial > emacs

comparison src/ralloc.c @ 109126:aec1143e8d85