libguile/instructions.c

   1 /* Copyright (C) 2001, 2009 Free Software Foundation, Inc.
   2  *
   3  * This library is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU Lesser General Public License
   5  * as published by the Free Software Foundation; either version 3 of
   6  * the License, or (at your option) any later version.
   7  *
   8  * This library is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * Lesser General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public
  14  * License along with this library; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  16  * 02110-1301 USA
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 #  include <config.h>
  21 #endif
  22
  23 #include <string.h>
  24
  25 #include "_scm.h"
  26 #include "vm-bootstrap.h"
  27 #include "instructions.h"
  28
  29 struct scm_instruction {
  30   enum scm_opcode opcode;       /* opcode */
  31   const char *name;             /* instruction name */
  32   signed char len;              /* Instruction length.  This may be -1 for
  33                                    the loader (see the `VM_LOADER'
  34                                    macro).  */
  35   signed char npop;             /* The number of values popped.  This may be
  36                                    -1 for insns like `call' which can take
  37                                    any number of arguments.  */
  38   char npush;                   /* the number of values pushed */
  39   SCM symname;                  /* filled in later */
  40 };
  41
  42 #define SCM_VALIDATE_LOOKUP_INSTRUCTION(pos, var, cvar)               \
  43   do {                                                                \
  44     cvar = scm_lookup_instruction_by_name (var);                      \
  45     SCM_ASSERT_TYPE (cvar, var, pos, FUNC_NAME, "INSTRUCTION_P");     \
  46   } while (0)
  47
  48
  49 static struct scm_instruction*
  50 fetch_instruction_table ()
  51 {
  52   static struct scm_instruction *table = NULL;
  53
  54   if (SCM_UNLIKELY (!table))
  55     {
  56       size_t bytes = SCM_VM_NUM_INSTRUCTIONS * sizeof(struct scm_instruction);
  57       int i;
  58       table = malloc (bytes);
  59       memset (table, 0, bytes);
  60 #define VM_INSTRUCTION_TO_TABLE 1
  61 #include <libguile/vm-expand.h>
  62 #include <libguile/vm-i-system.i>
  63 #include <libguile/vm-i-scheme.i>
  64 #include <libguile/vm-i-loader.i>
  65 #undef VM_INSTRUCTION_TO_TABLE
  66       for (i = 0; i < SCM_VM_NUM_INSTRUCTIONS; i++)
  67         {
  68           table[i].opcode = i;
  69           if (table[i].name)
  70             table[i].symname = scm_from_locale_symbol (table[i].name);
  71           else
  72             table[i].symname = SCM_BOOL_F;
  73         }
  74     }
  75   return table;
  76 }
  77
  78 static struct scm_instruction *
  79 scm_lookup_instruction_by_name (SCM name)
  80 {
  81   static SCM instructions_by_name = SCM_BOOL_F;
  82   struct scm_instruction *table = fetch_instruction_table ();
  83   SCM op;
  84
  85   if (SCM_UNLIKELY (scm_is_false (instructions_by_name)))
  86     {
  87       unsigned int i;
  88
  89       instructions_by_name =
  90         scm_make_hash_table (SCM_I_MAKINUM (SCM_VM_NUM_INSTRUCTIONS));
  91
  92       for (i = 0; i < SCM_VM_NUM_INSTRUCTIONS; i++)
  93         if (scm_is_true (table[i].symname))
  94           scm_hashq_set_x (instructions_by_name, table[i].symname,
  95                            SCM_I_MAKINUM (i));
  96     }
  97
  98   op = scm_hashq_ref (instructions_by_name, name, SCM_UNDEFINED);
  99   if (SCM_I_INUMP (op))
 100     return &table[SCM_I_INUM (op)];
 101
 102   return NULL;
 103 }
 104
 105
 106 /* Scheme interface */
 107
 108 SCM_DEFINE (scm_instruction_list, "instruction-list", 0, 0, 0,
 109             (void),
 110             "")
 111 #define FUNC_NAME s_scm_instruction_list
 112 {
 113   SCM list = SCM_EOL;
 114   int i;
 115   struct scm_instruction *ip = fetch_instruction_table ();
 116   for (i = 0; i < SCM_VM_NUM_INSTRUCTIONS; i++)
 117     if (ip[i].name)
 118       list = scm_cons (ip[i].symname, list);
 119   return scm_reverse_x (list, SCM_EOL);
 120 }
 121 #undef FUNC_NAME
 122
 123 SCM_DEFINE (scm_instruction_p, "instruction?", 1, 0, 0,
 124             (SCM obj),
 125             "")
 126 #define FUNC_NAME s_scm_instruction_p
 127 {
 128   return scm_from_bool (scm_lookup_instruction_by_name (obj) != NULL);
 129 }
 130 #undef FUNC_NAME
 131
 132 SCM_DEFINE (scm_instruction_length, "instruction-length", 1, 0, 0,
 133             (SCM inst),
 134             "")
 135 #define FUNC_NAME s_scm_instruction_length
 136 {
 137   struct scm_instruction *ip;
 138   SCM_VALIDATE_LOOKUP_INSTRUCTION (1, inst, ip);
 139   return SCM_I_MAKINUM (ip->len);
 140 }
 141 #undef FUNC_NAME
 142
 143 SCM_DEFINE (scm_instruction_pops, "instruction-pops", 1, 0, 0,
 144             (SCM inst),
 145             "")
 146 #define FUNC_NAME s_scm_instruction_pops
 147 {
 148   struct scm_instruction *ip;
 149   SCM_VALIDATE_LOOKUP_INSTRUCTION (1, inst, ip);
 150   return SCM_I_MAKINUM (ip->npop);
 151 }
 152 #undef FUNC_NAME
 153
 154 SCM_DEFINE (scm_instruction_pushes, "instruction-pushes", 1, 0, 0,
 155             (SCM inst),
 156             "")
 157 #define FUNC_NAME s_scm_instruction_pushes
 158 {
 159   struct scm_instruction *ip;
 160   SCM_VALIDATE_LOOKUP_INSTRUCTION (1, inst, ip);
 161   return SCM_I_MAKINUM (ip->npush);
 162 }
 163 #undef FUNC_NAME
 164
 165 SCM_DEFINE (scm_instruction_to_opcode, "instruction->opcode", 1, 0, 0,
 166             (SCM inst),
 167             "")
 168 #define FUNC_NAME s_scm_instruction_to_opcode
 169 {
 170   struct scm_instruction *ip;
 171   SCM_VALIDATE_LOOKUP_INSTRUCTION (1, inst, ip);
 172   return SCM_I_MAKINUM (ip->opcode);
 173 }
 174 #undef FUNC_NAME
 175
 176 SCM_DEFINE (scm_opcode_to_instruction, "opcode->instruction", 1, 0, 0,
 177             (SCM op),
 178             "")
 179 #define FUNC_NAME s_scm_opcode_to_instruction
 180 {
 181   int opcode;
 182   SCM ret = SCM_BOOL_F;
 183
 184   SCM_MAKE_VALIDATE (1, op, I_INUMP);
 185   opcode = SCM_I_INUM (op);
 186
 187   if (opcode >= 0 && opcode < SCM_VM_NUM_INSTRUCTIONS)
 188     ret = fetch_instruction_table ()[opcode].symname;
 189
 190   if (scm_is_false (ret))
 191     scm_wrong_type_arg_msg (FUNC_NAME, 1, op, "INSTRUCTION_P");
 192
 193   return ret;
 194 }
 195 #undef FUNC_NAME
 196
 197 void
 198 scm_bootstrap_instructions (void)
 199 {
 200   scm_c_register_extension ("libguile", "scm_init_instructions",
 201                             (scm_t_extension_init_func)scm_init_instructions,
 202                             NULL);
 203 }
 204
 205 void
 206 scm_init_instructions (void)
 207 {
 208   scm_bootstrap_vm ();
 209
 210 #ifndef SCM_MAGIC_SNARFER
 211 #include "libguile/instructions.x"
 212 #endif
 213 }
 214
 215 /*
 216   Local Variables:
 217   c-file-style: "gnu"
 218   End:
 219 */