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