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
  53 #include "libguile/pairs.h"
  54 #include "libguile/gc.h"
  55
  56
  57 SCM_API SCM scm_cell (scm_t_bits car, scm_t_bits cdr);
  58 SCM_API SCM scm_double_cell (scm_t_bits car, scm_t_bits cbr,
  59                              scm_t_bits ccr, scm_t_bits cdr);
  60
  61 #ifdef HAVE_INLINE
  62
  63 #ifndef EXTERN_INLINE
  64 #define EXTERN_INLINE extern inline
  65 #endif
  66
  67 extern unsigned scm_newcell2_count;
  68 extern unsigned scm_newcell_count;
  69
  70
  71
  72 EXTERN_INLINE
  73 SCM
  74 scm_cell (scm_t_bits car, scm_t_bits cdr)
  75 {
  76   SCM z;
  77
  78   if (SCM_NULLP (scm_i_freelist))
  79     {
  80       z = scm_gc_for_newcell (&scm_i_master_freelist, &scm_i_freelist);
  81     }
  82   else
  83     {
  84       z = scm_i_freelist;
  85       scm_i_freelist = SCM_FREE_CELL_CDR (scm_i_freelist);
  86     }
  87
  88   /*
  89     We update scm_cells_allocated from this function. If we don't
  90     update this explicitly, we will have to walk a freelist somewhere
  91     later on, which seems a lot more expensive.
  92    */
  93   scm_cells_allocated += 1;
  94
  95 #if (SCM_DEBUG_CELL_ACCESSES == 1)
  96     if (scm_debug_cell_accesses_p)
  97     {
  98       if (SCM_GC_MARK_P (z))
  99         {
 100           fprintf(stderr, "scm_cell tried to allocate a marked cell.\n");
 101           abort();
 102         }
 103       else if (SCM_GC_CELL_TYPE(z) != scm_tc_free_cell)
 104         {
 105           fprintf(stderr, "cell from freelist is not a free cell.\n");
 106           abort();
 107         }
 108
 109       SCM_SET_GC_MARK (z);
 110     }
 111 #endif
 112
 113
 114   /* Initialize the type slot last so that the cell is ignored by the
 115      GC until it is completely initialized.  This is only relevant
 116      when the GC can actually run during this code, which it can't for
 117      cooperating threads, but it might be important when we get true
 118      preemptive threads.
 119   */
 120   SCM_GC_SET_CELL_WORD (z, 1, cdr);
 121   SCM_GC_SET_CELL_WORD (z, 0, car);
 122
 123 #ifdef USE_THREADS
 124 #ifndef USE_COOP_THREADS
 125   /* When we are using non-cooperating threads, we might need to make
 126      sure that the initial values for the slots are protected until
 127      the cell is completely initialized.
 128   */
 129 #error review me
 130   scm_remember_upto_here_1 (SCM_PACK (cdr));
 131 #endif
 132 #endif
 133
 134
 135 #if (SCM_DEBUG_CELL_ACCESSES == 1)
 136   if (scm_expensive_debug_cell_accesses_p )
 137     scm_i_expensive_validation_check (z);
 138 #endif
 139
 140   return z;
 141 }
 142
 143 EXTERN_INLINE
 144 SCM
 145 scm_double_cell (scm_t_bits car, scm_t_bits cbr,
 146                  scm_t_bits ccr, scm_t_bits cdr)
 147 {
 148   SCM z;
 149
 150
 151   if (SCM_NULLP (scm_i_freelist2))
 152     {
 153       z = scm_gc_for_newcell (&scm_i_master_freelist2, &scm_i_freelist2);
 154     }
 155   else
 156     {
 157       z = scm_i_freelist2;
 158       scm_i_freelist2 = SCM_FREE_CELL_CDR (scm_i_freelist2);
 159     }
 160
 161   scm_cells_allocated += 2;
 162
 163   /* Initialize the type slot last so that the cell is ignored by the
 164      GC until it is completely initialized.  This is only relevant
 165      when the GC can actually run during this code, which it can't for
 166      cooperating threads, but it might be important when we get true
 167      preemptive threads.
 168   */
 169   SCM_GC_SET_CELL_WORD (z, 1, cbr);
 170   SCM_GC_SET_CELL_WORD (z, 2, ccr);
 171   SCM_GC_SET_CELL_WORD (z, 3, cdr);
 172   SCM_GC_SET_CELL_WORD (z, 0, car);
 173
 174 #ifdef USE_THREADS
 175 #ifndef USE_COOP_THREADS
 176   /* When we are using non-cooperating threads, we might need to make
 177      sure that the initial values for the slots are protected until
 178      the cell is completely initialized.
 179   */
 180 #error review me
 181   scm_remember_upto_here_3 (SCM_PACK (cbr), SCM_PACK (ccr), SCM_PACK (cdr));
 182 #endif
 183 #endif
 184
 185
 186 #if (SCM_DEBUG_CELL_ACCESSES == 1)
 187   if (scm_debug_cell_accesses_p)
 188     {
 189       if (SCM_GC_MARK_P (z))
 190         {
 191           fprintf(stderr,
 192                   "scm_double_cell tried to allocate a marked cell.\n");
 193           abort();
 194         }
 195
 196       SCM_SET_GC_MARK (z);
 197     }
 198 #endif
 199
 200   return z;
 201 }
 202
 203
 204
 205 #endif
 206 #endif