/* This file contains definitions for deprecated features. When you deprecate something, move it here when that is feasible. */ /* Copyright (C) 2003 Free Software Foundation, Inc. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this software; see the file COPYING. If not, write to * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, MA 02111-1307 USA * * As a special exception, the Free Software Foundation gives permission * for additional uses of the text contained in its release of GUILE. * * The exception is that, if you link the GUILE library with other files * to produce an executable, this does not by itself cause the * resulting executable to be covered by the GNU General Public License. * Your use of that executable is in no way restricted on account of * linking the GUILE library code into it. * * This exception does not however invalidate any other reasons why * the executable file might be covered by the GNU General Public License. * * This exception applies only to the code released by the * Free Software Foundation under the name GUILE. If you copy * code from other Free Software Foundation releases into a copy of * GUILE, as the General Public License permits, the exception does * not apply to the code that you add in this way. To avoid misleading * anyone as to the status of such modified files, you must delete * this exception notice from them. * * If you write modifications of your own for GUILE, it is your choice * whether to permit this exception to apply to your modifications. * If you do not wish that, delete this exception notice. */ #include "libguile/_scm.h" #include "libguile/deprecated.h" #include "libguile/deprecation.h" #include "libguile/snarf.h" #include "libguile/validate.h" #include "libguile/strings.h" #include "libguile/strop.h" #include #include #if (SCM_ENABLE_DEPRECATED == 1) SCM_REGISTER_PROC(s_substring_move_left_x, "substring-move-left!", 5, 0, 0, scm_substring_move_x); SCM_REGISTER_PROC(s_substring_move_right_x, "substring-move-right!", 5, 0, 0, scm_substring_move_x); SCM scm_wta (SCM arg, const char *pos, const char *s_subr) { if (!s_subr || !*s_subr) s_subr = NULL; if ((~0x1fL) & (long) pos) { /* error string supplied. */ scm_misc_error (s_subr, pos, scm_list_1 (arg)); } else { /* numerical error code. */ scm_t_bits error = (scm_t_bits) pos; switch (error) { case SCM_ARGn: scm_wrong_type_arg (s_subr, 0, arg); case SCM_ARG1: scm_wrong_type_arg (s_subr, 1, arg); case SCM_ARG2: scm_wrong_type_arg (s_subr, 2, arg); case SCM_ARG3: scm_wrong_type_arg (s_subr, 3, arg); case SCM_ARG4: scm_wrong_type_arg (s_subr, 4, arg); case SCM_ARG5: scm_wrong_type_arg (s_subr, 5, arg); case SCM_ARG6: scm_wrong_type_arg (s_subr, 6, arg); case SCM_ARG7: scm_wrong_type_arg (s_subr, 7, arg); case SCM_WNA: scm_wrong_num_args (arg); case SCM_OUTOFRANGE: scm_out_of_range (s_subr, arg); case SCM_NALLOC: scm_memory_error (s_subr); default: /* this shouldn't happen. */ scm_misc_error (s_subr, "Unknown error", SCM_EOL); } } return SCM_UNSPECIFIED; } /* Module registry */ /* We can't use SCM objects here. One should be able to call SCM_REGISTER_MODULE from a C++ constructor for a static object. This happens before main and thus before libguile is initialized. */ struct moddata { struct moddata *link; char *module_name; void *init_func; }; static struct moddata *registered_mods = NULL; void scm_register_module_xxx (char *module_name, void *init_func) { struct moddata *md; scm_c_issue_deprecation_warning ("`scm_register_module_xxx' is deprecated. Use extensions instead."); /* XXX - should we (and can we) DEFER_INTS here? */ for (md = registered_mods; md; md = md->link) if (!strcmp (md->module_name, module_name)) { md->init_func = init_func; return; } md = (struct moddata *) malloc (sizeof (struct moddata)); if (md == NULL) { fprintf (stderr, "guile: can't register module (%s): not enough memory", module_name); return; } md->module_name = module_name; md->init_func = init_func; md->link = registered_mods; registered_mods = md; } SCM_DEFINE (scm_registered_modules, "c-registered-modules", 0, 0, 0, (), "Return a list of the object code modules that have been imported into\n" "the current Guile process. Each element of the list is a pair whose\n" "car is the name of the module, and whose cdr is the function handle\n" "for that module's initializer function. The name is the string that\n" "has been passed to scm_register_module_xxx.") #define FUNC_NAME s_scm_registered_modules { SCM res; struct moddata *md; res = SCM_EOL; for (md = registered_mods; md; md = md->link) res = scm_cons (scm_cons (scm_makfrom0str (md->module_name), scm_ulong2num ((unsigned long) md->init_func)), res); return res; } #undef FUNC_NAME SCM_DEFINE (scm_clear_registered_modules, "c-clear-registered-modules", 0, 0, 0, (), "Destroy the list of modules registered with the current Guile process.\n" "The return value is unspecified. @strong{Warning:} this function does\n" "not actually unlink or deallocate these modules, but only destroys the\n" "records of which modules have been loaded. It should therefore be used\n" "only by module bookkeeping operations.") #define FUNC_NAME s_scm_clear_registered_modules { struct moddata *md1, *md2; SCM_DEFER_INTS; for (md1 = registered_mods; md1; md1 = md2) { md2 = md1->link; free (md1); } registered_mods = NULL; SCM_ALLOW_INTS; return SCM_UNSPECIFIED; } #undef FUNC_NAME void scm_i_init_deprecated () { #include "libguile/deprecated.x" } #endif