libguile/procs.c

   1 /*      Copyright (C) 1995,1996,1997 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 \f
  42
  43 #include <stdio.h>
  44 #include "_scm.h"
  45
  46 #include "objects.h"
  47
  48 #include "procs.h"
  49 \f
  50
  51
  52 /* {Procedures}
  53  */
  54
  55 scm_subr_entry *scm_subr_table;
  56
  57 /* libguile contained approx. 700 primitive procedures on 24 Aug 1999. */
  58
  59 int scm_subr_table_size = 0;
  60 int scm_subr_table_room = 750;
  61
  62 SCM
  63 scm_make_subr_opt (name, type, fcn, set)
  64      const char *name;
  65      int type;
  66      SCM (*fcn) ();
  67      int set;
  68 {
  69   SCM symcell;
  70   register SCM z;
  71   int entry;
  72
  73   if (scm_subr_table_size == scm_subr_table_room)
  74     {
  75       scm_sizet new_size = scm_subr_table_room * 3 / 2;
  76       void *new_table
  77         = scm_must_realloc ((char *) scm_subr_table,
  78                             sizeof (scm_subr_entry) * scm_subr_table_room,
  79                             sizeof (scm_subr_entry) * new_size,
  80                             "scm_make_subr_opt");
  81       scm_subr_table = new_table;
  82       scm_subr_table_room = new_size;
  83     }
  84
  85   SCM_NEWCELL (z);
  86   symcell = set ? scm_sysintern0 (name) : scm_intern0 (name);
  87
  88   entry = scm_subr_table_size;
  89   scm_subr_table[entry].handle = z;
  90   scm_subr_table[entry].name = SCM_CAR (symcell);
  91   scm_subr_table[entry].generic = 0;
  92   scm_subr_table[entry].properties = SCM_EOL;
  93   scm_subr_table[entry].documentation = SCM_BOOL_F;
  94
  95   SCM_SUBRF (z) = fcn;
  96   SCM_SETCAR (z, (entry << 8) + type);
  97   scm_subr_table_size++;
  98
  99   if (set)
 100     SCM_SETCDR (symcell, z);
 101
 102   return z;
 103 }
 104
 105 /* This function isn't currently used since subrs are never freed. */
 106 /* *fixme* Need mutex here. */
 107 void
 108 scm_free_subr_entry (SCM subr)
 109 {
 110   int entry = SCM_SUBRNUM (subr);
 111   /* Move last entry in table to the free position */
 112   scm_subr_table[entry] = scm_subr_table[scm_subr_table_size - 1];
 113   SCM_SET_SUBRNUM (scm_subr_table[entry].handle, entry);
 114   scm_subr_table_size--;
 115 }
 116
 117 SCM
 118 scm_make_subr (name, type, fcn)
 119      const char *name;
 120      int type;
 121      SCM (*fcn) ();
 122 {
 123   return scm_make_subr_opt (name, type, fcn, 1);
 124 }
 125
 126 SCM
 127 scm_make_subr_with_generic (const char *name, int type, SCM (*fcn) (), SCM *gf)
 128 {
 129   SCM subr = scm_make_subr_opt (name, type, fcn, 1);
 130   scm_subr_table[scm_subr_table_size - 1].generic = gf;
 131   return subr;
 132 }
 133
 134 void
 135 scm_mark_subr_table ()
 136 {
 137   int i;
 138   for (i = 0; i < scm_subr_table_size; ++i)
 139     {
 140       SCM_SETGC8MARK (scm_subr_table[i].name);
 141       if (scm_subr_table[i].generic && *scm_subr_table[i].generic)
 142         scm_gc_mark (*scm_subr_table[i].generic);
 143       if (SCM_NIMP (scm_subr_table[i].properties))
 144         scm_gc_mark (scm_subr_table[i].properties);
 145       if (SCM_NIMP (scm_subr_table[i].documentation))
 146         scm_gc_mark (scm_subr_table[i].documentation);
 147     }
 148 }
 149
 150
 151 #ifdef CCLO
 152 SCM
 153 scm_makcclo (proc, len)
 154      SCM proc;
 155      long len;
 156 {
 157   SCM s;
 158   SCM_NEWCELL (s);
 159   SCM_DEFER_INTS;
 160   SCM_SETCHARS (s, scm_must_malloc (len * sizeof (SCM), "compiled-closure"));
 161   SCM_SETLENGTH (s, len, scm_tc7_cclo);
 162   while (--len)
 163     SCM_VELTS (s)[len] = SCM_UNSPECIFIED;
 164   SCM_CCLO_SUBR (s) = proc;
 165   SCM_ALLOW_INTS;
 166   return s;
 167 }
 168
 169 /* Undocumented debugging procedure */
 170 #ifdef GUILE_DEBUG
 171 SCM_PROC (s_make_cclo, "make-cclo", 2, 0, 0, scm_make_cclo);
 172
 173 SCM
 174 scm_make_cclo (proc, len)
 175      SCM proc;
 176      SCM len;
 177 {
 178   return scm_makcclo (proc, SCM_INUM (len));
 179 }
 180 #endif
 181 #endif
 182
 183
 184
 185 SCM_PROC(s_procedure_p, "procedure?", 1, 0, 0, scm_procedure_p);
 186
 187 SCM
 188 scm_procedure_p (obj)
 189      SCM obj;
 190 {
 191   if (SCM_NIMP (obj))
 192     switch (SCM_TYP7 (obj))
 193       {
 194       case scm_tcs_cons_gloc:
 195         if (!SCM_I_OPERATORP (obj))
 196           break;
 197       case scm_tcs_closures:
 198       case scm_tc7_contin:
 199       case scm_tcs_subrs:
 200 #ifdef CCLO
 201       case scm_tc7_cclo:
 202 #endif
 203       case scm_tc7_pws:
 204         return SCM_BOOL_T;
 205       default:
 206         return SCM_BOOL_F;
 207       }
 208   return SCM_BOOL_F;
 209 }
 210
 211 SCM_PROC(s_closure_p, "closure?", 1, 0, 0, scm_closure_p);
 212
 213 SCM
 214 scm_closure_p (obj)
 215      SCM obj;
 216 {
 217   return SCM_NIMP (obj) && SCM_CLOSUREP (obj) ? SCM_BOOL_T : SCM_BOOL_F;
 218 }
 219
 220 SCM_PROC(s_thunk_p, "thunk?", 1, 0, 0, scm_thunk_p);
 221
 222 #ifdef __STDC__
 223 SCM
 224 scm_thunk_p (SCM obj)
 225 #else
 226 SCM
 227 scm_thunk_p (obj)
 228      SCM obj;
 229 #endif
 230 {
 231   if (SCM_NIMP (obj))
 232     {
 233     again:
 234       switch (SCM_TYP7 (obj))
 235         {
 236         case scm_tcs_closures:
 237           if (SCM_NULLP (SCM_CAR (SCM_CODE (obj))))
 238             return SCM_BOOL_T;
 239         case scm_tc7_subr_0:
 240         case scm_tc7_subr_1o:
 241         case scm_tc7_lsubr:
 242         case scm_tc7_rpsubr:
 243         case scm_tc7_asubr:
 244 #ifdef CCLO
 245         case scm_tc7_cclo:
 246 #endif
 247           return SCM_BOOL_T;
 248         case scm_tc7_pws:
 249           obj = SCM_PROCEDURE (obj);
 250           goto again;
 251         default:
 252           ;
 253         }
 254     }
 255   return SCM_BOOL_F;
 256 }
 257
 258 /* Only used internally. */
 259 int
 260 scm_subr_p (SCM obj)
 261 {
 262   if (SCM_NIMP (obj))
 263     switch (SCM_TYP7 (obj))
 264       {
 265       case scm_tcs_subrs:
 266         return 1;
 267       default:
 268         ;
 269       }
 270   return 0;
 271 }
 272
 273 SCM_PROC(s_procedure_documentation, "procedure-documentation", 1, 0, 0, scm_procedure_documentation);
 274
 275 SCM
 276 scm_procedure_documentation (proc)
 277      SCM proc;
 278 {
 279   SCM code;
 280   SCM_ASSERT (SCM_BOOL_T == scm_procedure_p (proc) && SCM_NIMP (proc) && SCM_TYP7 (proc) != scm_tc7_contin,
 281           proc, SCM_ARG1, s_procedure_documentation);
 282   switch (SCM_TYP7 (proc))
 283     {
 284     case scm_tcs_closures:
 285       code = SCM_CDR (SCM_CODE (proc));
 286       if (SCM_IMP (SCM_CDR (code)))
 287         return SCM_BOOL_F;
 288       code = SCM_CAR (code);
 289       if (SCM_IMP (code))
 290         return SCM_BOOL_F;
 291       if (SCM_STRINGP (code))
 292         return code;
 293     default:
 294       return SCM_BOOL_F;
 295 /*
 296   case scm_tcs_subrs:
 297 #ifdef CCLO
 298   case scm_tc7_cclo:
 299 #endif
 300 */
 301     }
 302 }
 303
 304
 305 /* Procedure-with-setter
 306  */
 307
 308 SCM_PROC (s_procedure_with_setter_p, "procedure-with-setter?", 1, 0, 0, scm_procedure_with_setter_p);
 309
 310 SCM
 311 scm_procedure_with_setter_p (SCM obj)
 312 {
 313   return (SCM_NIMP (obj) && SCM_PROCEDURE_WITH_SETTER_P (obj)
 314           ? SCM_BOOL_T
 315           : SCM_BOOL_F);
 316 }
 317
 318 SCM_PROC (s_make_procedure_with_setter, "make-procedure-with-setter", 2, 0, 0, scm_make_procedure_with_setter);
 319
 320 SCM
 321 scm_make_procedure_with_setter (SCM procedure, SCM setter)
 322 {
 323   SCM z;
 324   SCM_ASSERT (SCM_NFALSEP (scm_procedure_p (procedure)),
 325               procedure, SCM_ARG1, s_make_procedure_with_setter);
 326   SCM_ASSERT (SCM_NFALSEP (scm_procedure_p (setter)),
 327               setter, SCM_ARG2, s_make_procedure_with_setter);
 328   SCM_NEWCELL (z);
 329   SCM_ENTER_A_SECTION;
 330   SCM_SETCDR (z, scm_cons (procedure, setter));
 331   SCM_SETCAR (z, scm_tc7_pws);
 332   SCM_EXIT_A_SECTION;
 333   return z;
 334 }
 335
 336 SCM_PROC (s_procedure, "procedure", 1, 0, 0, scm_procedure);
 337
 338 SCM
 339 scm_procedure (SCM proc)
 340 {
 341   SCM_ASSERT (SCM_NIMP (proc), proc, SCM_ARG1, s_procedure);
 342   if (SCM_PROCEDURE_WITH_SETTER_P (proc))
 343     return SCM_PROCEDURE (proc);
 344   else if (SCM_STRUCTP (proc))
 345     {
 346       SCM_ASSERT (SCM_I_OPERATORP (proc), proc, SCM_ARG1, s_procedure);
 347       return proc;
 348     }
 349   scm_wrong_type_arg (s_procedure, SCM_ARG1, proc);
 350   return 0; /* not reached */
 351 }
 352
 353 SCM_GPROC (s_setter, "setter", 1, 0, 0, scm_setter, g_setter);
 354
 355 SCM
 356 scm_setter (SCM proc)
 357 {
 358   SCM_GASSERT1 (SCM_NIMP (proc), g_setter, proc, SCM_ARG1, s_setter);
 359   if (SCM_PROCEDURE_WITH_SETTER_P (proc))
 360     return SCM_SETTER (proc);
 361   else if (SCM_STRUCTP (proc))
 362     {
 363       SCM setter;
 364       SCM_GASSERT1 (SCM_I_OPERATORP (proc),
 365                     g_setter, proc, SCM_ARG1, s_setter);
 366       setter = (SCM_I_ENTITYP (proc)
 367                 ? SCM_ENTITY_SETTER (proc)
 368                 : SCM_OPERATOR_SETTER (proc));
 369       if (SCM_NIMP (setter))
 370         return setter;
 371       /* fall through */
 372     }
 373   SCM_WTA_DISPATCH_1 (g_setter, proc, SCM_ARG1, s_setter);
 374   return 0;
 375 }
 376
 377
 378 void
 379 scm_init_iprocs(subra, type)
 380      const scm_iproc *subra;
 381      int type;
 382 {
 383   for(;subra->scm_string; subra++)
 384     scm_make_subr(subra->scm_string,
 385                   type,
 386                   subra->cproc);
 387 }
 388
 389
 390 void
 391 scm_init_subr_table ()
 392 {
 393   scm_subr_table
 394     = ((scm_subr_entry *)
 395        scm_must_malloc (sizeof (scm_subr_entry) * scm_subr_table_room,
 396                         "scm_subr_table"));
 397 }
 398
 399 void
 400 scm_init_procs ()
 401 {
 402 #include "procs.x"
 403 }