home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / gdb / scm-lang.c < prev    next >
C/C++ Source or Header  |  1996-04-09  |  7KB  |  269 lines
  1. /* Scheme/Guile language support routines for GDB, the GNU debugger.
  2.    Copyright 1995 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  6. This program is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2 of the License, or
  9. (at your option) any later version.
  10.  
  11. This program is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with this program; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19.  
  20. #include "defs.h"
  21. #include "symtab.h"
  22. #include "gdbtypes.h"
  23. #include "expression.h"
  24. #include "parser-defs.h"
  25. #include "language.h"
  26. #include "value.h"
  27. #include "c-lang.h"
  28. #include "scm-lang.h"
  29. #include "scm-tags.h"
  30. #include "gdb_string.h"
  31.  
  32. extern struct type ** const (c_builtin_types[]);
  33. extern value_ptr value_allocate_space_in_inferior PARAMS ((int));
  34. extern value_ptr find_function_in_inferior PARAMS ((char*));
  35.  
  36. struct type *builtin_type_scm;
  37.  
  38. void
  39. scm_printchar (c, stream)
  40.      int c;
  41.      GDB_FILE *stream;
  42. {
  43.   fprintf_filtered (stream, "#\\%c", c);
  44. }
  45.  
  46. static void
  47. scm_printstr (stream, string, length, force_ellipses)
  48.      GDB_FILE *stream;
  49.      char *string;
  50.      unsigned int length;
  51.      int force_ellipses;
  52. {
  53.   fprintf_filtered (stream, "\"%s\"", string);
  54. }
  55.  
  56. int
  57. is_scmvalue_type (type)
  58.      struct type *type;
  59. {
  60.   if (TYPE_CODE (type) == TYPE_CODE_INT
  61.       && TYPE_NAME (type) && strcmp (TYPE_NAME (type), "SCM") == 0)
  62.     {
  63.       return 1;
  64.     }
  65.   return 0;
  66. }
  67.  
  68. /* Get the INDEX'th SCM value, assuming SVALUE is the address
  69.    of the 0'th one.  */
  70.  
  71. LONGEST
  72. scm_get_field (svalue, index)
  73.      LONGEST svalue;
  74.      int index;
  75. {
  76.   value_ptr val;
  77.   char buffer[20];
  78.   read_memory (SCM2PTR (svalue) + index * TYPE_LENGTH (builtin_type_scm),
  79.            buffer, TYPE_LENGTH (builtin_type_scm));
  80.   return extract_signed_integer (buffer, TYPE_LENGTH (builtin_type_scm));
  81. }
  82.  
  83. /* Unpack a value of type TYPE in buffer VALADDR as an integer
  84.    (if CONTEXT == TYPE_CODE_IN), a pointer (CONTEXT == TYPE_CODE_PTR),
  85.    or Boolean (CONTEXT == TYPE_CODE_BOOL).  */
  86.  
  87. LONGEST
  88. scm_unpack (type, valaddr, context)
  89.      struct type *type;
  90.      char *valaddr;
  91.      enum type_code context;
  92. {
  93.   if (is_scmvalue_type (type))
  94.     {
  95.       LONGEST svalue = extract_signed_integer (valaddr, TYPE_LENGTH (type));
  96.       if (context == TYPE_CODE_BOOL)
  97.     {
  98.       if (svalue == SCM_BOOL_F)
  99.         return 0;
  100.       else
  101.         return 1;
  102.     }
  103.       switch (7 & svalue)
  104.     {
  105.     case 2:  case 6: /* fixnum */
  106.       return svalue >> 2;
  107.     case 4: /* other immediate value */
  108.       if (SCM_ICHRP (svalue)) /* character */
  109.         return SCM_ICHR (svalue);
  110.       else if (SCM_IFLAGP (svalue))
  111.         {
  112.           switch (svalue)
  113.         {
  114. #ifndef SICP
  115.         case SCM_EOL:
  116. #endif
  117.         case SCM_BOOL_F:
  118.           return 0;
  119.         case SCM_BOOL_T:
  120.           return 1;
  121.         }
  122.         }
  123.       error ("Value can't be converted to integer.");
  124.     default:
  125.       return svalue;
  126.     }
  127.     }
  128.   else
  129.     return unpack_long (type, valaddr);
  130. }
  131.  
  132. /* True if we're correctly in Guile's eval.c (the evaluator and apply). */
  133.  
  134. static int
  135. in_eval_c ()
  136. {
  137.   if (current_source_symtab && current_source_symtab->filename)
  138.     {
  139.       char *filename = current_source_symtab->filename;
  140.       int len = strlen (filename);
  141.       if (len >= 6 && strcmp (filename + len - 6, "eval.c") == 0)
  142.     return 1;
  143.     }
  144.   return 0;
  145. }
  146.  
  147. /* Lookup a value for the variable named STR.
  148.    First lookup in Scheme context (using the scm_lookup_cstr inferior
  149.    function), then try lookup_symbol for compiled variables. */
  150.  
  151. value_ptr
  152. scm_lookup_name (str)
  153.      char *str;
  154. {
  155.   value_ptr args[3];
  156.   int len = strlen (str);
  157.   value_ptr symval, func, val;
  158.   struct symbol *sym;
  159.   args[0] = value_allocate_space_in_inferior (len);
  160.   args[1] = value_from_longest (builtin_type_int, len);
  161.   write_memory (value_as_long (args[0]), str, len);
  162.  
  163.   if (in_eval_c ()
  164.       && (sym = lookup_symbol ("env",
  165.                    expression_context_block,
  166.                    VAR_NAMESPACE, (int *) NULL,
  167.                    (struct symtab **) NULL)) != NULL)
  168.     args[2] = value_of_variable (sym, expression_context_block);
  169.   else
  170.     /* FIXME in this case, we should try lookup_symbol first */
  171.     args[2] = value_from_longest (builtin_type_scm, SCM_EOL);
  172.  
  173.   func = find_function_in_inferior ("scm_lookup_cstr");
  174.   val = call_function_by_hand (func, 3, args);
  175.   if (!value_logical_not (val))
  176.     return value_ind (val);
  177.  
  178.   sym = lookup_symbol (str,
  179.                expression_context_block,
  180.                VAR_NAMESPACE, (int *) NULL,
  181.                (struct symtab **) NULL);
  182.   if (sym)
  183.     return value_of_variable (sym, NULL);
  184.   error ("No symbol \"%s\" in current context.");
  185. }
  186.  
  187. value_ptr
  188. scm_evaluate_string (str, len)
  189.      char *str; int len;
  190. {
  191.   value_ptr func;
  192.   value_ptr addr = value_allocate_space_in_inferior (len + 1);
  193.   LONGEST iaddr = value_as_long (addr);
  194.   write_memory (iaddr, str, len);
  195.   /* FIXME - should find and pass env */
  196.   write_memory (iaddr + len, "", 1);
  197.   func = find_function_in_inferior ("scm_evstr");
  198.   return call_function_by_hand (func, 1, &addr);
  199. }
  200.  
  201. static value_ptr
  202. evaluate_subexp_scm (expect_type, exp, pos, noside)
  203.      struct type *expect_type;
  204.      register struct expression *exp;
  205.      register int *pos;
  206.      enum noside noside;
  207. {
  208.   enum exp_opcode op = exp->elts[*pos].opcode;
  209.   int len, pc;  char *str;
  210.   switch (op)
  211.     {
  212.     case OP_NAME:
  213.       pc = (*pos)++;
  214.       len = longest_to_int (exp->elts[pc + 1].longconst);
  215.       (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
  216.       if (noside == EVAL_SKIP)
  217.     goto nosideret;
  218.       str = &exp->elts[pc + 2].string;
  219.       return scm_lookup_name (str);
  220.     case OP_EXPRSTRING:
  221.       pc = (*pos)++;
  222.       len = longest_to_int (exp->elts[pc + 1].longconst);
  223.       (*pos) += 3 + BYTES_TO_EXP_ELEM (len + 1);
  224.       if (noside == EVAL_SKIP)
  225.     goto nosideret;
  226.       str = &exp->elts[pc + 2].string;
  227.       return scm_evaluate_string (str, len);
  228.     default: ;
  229.     }
  230.   return evaluate_subexp_standard (expect_type, exp, pos, noside);
  231.  nosideret:
  232.   return value_from_longest (builtin_type_long, (LONGEST) 1);
  233. }
  234.  
  235. const struct language_defn scm_language_defn = {
  236.   "scheme",            /* Language name */
  237.   language_scm,
  238.   c_builtin_types,
  239.   range_check_off,
  240.   type_check_off,
  241.   scm_parse,
  242.   c_error,
  243.   evaluate_subexp_scm,
  244.   scm_printchar,            /* Print a character constant */
  245.   scm_printstr,            /* Function to print string constant */
  246.   NULL,    /* Create fundamental type in this language */
  247.   c_print_type,            /* Print a type using appropriate syntax */
  248.   scm_val_print,        /* Print a value using appropriate syntax */
  249.   scm_value_print,        /* Print a top-level value */
  250.   {"",     "",    "",  ""},    /* Binary format info */
  251.   {"#o%lo",  "#o",   "o", ""},    /* Octal format info */
  252.   {"%ld",   "",    "d", ""},    /* Decimal format info */
  253.   {"#x%lX", "#X",  "X", ""},    /* Hex format info */
  254.   NULL,                /* expression operators for printing */
  255.   1,                /* c-style arrays */
  256.   0,                /* String lower bound */
  257.   &builtin_type_char,        /* Type of string elements */ 
  258.   LANG_MAGIC
  259. };
  260.  
  261. void
  262. _initialize_scheme_language ()
  263. {
  264.   add_language (&scm_language_defn);
  265.   builtin_type_scm = init_type (TYPE_CODE_INT,
  266.                 TARGET_LONG_BIT / TARGET_CHAR_BIT,
  267.                 0, "SCM", (struct objfile *) NULL);
  268. }
  269.