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