libguile/procs.c

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