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
  56 SCM
  57 scm_make_subr_opt (name, type, fcn, set)
  58      const char *name;
  59      int type;
  60      SCM (*fcn) ();
  61      int set;
  62 {
  63   SCM symcell;
  64   long tmp;
  65   register SCM z;
  66   symcell = scm_sysintern (name, SCM_UNDEFINED);
  67   tmp = ((((SCM_CELLPTR) (SCM_CAR (symcell))) - scm_heap_org) << 8);
  68   if ((tmp >> 8) != ((SCM_CELLPTR) (SCM_CAR (symcell)) - scm_heap_org))
  69     tmp = 0;
  70   SCM_NEWCELL (z);
  71   SCM_SUBRF (z) = fcn;
  72   SCM_SETCAR (z, tmp + type);
  73   if (set)
  74     SCM_SETCDR (symcell, z);
  75   return z;
  76 }
  77
  78
  79
  80 SCM
  81 scm_make_subr (name, type, fcn)
  82      const char *name;
  83      int type;
  84      SCM (*fcn) ();
  85 {
  86   return scm_make_subr_opt (name, type, fcn, 1);
  87 }
  88
  89 #ifdef CCLO
  90
  91 SCM
  92 scm_makcclo (proc, len)
  93      SCM proc;
  94      long len;
  95 {
  96   SCM s;
  97   SCM_NEWCELL (s);
  98   SCM_DEFER_INTS;
  99   SCM_SETCHARS (s, scm_must_malloc (len * sizeof (SCM), "compiled-closure"));
 100   SCM_SETLENGTH (s, len, scm_tc7_cclo);
 101   while (--len)
 102     SCM_VELTS (s)[len] = SCM_UNSPECIFIED;
 103   SCM_CCLO_SUBR (s) = proc;
 104   SCM_ALLOW_INTS;
 105   return s;
 106 }
 107
 108 /* Undocumented debugging procedure */
 109 #ifdef GUILE_DEBUG
 110 SCM_PROC (s_make_cclo, "make-cclo", 2, 0, 0, scm_make_cclo);
 111
 112 SCM
 113 scm_make_cclo (proc, len)
 114      SCM proc;
 115      SCM len;
 116 {
 117   return scm_makcclo (proc, SCM_INUM (len));
 118 }
 119 #endif
 120 #endif
 121
 122
 123
 124 SCM_PROC(s_procedure_p, "procedure?", 1, 0, 0, scm_procedure_p);
 125
 126 SCM
 127 scm_procedure_p (obj)
 128      SCM obj;
 129 {
 130   if (SCM_NIMP (obj))
 131     switch (SCM_TYP7 (obj))
 132       {
 133       case scm_tcs_cons_gloc:
 134         if (!SCM_I_OPERATORP (obj))
 135           break;
 136       case scm_tcs_closures:
 137       case scm_tc7_contin:
 138       case scm_tcs_subrs:
 139 #ifdef CCLO
 140       case scm_tc7_cclo:
 141 #endif
 142       case scm_tc7_pws:
 143         return SCM_BOOL_T;
 144       default:
 145         return SCM_BOOL_F;
 146       }
 147   return SCM_BOOL_F;
 148 }
 149
 150 SCM_PROC(s_closure_p, "closure?", 1, 0, 0, scm_closure_p);
 151
 152 SCM
 153 scm_closure_p (obj)
 154      SCM obj;
 155 {
 156   return SCM_NIMP (obj) && SCM_CLOSUREP (obj) ? SCM_BOOL_T : SCM_BOOL_F;
 157 }
 158
 159 SCM_PROC(s_thunk_p, "thunk?", 1, 0, 0, scm_thunk_p);
 160
 161 #ifdef __STDC__
 162 SCM
 163 scm_thunk_p (SCM obj)
 164 #else
 165 SCM
 166 scm_thunk_p (obj)
 167      SCM obj;
 168 #endif
 169 {
 170   if (SCM_NIMP (obj))
 171     {
 172     again:
 173       switch (SCM_TYP7 (obj))
 174         {
 175         case scm_tcs_closures:
 176           if (SCM_NULLP (SCM_CAR (SCM_CODE (obj))))
 177             return SCM_BOOL_T;
 178         case scm_tc7_subr_0:
 179         case scm_tc7_subr_1o:
 180         case scm_tc7_lsubr:
 181         case scm_tc7_rpsubr:
 182         case scm_tc7_asubr:
 183 #ifdef CCLO
 184         case scm_tc7_cclo:
 185 #endif
 186           return SCM_BOOL_T;
 187         case scm_tc7_pws:
 188           obj = SCM_PROCEDURE (obj);
 189           goto again;
 190         default:
 191           ;
 192         }
 193     }
 194   return SCM_BOOL_F;
 195 }
 196
 197 SCM_PROC(s_procedure_documentation, "procedure-documentation", 1, 0, 0, scm_procedure_documentation);
 198
 199 SCM
 200 scm_procedure_documentation (proc)
 201      SCM proc;
 202 {
 203   SCM code;
 204   SCM_ASSERT (SCM_BOOL_T == scm_procedure_p (proc) && SCM_NIMP (proc) && SCM_TYP7 (proc) != scm_tc7_contin,
 205           proc, SCM_ARG1, s_procedure_documentation);
 206   switch (SCM_TYP7 (proc))
 207     {
 208     case scm_tcs_closures:
 209       code = SCM_CDR (SCM_CODE (proc));
 210       if (SCM_IMP (SCM_CDR (code)))
 211         return SCM_BOOL_F;
 212       code = SCM_CAR (code);
 213       if (SCM_IMP (code))
 214         return SCM_BOOL_F;
 215       if (SCM_STRINGP (code))
 216         return code;
 217     default:
 218       return SCM_BOOL_F;
 219 /*
 220   case scm_tcs_subrs:
 221 #ifdef CCLO
 222   case scm_tc7_cclo:
 223 #endif
 224 */
 225     }
 226 }
 227
 228
 229 /* Procedure-with-setter
 230  */
 231
 232 SCM_PROC (s_procedure_with_setter_p, "procedure-with-setter?", 1, 0, 0, scm_procedure_with_setter_p);
 233
 234 SCM
 235 scm_procedure_with_setter_p (SCM obj)
 236 {
 237   return (SCM_NIMP (obj) && SCM_PROCEDURE_WITH_SETTER_P (obj)
 238           ? SCM_BOOL_T
 239           : SCM_BOOL_F);
 240 }
 241
 242 SCM_PROC (s_make_procedure_with_setter, "make-procedure-with-setter", 2, 0, 0, scm_make_procedure_with_setter);
 243
 244 SCM
 245 scm_make_procedure_with_setter (SCM procedure, SCM setter)
 246 {
 247   SCM z;
 248   SCM_ASSERT (SCM_NFALSEP (scm_procedure_p (procedure)),
 249               procedure, SCM_ARG1, s_make_procedure_with_setter);
 250   SCM_ASSERT (SCM_NFALSEP (scm_procedure_p (setter)),
 251               setter, SCM_ARG2, s_make_procedure_with_setter);
 252   SCM_NEWCELL (z);
 253   SCM_ENTER_A_SECTION;
 254   SCM_SETCDR (z, scm_cons (procedure, setter));
 255   SCM_SETCAR (z, scm_tc7_pws);
 256   SCM_EXIT_A_SECTION;
 257   return z;
 258 }
 259
 260 SCM_PROC (s_procedure, "procedure", 1, 0, 0, scm_procedure);
 261
 262 SCM
 263 scm_procedure (SCM proc)
 264 {
 265   SCM_ASSERT (SCM_NIMP (proc), proc, SCM_ARG1, s_procedure);
 266   if (SCM_PROCEDURE_WITH_SETTER_P (proc))
 267     return SCM_PROCEDURE (proc);
 268   else if (SCM_STRUCTP (proc))
 269     {
 270       SCM_ASSERT (SCM_I_OPERATORP (proc), proc, SCM_ARG1, s_procedure);
 271       return proc;
 272     }
 273   scm_wrong_type_arg (s_procedure, SCM_ARG1, proc);
 274   return 0; /* not reached */
 275 }
 276
 277 SCM_PROC (s_setter, "setter", 1, 0, 0, scm_setter);
 278
 279 SCM
 280 scm_setter (SCM proc)
 281 {
 282   SCM_ASSERT (SCM_NIMP (proc), proc, SCM_ARG1, s_setter);
 283   if (SCM_PROCEDURE_WITH_SETTER_P (proc))
 284     return SCM_SETTER (proc);
 285   else if (SCM_STRUCTP (proc))
 286     {
 287       SCM_ASSERT (SCM_I_OPERATORP (proc), proc, SCM_ARG1, s_setter);
 288       return (SCM_I_ENTITYP (proc)
 289               ? SCM_ENTITY_SETTER (proc)
 290               : SCM_OPERATOR_SETTER (proc));
 291     }
 292   scm_wrong_type_arg (s_setter, SCM_ARG1, proc);
 293   return 0;
 294 }
 295
 296 void
 297 scm_init_iprocs(subra, type)
 298      const scm_iproc *subra;
 299      int type;
 300 {
 301   for(;subra->scm_string; subra++)
 302     scm_make_subr(subra->scm_string,
 303                   type,
 304                   subra->cproc);
 305 }
 306
 307
 308
 309
 310
 311 void
 312 scm_init_procs ()
 313 {
 314 #include "procs.x"
 315 }
 316