libguile/inline.h

   1 /* classes: h_files */
   2
   3 #ifndef SCM_INLINE_H
   4 #define SCM_INLINE_H
   5
   6 /* Copyright (C) 2001 Free Software Foundation, Inc.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2, or (at your option)
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this software; see the file COPYING.  If not, write to
  20  * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  21  * Boston, MA 02111-1307 USA
  22  *
  23  * As a special exception, the Free Software Foundation gives permission
  24  * for additional uses of the text contained in its release of GUILE.
  25  *
  26  * The exception is that, if you link the GUILE library with other files
  27  * to produce an executable, this does not by itself cause the
  28  * resulting executable to be covered by the GNU General Public License.
  29  * Your use of that executable is in no way restricted on account of
  30  * linking the GUILE library code into it.
  31  *
  32  * This exception does not however invalidate any other reasons why
  33  * the executable file might be covered by the GNU General Public License.
  34  *
  35  * This exception applies only to the code released by the
  36  * Free Software Foundation under the name GUILE.  If you copy
  37  * code from other Free Software Foundation releases into a copy of
  38  * GUILE, as the General Public License permits, the exception does
  39  * not apply to the code that you add in this way.  To avoid misleading
  40  * anyone as to the status of such modified files, you must delete
  41  * this exception notice from them.
  42  *
  43  * If you write modifications of your own for GUILE, it is your choice
  44  * whether to permit this exception to apply to your modifications.
  45  * If you do not wish that, delete this exception notice.  */
  46
  47 /* This file is for inline functions.  On platforms that don't support
  48    inlining functions, they are turned into ordinary functions.  See
  49    "inline.c".
  50 */
  51
  52 #include "libguile/pairs.h"
  53 #include "libguile/gc.h"
  54
  55 #ifdef HAVE_INLINE
  56
  57 static inline SCM
  58 scm_alloc_cell (scm_t_bits car, scm_t_bits cdr)
  59 {
  60   SCM z;
  61
  62 #ifdef GUILE_DEBUG_FREELIST
  63   scm_newcell_count++;
  64   if (scm_debug_check_freelist)
  65     {
  66       scm_check_freelist (scm_freelist);
  67       scm_gc();
  68     }
  69 #endif
  70
  71   if (SCM_NULLP (scm_freelist))
  72     {
  73       z = scm_gc_for_newcell (&scm_master_freelist, &scm_freelist);
  74     }
  75   else
  76     {
  77       z = scm_freelist;
  78       scm_freelist = SCM_FREE_CELL_CDR (scm_freelist);
  79     }
  80
  81   /* Initialize the type slot last so that the cell is ignored by the
  82      GC until it is completely initialized.  This is only relevant
  83      when the GC can actually run during this code, which it can't for
  84      cooperating threads, but it might be important when we get true
  85      preemptive threads.
  86   */
  87   SCM_GC_SET_CELL_WORD (z, 1, cdr);
  88   SCM_GC_SET_CELL_WORD (z, 0, car);
  89
  90 #ifdef USE_THREADS
  91 #ifndef USE_COOP_THREADS
  92   /* When we are using non-cooperating threads, we might need to make
  93      sure that the initial values for the slots are protected until
  94      the cell is completely initialized.
  95   */
  96 #error review me
  97   scm_remember_upto_here_1 (SCM_PACK (cdr));
  98 #endif
  99 #endif
 100
 101   return z;
 102 }
 103
 104 static inline SCM
 105 scm_alloc_double_cell (scm_t_bits car, scm_t_bits cbr,
 106                        scm_t_bits ccr, scm_t_bits cdr)
 107 {
 108   SCM z;
 109
 110 #ifdef GUILE_DEBUG_FREELIST
 111   scm_newcell2_count++;
 112   if (scm_debug_check_freelist)
 113     {
 114       scm_check_freelist (scm_freelist2);
 115       scm_gc();
 116     }
 117 #endif
 118
 119   if (SCM_NULLP (scm_freelist2))
 120     {
 121       z = scm_gc_for_newcell (&scm_master_freelist2, &scm_freelist2);
 122     }
 123   else
 124     {
 125       z = scm_freelist2;
 126       scm_freelist2 = SCM_FREE_CELL_CDR (scm_freelist2);
 127     }
 128
 129   /* Initialize the type slot last so that the cell is ignored by the
 130      GC until it is completely initialized.  This is only relevant
 131      when the GC can actually run during this code, which it can't for
 132      cooperating threads, but it might be important when we get true
 133      preemptive threads.
 134   */
 135   SCM_GC_SET_CELL_WORD (z, 1, cbr);
 136   SCM_GC_SET_CELL_WORD (z, 2, ccr);
 137   SCM_GC_SET_CELL_WORD (z, 3, cdr);
 138   SCM_GC_SET_CELL_WORD (z, 0, car);
 139
 140 #ifdef USE_THREADS
 141 #ifndef USE_COOP_THREADS
 142   /* When we are using non-cooperating threads, we might need to make
 143      sure that the initial values for the slots are protected until
 144      the cell is completely initialized.
 145   */
 146 #error review me
 147   scm_remember_upto_here_3 (SCM_PACK (cbr), SCM_PACK (ccr), SCM_PACK (cdr));
 148 #endif
 149 #endif
 150
 151   return z;
 152 }
 153
 154 #else /* !HAVE_INLINE */
 155
 156 SCM_API SCM scm_alloc_cell (scm_t_bits car, scm_t_bits cdr);
 157 SCM_API SCM scm_alloc_double_cell (scm_t_bits car, scm_t_bits cbr,
 158                                    scm_t_bits ccr, scm_t_bits cdr);
 159
 160 #endif
 161
 162 #endif