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   SCM_NEWCELL (z);
  90
  91   entry = scm_subr_table_size;
  92   scm_subr_table[entry].handle = z;
  93   scm_subr_table[entry].name = scm_str2symbol (name);
  94   scm_subr_table[entry].generic = 0;
  95   scm_subr_table[entry].properties = SCM_EOL;
  96
  97   SCM_SET_SUBRF (z, fcn);
  98   SCM_SET_CELL_TYPE (z, (entry << 8) + type);
  99   scm_subr_table_size++;
 100
 101   return z;
 102 }
 103
 104 SCM
 105 scm_c_define_subr (const char *name, long type, SCM (*fcn) ())
 106 {
 107   SCM subr = scm_c_make_subr (name, type, fcn);
 108   scm_define (SCM_SUBR_ENTRY(subr).name, subr);
 109   return subr;
 110 }
 111
 112 /* This function isn't currently used since subrs are never freed. */
 113 /* *fixme* Need mutex here. */
 114 void
 115 scm_free_subr_entry (SCM subr)
 116 {
 117   long entry = SCM_SUBRNUM (subr);
 118   /* Move last entry in table to the free position */
 119   scm_subr_table[entry] = scm_subr_table[scm_subr_table_size - 1];
 120   SCM_SET_SUBRNUM (scm_subr_table[entry].handle, entry);
 121   scm_subr_table_size--;
 122 }
 123
 124 SCM
 125 scm_c_make_subr_with_generic (const char *name,
 126                               long type, SCM (*fcn) (), SCM *gf)
 127 {
 128   SCM subr = scm_c_make_subr (name, type, fcn);
 129   SCM_SUBR_ENTRY(subr).generic = gf;
 130   return subr;
 131 }
 132
 133 SCM
 134 scm_c_define_subr_with_generic (const char *name,
 135                                 long type, SCM (*fcn) (), SCM *gf)
 136 {
 137   SCM subr = scm_c_make_subr_with_generic (name, type, fcn, gf);
 138   scm_define (SCM_SUBR_ENTRY(subr).name, subr);
 139   return subr;
 140 }
 141
 142 void
 143 scm_mark_subr_table ()
 144 {
 145   long i;
 146   for (i = 0; i < scm_subr_table_size; ++i)
 147     {
 148       SCM_SETGCMARK (scm_subr_table[i].name);
 149       if (scm_subr_table[i].generic && *scm_subr_table[i].generic)
 150         scm_gc_mark (*scm_subr_table[i].generic);
 151       if (SCM_NIMP (scm_subr_table[i].properties))
 152         scm_gc_mark (scm_subr_table[i].properties);
 153     }
 154 }
 155
 156
 157 #ifdef CCLO
 158 SCM
 159 scm_makcclo (SCM proc, size_t len)
 160 {
 161   scm_t_bits *base = scm_must_malloc (len * sizeof (scm_t_bits), "compiled-closure");
 162   unsigned long i;
 163   SCM s;
 164
 165   for (i = 0; i < len; ++i)
 166     base [i] = SCM_UNPACK (SCM_UNSPECIFIED);
 167
 168   SCM_NEWCELL (s);
 169   SCM_DEFER_INTS;
 170   SCM_SET_CCLO_BASE (s, base);
 171   SCM_SET_CCLO_LENGTH (s, len);
 172   SCM_SET_CCLO_SUBR (s, proc);
 173   SCM_ALLOW_INTS;
 174   return s;
 175 }
 176
 177 /* Undocumented debugging procedure */
 178 #ifdef GUILE_DEBUG
 179 SCM_DEFINE (scm_make_cclo, "make-cclo", 2, 0, 0,
 180             (SCM proc, SCM len),
 181             "Create a compiled closure for @var{proc}, which reserves\n"
 182             "@var{len} objects for its usage.")
 183 #define FUNC_NAME s_scm_make_cclo
 184 {
 185   return scm_makcclo (proc, SCM_INUM (len));
 186 }
 187 #undef FUNC_NAME
 188 #endif
 189 #endif
 190
 191
 192
 193 SCM_DEFINE (scm_procedure_p, "procedure?", 1, 0, 0,
 194             (SCM obj),
 195             "Return @code{#t} if @var{obj} is a procedure.")
 196 #define FUNC_NAME s_scm_procedure_p
 197 {
 198   if (SCM_NIMP (obj))
 199     switch (SCM_TYP7 (obj))
 200       {
 201       case scm_tcs_struct:
 202         if (!SCM_I_OPERATORP (obj))
 203           break;
 204       case scm_tcs_closures:
 205       case scm_tcs_subrs:
 206 #ifdef CCLO
 207       case scm_tc7_cclo:
 208 #endif
 209       case scm_tc7_pws:
 210         return SCM_BOOL_T;
 211       case scm_tc7_smob:
 212         return SCM_BOOL (SCM_SMOB_DESCRIPTOR (obj).apply);
 213       default:
 214         return SCM_BOOL_F;
 215       }
 216   return SCM_BOOL_F;
 217 }
 218 #undef FUNC_NAME
 219
 220 SCM_DEFINE (scm_closure_p, "closure?", 1, 0, 0,
 221            (SCM obj),
 222             "Return @code{#t} if @var{obj} is a closure.")
 223 #define FUNC_NAME s_scm_closure_p
 224 {
 225   return SCM_BOOL (SCM_CLOSUREP (obj));
 226 }
 227 #undef FUNC_NAME
 228
 229 SCM_DEFINE (scm_thunk_p, "thunk?", 1, 0, 0,
 230             (SCM obj),
 231             "Return @code{#t} if @var{obj} is a thunk.")
 232 #define FUNC_NAME s_scm_thunk_p
 233 {
 234   if (SCM_NIMP (obj))
 235     {
 236     again:
 237       switch (SCM_TYP7 (obj))
 238         {
 239         case scm_tcs_closures:
 240           return SCM_BOOL (!SCM_CONSP (SCM_CLOSURE_FORMALS (obj)));
 241         case scm_tc7_subr_0:
 242         case scm_tc7_subr_1o:
 243         case scm_tc7_lsubr:
 244         case scm_tc7_rpsubr:
 245         case scm_tc7_asubr:
 246 #ifdef CCLO
 247         case scm_tc7_cclo:
 248 #endif
 249           return SCM_BOOL_T;
 250         case scm_tc7_pws:
 251           obj = SCM_PROCEDURE (obj);
 252           goto again;
 253         default:
 254           ;
 255         }
 256     }
 257   return SCM_BOOL_F;
 258 }
 259 #undef FUNC_NAME
 260
 261 /* Only used internally. */
 262 int
 263 scm_subr_p (SCM obj)
 264 {
 265   if (SCM_NIMP (obj))
 266     switch (SCM_TYP7 (obj))
 267       {
 268       case scm_tcs_subrs:
 269         return 1;
 270       default:
 271         ;
 272       }
 273   return 0;
 274 }
 275
 276 SCM_DEFINE (scm_procedure_documentation, "procedure-documentation", 1, 0, 0,
 277            (SCM proc),
 278             "Return the documentation string associated with @code{proc}.  By\n"
 279             "convention, if a procedure contains more than one expression and the\n"
 280             "first expression is a string constant, that string is assumed to contain\n"
 281             "documentation for that procedure.")
 282 #define FUNC_NAME s_scm_procedure_documentation
 283 {
 284   SCM code;
 285   SCM_ASSERT (SCM_EQ_P (scm_procedure_p (proc), SCM_BOOL_T) && SCM_NIMP (proc),
 286               proc, SCM_ARG1, FUNC_NAME);
 287   switch (SCM_TYP7 (proc))
 288     {
 289     case scm_tcs_closures:
 290       code = SCM_CDR (SCM_CODE (proc));
 291       if (SCM_IMP (SCM_CDR (code)))
 292         return SCM_BOOL_F;
 293       code = SCM_CAR (code);
 294       if (SCM_IMP (code))
 295         return SCM_BOOL_F;
 296       if (SCM_STRINGP (code))
 297         return code;
 298     default:
 299       return SCM_BOOL_F;
 300 /*
 301   case scm_tcs_subrs:
 302 #ifdef CCLO
 303   case scm_tc7_cclo:
 304 #endif
 305 */
 306     }
 307 }
 308 #undef FUNC_NAME
 309
 310
 311 /* Procedure-with-setter
 312  */
 313
 314 SCM_DEFINE (scm_procedure_with_setter_p, "procedure-with-setter?", 1, 0, 0,
 315             (SCM obj),
 316             "Return @code{#t} if @var{obj} is a procedure with an\n"
 317             "associated setter procedure.")
 318 #define FUNC_NAME s_scm_procedure_with_setter_p
 319 {
 320   return SCM_BOOL(SCM_PROCEDURE_WITH_SETTER_P (obj));
 321 }
 322 #undef FUNC_NAME
 323
 324 SCM_DEFINE (scm_make_procedure_with_setter, "make-procedure-with-setter", 2, 0, 0,
 325             (SCM procedure, SCM setter),
 326             "Create a new procedure which behaves like @var{procedure}, but\n"
 327             "with the associated setter @var{setter}.")
 328 #define FUNC_NAME s_scm_make_procedure_with_setter
 329 {
 330   SCM z;
 331   SCM_VALIDATE_PROC (1, procedure);
 332   SCM_VALIDATE_PROC (2, setter);
 333   SCM_NEWCELL2 (z);
 334   SCM_ENTER_A_SECTION;
 335   SCM_SET_CELL_OBJECT_1 (z, procedure);
 336   SCM_SET_CELL_OBJECT_2 (z, setter);
 337   SCM_SET_CELL_TYPE (z, scm_tc7_pws);
 338   SCM_EXIT_A_SECTION;
 339   return z;
 340 }
 341 #undef FUNC_NAME
 342
 343 SCM_DEFINE (scm_procedure, "procedure", 1, 0, 0,
 344             (SCM proc),
 345             "Return the procedure of @var{proc}, which must be either a\n"
 346             "procedure with setter, or an operator struct.")
 347 #define FUNC_NAME s_scm_procedure
 348 {
 349   SCM_VALIDATE_NIM (1, proc);
 350   if (SCM_PROCEDURE_WITH_SETTER_P (proc))
 351     return SCM_PROCEDURE (proc);
 352   else if (SCM_STRUCTP (proc))
 353     {
 354       SCM_ASSERT (SCM_I_OPERATORP (proc), proc, SCM_ARG1, FUNC_NAME);
 355       return proc;
 356     }
 357   SCM_WRONG_TYPE_ARG (1, proc);
 358   return SCM_BOOL_F; /* not reached */
 359 }
 360 #undef FUNC_NAME
 361
 362 SCM_GPROC (s_setter, "setter", 1, 0, 0, scm_setter, g_setter);
 363
 364 SCM
 365 scm_setter (SCM proc)
 366 {
 367   SCM_GASSERT1 (SCM_NIMP (proc), g_setter, proc, SCM_ARG1, s_setter);
 368   if (SCM_PROCEDURE_WITH_SETTER_P (proc))
 369     return SCM_SETTER (proc);
 370   else if (SCM_STRUCTP (proc))
 371     {
 372       SCM setter;
 373       SCM_GASSERT1 (SCM_I_OPERATORP (proc),
 374                     g_setter, proc, SCM_ARG1, s_setter);
 375       setter = (SCM_I_ENTITYP (proc)
 376                 ? SCM_ENTITY_SETTER (proc)
 377                 : SCM_OPERATOR_SETTER (proc));
 378       if (SCM_NIMP (setter))
 379         return setter;
 380       /* fall through */
 381     }
 382   SCM_WTA_DISPATCH_1 (g_setter, proc, SCM_ARG1, s_setter);
 383   return SCM_BOOL_F; /* not reached */
 384 }
 385
 386
 387 void
 388 scm_init_subr_table ()
 389 {
 390   scm_subr_table
 391     = ((scm_t_subr_entry *)
 392        scm_must_malloc (sizeof (scm_t_subr_entry) * scm_subr_table_room,
 393                         "scm_subr_table"));
 394 }
 395
 396 void
 397 scm_init_procs ()
 398 {
 399 #ifndef SCM_MAGIC_SNARFER
 400 #include "libguile/procs.x"
 401 #endif
 402 }
 403
 404 #if SCM_DEBUG_DEPRECATED == 0
 405
 406 SCM
 407 scm_make_subr_opt (const char *name, int type, SCM (*fcn) (), int set)
 408 {
 409   scm_c_issue_deprecation_warning
 410     ("`scm_make_subr_opt' is deprecated.  Use `scm_c_make_subr' or "
 411      "`scm_c_define_subr' instead.");
 412
 413   if (set)
 414     return scm_c_define_subr (name, type, fcn);
 415   else
 416     return scm_c_make_subr (name, type, fcn);
 417 }
 418
 419 SCM
 420 scm_make_subr (const char *name, int type, SCM (*fcn) ())
 421 {
 422   scm_c_issue_deprecation_warning
 423     ("`scm_make_subr' is deprecated.  Use `scm_c_define_subr' instead.");
 424
 425   return scm_c_define_subr (name, type, fcn);
 426 }
 427
 428 SCM
 429 scm_make_subr_with_generic (const char *name, int type, SCM (*fcn) (), SCM *gf)
 430 {
 431   scm_c_issue_deprecation_warning
 432     ("`scm_make_subr_with_generic' is deprecated.  Use "
 433      "`scm_c_define_subr_with_generic' instead.");
 434
 435   return scm_c_define_subr_with_generic (name, type, fcn, gf);
 436 }
 437
 438 #endif /* !SCM_DEBUG_DEPRECATION */
 439
 440 /*
 441   Local Variables:
 442   c-file-style: "gnu"
 443   End:
 444 */