libguile/procs.c

   1 /* Copyright (C) 1995,1996,1997,1999,2000,2001 Free Software Foundation, Inc.
   2  *
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2, or (at your option)
   6  * any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this software; see the file COPYING.  If not, write to
  15  * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
  16  * Boston, MA 02111-1307 USA
  17  *
  18  * As a special exception, the Free Software Foundation gives permission
  19  * for additional uses of the text contained in its release of GUILE.
  20  *
  21  * The exception is that, if you link the GUILE library with other files
  22  * to produce an executable, this does not by itself cause the
  23  * resulting executable to be covered by the GNU General Public License.
  24  * Your use of that executable is in no way restricted on account of
  25  * linking the GUILE library code into it.
  26  *
  27  * This exception does not however invalidate any other reasons why
  28  * the executable file might be covered by the GNU General Public License.
  29  *
  30  * This exception applies only to the code released by the
  31  * Free Software Foundation under the name GUILE.  If you copy
  32  * code from other Free Software Foundation releases into a copy of
  33  * GUILE, as the General Public License permits, the exception does
  34  * not apply to the code that you add in this way.  To avoid misleading
  35  * anyone as to the status of such modified files, you must delete
  36  * this exception notice from them.
  37  *
  38  * If you write modifications of your own for GUILE, it is your choice
  39  * whether to permit this exception to apply to your modifications.
  40  * If you do not wish that, delete this exception notice.  */
  41
  42
  43 \f
  44
  45 #include "libguile/_scm.h"
  46
  47 #include "libguile/objects.h"
  48 #include "libguile/strings.h"
  49 #include "libguile/vectors.h"
  50 #include "libguile/smob.h"
  51 #include "libguile/deprecation.h"
  52
  53 #include "libguile/validate.h"
  54 #include "libguile/procs.h"
  55 \f
  56
  57
  58 /* {Procedures}
  59  */
  60
  61 scm_t_subr_entry *scm_subr_table;
  62
  63 /* libguile contained approx. 700 primitive procedures on 24 Aug 1999. */
  64
  65 /* Increased to 800 on 2001-05-07 -- Guile now has 779 primitives on
  66    startup, 786 with guile-readline.  'martin */
  67
  68 long scm_subr_table_size = 0;
  69 long scm_subr_table_room = 800;
  70
  71 SCM
  72 scm_c_make_subr (const char *name, long type, SCM (*fcn) ())
  73 {
  74   register SCM z;
  75   long entry;
  76
  77   if (scm_subr_table_size == scm_subr_table_room)
  78     {
  79       long new_size = scm_subr_table_room * 3 / 2;
  80       void *new_table
  81         = scm_must_realloc ((char *) scm_subr_table,
  82                             sizeof (scm_t_subr_entry) * scm_subr_table_room,
  83                             sizeof (scm_t_subr_entry) * new_size,
  84                             "scm_subr_table");
  85       scm_subr_table = new_table;
  86       scm_subr_table_room = new_size;
  87     }
  88
  89   entry = scm_subr_table_size;
  90   z = scm_alloc_cell ((entry << 8) + type, (scm_t_bits) fcn);
  91   scm_subr_table[entry].handle = z;
  92   scm_subr_table[entry].name = scm_str2symbol (name);
  93   scm_subr_table[entry].generic = 0;
  94   scm_subr_table[entry].properties = SCM_EOL;
  95   scm_subr_table_size++;
  96
  97   return z;
  98 }
  99
 100 SCM
 101 scm_c_define_subr (const char *name, long type, SCM (*fcn) ())
 102 {
 103   SCM subr = scm_c_make_subr (name, type, fcn);
 104   scm_define (SCM_SUBR_ENTRY(subr).name, subr);
 105   return subr;
 106 }
 107
 108 /* This function isn't currently used since subrs are never freed. */
 109 /* *fixme* Need mutex here. */
 110 void
 111 scm_free_subr_entry (SCM subr)
 112 {
 113   long entry = SCM_SUBRNUM (subr);
 114   /* Move last entry in table to the free position */
 115   scm_subr_table[entry] = scm_subr_table[scm_subr_table_size - 1];
 116   SCM_SET_SUBRNUM (scm_subr_table[entry].handle, entry);
 117   scm_subr_table_size--;
 118 }
 119
 120 SCM
 121 scm_c_make_subr_with_generic (const char *name,
 122                               long type, SCM (*fcn) (), SCM *gf)
 123 {
 124   SCM subr = scm_c_make_subr (name, type, fcn);
 125   SCM_SUBR_ENTRY(subr).generic = gf;
 126   return subr;
 127 }
 128
 129 SCM
 130 scm_c_define_subr_with_generic (const char *name,
 131                                 long type, SCM (*fcn) (), SCM *gf)
 132 {
 133   SCM subr = scm_c_make_subr_with_generic (name, type, fcn, gf);
 134   scm_define (SCM_SUBR_ENTRY(subr).name, subr);
 135   return subr;
 136 }
 137
 138 void
 139 scm_mark_subr_table ()
 140 {
 141   long i;
 142   for (i = 0; i < scm_subr_table_size; ++i)
 143     {
 144       SCM_SETGCMARK (scm_subr_table[i].name);
 145       if (scm_subr_table[i].generic && *scm_subr_table[i].generic)
 146         scm_gc_mark (*scm_subr_table[i].generic);
 147       if (SCM_NIMP (scm_subr_table[i].properties))
 148         scm_gc_mark (scm_subr_table[i].properties);
 149     }
 150 }
 151
 152
 153 #ifdef CCLO
 154 SCM
 155 scm_makcclo (SCM proc, size_t len)
 156 {
 157   scm_t_bits *base = scm_must_malloc (len * sizeof (scm_t_bits), "compiled-closure");
 158   unsigned long i;
 159   SCM s;
 160
 161   for (i = 0; i < len; ++i)
 162     base [i] = SCM_UNPACK (SCM_UNSPECIFIED);
 163
 164   s = scm_alloc_cell (SCM_MAKE_CCLO_TAG (len), (scm_t_bits) base);
 165   SCM_SET_CCLO_SUBR (s, proc);
 166   return s;
 167 }
 168
 169 /* Undocumented debugging procedure */
 170 #ifdef GUILE_DEBUG
 171 SCM_DEFINE (scm_make_cclo, "make-cclo", 2, 0, 0,
 172             (SCM proc, SCM len),
 173             "Create a compiled closure for @var{proc}, which reserves\n"
 174             "@var{len} objects for its usage.")
 175 #define FUNC_NAME s_scm_make_cclo
 176 {
 177   return scm_makcclo (proc, SCM_INUM (len));
 178 }
 179 #undef FUNC_NAME
 180 #endif
 181 #endif
 182
 183
 184
 185 SCM_DEFINE (scm_procedure_p, "procedure?", 1, 0, 0,
 186             (SCM obj),
 187             "Return @code{#t} if @var{obj} is a procedure.")
 188 #define FUNC_NAME s_scm_procedure_p
 189 {
 190   if (SCM_NIMP (obj))
 191     switch (SCM_TYP7 (obj))
 192       {
 193       case scm_tcs_struct:
 194         if (!SCM_I_OPERATORP (obj))
 195           break;
 196       case scm_tcs_closures:
 197       case scm_tcs_subrs:
 198 #ifdef CCLO
 199       case scm_tc7_cclo:
 200 #endif
 201       case scm_tc7_pws:
 202         return SCM_BOOL_T;
 203       case scm_tc7_smob:
 204         return SCM_BOOL (SCM_SMOB_DESCRIPTOR (obj).apply);
 205       default:
 206         return SCM_BOOL_F;
 207       }
 208   return SCM_BOOL_F;
 209 }
 210 #undef FUNC_NAME
 211
 212 SCM_DEFINE (scm_closure_p, "closure?", 1, 0, 0,
 213            (SCM obj),
 214             "Return @code{#t} if @var{obj} is a closure.")
 215 #define FUNC_NAME s_scm_closure_p
 216 {
 217   return SCM_BOOL (SCM_CLOSUREP (obj));
 218 }
 219 #undef FUNC_NAME
 220
 221 SCM_DEFINE (scm_thunk_p, "thunk?", 1, 0, 0,
 222             (SCM obj),
 223             "Return @code{#t} if @var{obj} is a thunk.")
 224 #define FUNC_NAME s_scm_thunk_p
 225 {
 226   if (SCM_NIMP (obj))
 227     {
 228     again:
 229       switch (SCM_TYP7 (obj))
 230         {
 231         case scm_tcs_closures:
 232           return SCM_BOOL (!SCM_CONSP (SCM_CLOSURE_FORMALS (obj)));
 233         case scm_tc7_subr_0:
 234         case scm_tc7_subr_1o:
 235         case scm_tc7_lsubr:
 236         case scm_tc7_rpsubr:
 237         case scm_tc7_asubr:
 238 #ifdef CCLO
 239         case scm_tc7_cclo:
 240 #endif
 241           return SCM_BOOL_T;
 242         case scm_tc7_pws:
 243           obj = SCM_PROCEDURE (obj);
 244           goto again;
 245         default:
 246           ;
 247         }
 248     }
 249   return SCM_BOOL_F;
 250 }
 251 #undef FUNC_NAME
 252
 253 /* Only used internally. */
 254 int
 255 scm_subr_p (SCM obj)
 256 {
 257   if (SCM_NIMP (obj))
 258     switch (SCM_TYP7 (obj))
 259       {
 260       case scm_tcs_subrs:
 261         return 1;
 262       default:
 263         ;
 264       }
 265   return 0;
 266 }
 267
 268 SCM_DEFINE (scm_procedure_documentation, "procedure-documentation", 1, 0, 0,
 269            (SCM proc),
 270             "Return the documentation string associated with @code{proc}.  By\n"
 271             "convention, if a procedure contains more than one expression and the\n"
 272             "first expression is a string constant, that string is assumed to contain\n"
 273             "documentation for that procedure.")
 274 #define FUNC_NAME s_scm_procedure_documentation
 275 {
 276   SCM code;
 277   SCM_ASSERT (SCM_EQ_P (scm_procedure_p (proc), SCM_BOOL_T) && SCM_NIMP (proc),
 278               proc, SCM_ARG1, FUNC_NAME);
 279   switch (SCM_TYP7 (proc))
 280     {
 281     case scm_tcs_closures:
 282       code = SCM_CDR (SCM_CODE (proc));
 283       if (SCM_IMP (SCM_CDR (code)))
 284         return SCM_BOOL_F;
 285       code = SCM_CAR (code);
 286       if (SCM_IMP (code))
 287         return SCM_BOOL_F;
 288       if (SCM_STRINGP (code))
 289         return code;
 290     default:
 291       return SCM_BOOL_F;
 292 /*
 293   case scm_tcs_subrs:
 294 #ifdef CCLO
 295   case scm_tc7_cclo:
 296 #endif
 297 */
 298     }
 299 }
 300 #undef FUNC_NAME
 301
 302
 303 /* Procedure-with-setter
 304  */
 305
 306 SCM_DEFINE (scm_procedure_with_setter_p, "procedure-with-setter?", 1, 0, 0,
 307             (SCM obj),
 308             "Return @code{#t} if @var{obj} is a procedure with an\n"
 309             "associated setter procedure.")
 310 #define FUNC_NAME s_scm_procedure_with_setter_p
 311 {
 312   return SCM_BOOL(SCM_PROCEDURE_WITH_SETTER_P (obj));
 313 }
 314 #undef FUNC_NAME
 315
 316 SCM_DEFINE (scm_make_procedure_with_setter, "make-procedure-with-setter", 2, 0, 0,
 317             (SCM procedure, SCM setter),
 318             "Create a new procedure which behaves like @var{procedure}, but\n"
 319             "with the associated setter @var{setter}.")
 320 #define FUNC_NAME s_scm_make_procedure_with_setter
 321 {
 322   SCM_VALIDATE_PROC (1, procedure);
 323   SCM_VALIDATE_PROC (2, setter);
 324   return scm_alloc_double_cell (scm_tc7_pws,
 325                                 SCM_UNPACK (procedure),
 326                                 SCM_UNPACK (setter), 0);
 327 }
 328 #undef FUNC_NAME
 329
 330 SCM_DEFINE (scm_procedure, "procedure", 1, 0, 0,
 331             (SCM proc),
 332             "Return the procedure of @var{proc}, which must be either a\n"
 333             "procedure with setter, or an operator struct.")
 334 #define FUNC_NAME s_scm_procedure
 335 {
 336   SCM_VALIDATE_NIM (1, proc);
 337   if (SCM_PROCEDURE_WITH_SETTER_P (proc))
 338     return SCM_PROCEDURE (proc);
 339   else if (SCM_STRUCTP (proc))
 340     {
 341       SCM_ASSERT (SCM_I_OPERATORP (proc), proc, SCM_ARG1, FUNC_NAME);
 342       return proc;
 343     }
 344   SCM_WRONG_TYPE_ARG (1, proc);
 345   return SCM_BOOL_F; /* not reached */
 346 }
 347 #undef FUNC_NAME
 348
 349 SCM_GPROC (s_setter, "setter", 1, 0, 0, scm_setter, g_setter);
 350
 351 SCM
 352 scm_setter (SCM proc)
 353 {
 354   SCM_GASSERT1 (SCM_NIMP (proc), g_setter, proc, SCM_ARG1, s_setter);
 355   if (SCM_PROCEDURE_WITH_SETTER_P (proc))
 356     return SCM_SETTER (proc);
 357   else if (SCM_STRUCTP (proc))
 358     {
 359       SCM setter;
 360       SCM_GASSERT1 (SCM_I_OPERATORP (proc),
 361                     g_setter, proc, SCM_ARG1, s_setter);
 362       setter = (SCM_I_ENTITYP (proc)
 363                 ? SCM_ENTITY_SETTER (proc)
 364                 : SCM_OPERATOR_SETTER (proc));
 365       if (SCM_NIMP (setter))
 366         return setter;
 367       /* fall through */
 368     }
 369   SCM_WTA_DISPATCH_1 (g_setter, proc, SCM_ARG1, s_setter);
 370   return SCM_BOOL_F; /* not reached */
 371 }
 372
 373
 374 void
 375 scm_init_subr_table ()
 376 {
 377   scm_subr_table
 378     = ((scm_t_subr_entry *)
 379        scm_must_malloc (sizeof (scm_t_subr_entry) * scm_subr_table_room,
 380                         "scm_subr_table"));
 381 }
 382
 383 void
 384 scm_init_procs ()
 385 {
 386 #ifndef SCM_MAGIC_SNARFER
 387 #include "libguile/procs.x"
 388 #endif
 389 }
 390
 391 /*
 392   Local Variables:
 393   c-file-style: "gnu"
 394   End:
 395 */