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