(fix_submap_inheritance, get_keyelt, store_in_keymap,

[bpt/emacs.git] / src / vm-limit.c

diff --git a/src/vm-limit.c b/src/vm-limit.c
index 496e392..b23beeb 100644 (file)
--- a/src/vm-limit.c
+++ b/src/vm-limit.c
@@ -1,11 +1,11 @@
 /* Functions for memory limit warnings.
-   Copyright (C) 1990 Free Software Foundation, Inc.
+   Copyright (C) 1990, 1992 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
 GNU Emacs is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
+the Free Software Foundation; either version 2, or (at your option)
 any later version.
 
 GNU Emacs is distributed in the hope that it will be useful,
@@ -15,103 +15,119 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with GNU Emacs; see the file COPYING.  If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
 
-#include "config.h"
+#ifdef emacs
+#include <config.h>
 #include "lisp.h"
-#include "mem_limits.h"
+#endif
+
+#ifndef emacs
+#include <stddef.h>
+typedef size_t SIZE;
+typedef void *POINTER;
+#define EXCEEDS_LISP_PTR(x) 0
+#endif
+
+#include "mem-limits.h"
 
 /*
   Level number of warnings already issued.
   0 -- no warnings issued.
   1 -- 75% warning already issued.
   2 -- 85% warning already issued.
+  3 -- 95% warning issued; keep warning frequently.
 */
 static int warnlevel;
 
 /* Function to call to issue a warning;
    0 means don't issue them.  */
-static void (*warnfunction) ();
-
-extern POINTER sbrk ();
+static void (*warn_function) ();
 
 /* Get more memory space, complaining if we're near the end. */
 
-static POINTER
-morecore_with_warning (size)
-     register int size;
+static void
+check_memory_limits ()
 {
-  POINTER result;
-  register POINTER cp;
-  register unsigned int siz;
+  extern POINTER (*__morecore) ();
 
-  if (!data_space_start)
-    {
-      data_space_start = start_of_data ();
-    }
+  register POINTER cp;
+  unsigned long five_percent;
+  unsigned long data_size;
 
   if (lim_data == 0)
     get_lim_data ();
+  five_percent = lim_data / 20;
 
   /* Find current end of memory and issue warning if getting near max */
-  cp = sbrk (0);
-  siz = cp - data_space_start;
+  cp = (char *) (*__morecore) (0);
+  data_size = (char *) cp - (char *) data_space_start;
 
-  if (warnfunction)
+  if (warn_function)
     switch (warnlevel)
       {
       case 0: 
-       if (siz > (lim_data / 4) * 3)
+       if (data_size > five_percent * 15)
          {
            warnlevel++;
-           (*warnfunction) ("Warning: past 75% of memory limit");
+           (*warn_function) ("Warning: past 75% of memory limit");
          }
        break;
 
       case 1: 
-       if (siz > (lim_data / 20) * 17)
+       if (data_size > five_percent * 17)
          {
            warnlevel++;
-           (*warnfunction) ("Warning: past 85% of memory limit");
+           (*warn_function) ("Warning: past 85% of memory limit");
          }
        break;
 
       case 2: 
-       if (siz > (lim_data / 20) * 19)
+       if (data_size > five_percent * 19)
          {
            warnlevel++;
-           (*warnfunction) ("Warning: past 95% of memory limit");
+           (*warn_function) ("Warning: past 95% of memory limit");
          }
        break;
 
       default:
-       (*warnfunction) ("Warning: past acceptable memory limits");
+       (*warn_function) ("Warning: past acceptable memory limits");
        break;
       }
 
-  if (EXCEEDS_ELISP_PTR (cp))
-    (*warnfunction) ("Warning: memory in use exceeds lisp pointer size");
-
-  result = sbrk (size);
-  if (result == (POINTER) -1)
-    return NULL;
-  return result;
+  /* If we go down below 70% full, issue another 75% warning
+     when we go up again.  */
+  if (data_size < five_percent * 14)
+    warnlevel = 0;
+  /* If we go down below 80% full, issue another 85% warning
+     when we go up again.  */
+  else if (warnlevel > 1 && data_size < five_percent * 16)
+    warnlevel = 1;
+  /* If we go down below 90% full, issue another 95% warning
+     when we go up again.  */
+  else if (warnlevel > 2 && data_size < five_percent * 18)
+    warnlevel = 2;
+
+  if (EXCEEDS_LISP_PTR (cp))
+    (*warn_function) ("Warning: memory in use exceeds lisp pointer size");
 }
 
 /* Cause reinitialization based on job parameters;
    also declare where the end of pure storage is. */
 
 void
-malloc_init (start, warnfun)
+memory_warnings (start, warnfun)
      POINTER start;
      void (*warnfun) ();
 {
-  extern POINTER (* __morecore) ();     /* From gmalloc.c */
+  extern void (* __after_morecore_hook) ();     /* From gmalloc.c */
 
   if (start)
     data_space_start = start;
-  lim_data = 0;
-  warnlevel = 0;
-  warnfunction = warnfun;
-  __morecore = &morecore_with_warning;
+  else
+    data_space_start = start_of_data ();
+
+  warn_function = warnfun;
+  __after_morecore_hook = check_memory_limits;
 }