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