[deliverable/binutils-gdb.git] / gdb / scm-exp.c

/* Scheme/Guile language support routines for GDB, the GNU debugger.

   Copyright 1995, 1996, 2000, 2003 Free Software Foundation, Inc.

   This file is part of GDB.

   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 of the License, 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 program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "parser-defs.h"
#include "language.h"
#include "value.h"
#include "c-lang.h"
#include "scm-lang.h"
#include "scm-tags.h"

#define USE_EXPRSTRING 0

static void scm_lreadparen (int);
static int scm_skip_ws (void);
static void scm_read_token (int, int);
static LONGEST scm_istring2number (char *, int, int);
static LONGEST scm_istr2int (char *, int, int);
static void scm_lreadr (int);

static LONGEST
scm_istr2int (char *str, int len, int radix)
{
  int i = 0;
  LONGEST inum = 0;
  int c;
  int sign = 0;

  if (0 >= len)
    return SCM_BOOL_F;		/* zero scm_length */
  switch (str[0])
    {				/* leading sign */
    case '-':
    case '+':
      sign = str[0];
      if (++i == len)
	return SCM_BOOL_F;	/* bad if lone `+' or `-' */
    }
  do
    {
      switch (c = str[i++])
	{
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	  c = c - '0';
	  goto accumulate;
	case 'A':
	case 'B':
	case 'C':
	case 'D':
	case 'E':
	case 'F':
	  c = c - 'A' + 10;
	  goto accumulate;
	case 'a':
	case 'b':
	case 'c':
	case 'd':
	case 'e':
	case 'f':
	  c = c - 'a' + 10;
	accumulate:
	  if (c >= radix)
	    return SCM_BOOL_F;	/* bad digit for radix */
	  inum *= radix;
	  inum += c;
	  break;
	default:
	  return SCM_BOOL_F;	/* not a digit */
	}
    }
  while (i < len);
  if (sign == '-')
    inum = -inum;
  return SCM_MAKINUM (inum);
}

static LONGEST
scm_istring2number (char *str, int len, int radix)
{
  int i = 0;
  char ex = 0;
  char ex_p = 0, rx_p = 0;	/* Only allow 1 exactness and 1 radix prefix */
#if 0
  SCM res;
#endif
  if (len == 1)
    if (*str == '+' || *str == '-')	/* Catches lone `+' and `-' for speed */
      return SCM_BOOL_F;

  while ((len - i) >= 2 && str[i] == '#' && ++i)
    switch (str[i++])
      {
      case 'b':
      case 'B':
	if (rx_p++)
	  return SCM_BOOL_F;
	radix = 2;
	break;
      case 'o':
      case 'O':
	if (rx_p++)
	  return SCM_BOOL_F;
	radix = 8;
	break;
      case 'd':
      case 'D':
	if (rx_p++)
	  return SCM_BOOL_F;
	radix = 10;
	break;
      case 'x':
      case 'X':
	if (rx_p++)
	  return SCM_BOOL_F;
	radix = 16;
	break;
      case 'i':
      case 'I':
	if (ex_p++)
	  return SCM_BOOL_F;
	ex = 2;
	break;
      case 'e':
      case 'E':
	if (ex_p++)
	  return SCM_BOOL_F;
	ex = 1;
	break;
      default:
	return SCM_BOOL_F;
      }

  switch (ex)
    {
    case 1:
      return scm_istr2int (&str[i], len - i, radix);
    case 0:
      return scm_istr2int (&str[i], len - i, radix);
#if 0
      if NFALSEP
	(res) return res;
#ifdef FLOATS
    case 2:
      return scm_istr2flo (&str[i], len - i, radix);
#endif
#endif
    }
  return SCM_BOOL_F;
}

static void
scm_read_token (int c, int weird)
{
  while (1)
    {
      c = *lexptr++;
      switch (c)
	{
	case '[':
	case ']':
	case '(':
	case ')':
	case '\"':
	case ';':
	case ' ':
	case '\t':
	case '\r':
	case '\f':
	case '\n':
	  if (weird)
	    goto default_case;
	case '\0':		/* End of line */
	eof_case:
	  --lexptr;
	  return;
	case '\\':
	  if (!weird)
	    goto default_case;
	  else
	    {
	      c = *lexptr++;
	      if (c == '\0')
		goto eof_case;
	      else
		goto default_case;
	    }
	case '}':
	  if (!weird)
	    goto default_case;

	  c = *lexptr++;
	  if (c == '#')
	    return;
	  else
	    {
	      --lexptr;
	      c = '}';
	      goto default_case;
	    }

	default:
	default_case:
	  ;
	}
    }
}

static int
scm_skip_ws (void)
{
  int c;
  while (1)
    switch ((c = *lexptr++))
      {
      case '\0':
      goteof:
	return c;
      case ';':
      lp:
	switch ((c = *lexptr++))
	  {
	  case '\0':
	    goto goteof;
	  default:
	    goto lp;
	  case '\n':
	    break;
	  }
      case ' ':
      case '\t':
      case '\r':
      case '\f':
      case '\n':
	break;
      default:
	return c;
      }
}

static void
scm_lreadparen (int skipping)
{
  for (;;)
    {
      int c = scm_skip_ws ();
      if (')' == c || ']' == c)
	return;
      --lexptr;
      if (c == '\0')
	error ("missing close paren");
      scm_lreadr (skipping);
    }
}

static void
scm_lreadr (int skipping)
{
  int c, j;
  struct stoken str;
  LONGEST svalue = 0;
tryagain:
  c = *lexptr++;
  switch (c)
    {
    case '\0':
      lexptr--;
      return;
    case '[':
    case '(':
      scm_lreadparen (skipping);
      return;
    case ']':
    case ')':
      error ("unexpected #\\%c", c);
      goto tryagain;
    case '\'':
    case '`':
      str.ptr = lexptr - 1;
      scm_lreadr (skipping);
      if (!skipping)
	{
	  struct value *val = scm_evaluate_string (str.ptr, lexptr - str.ptr);
	  if (!is_scmvalue_type (value_type (val)))
	    error ("quoted scm form yields non-SCM value");
	  svalue = extract_signed_integer (VALUE_CONTENTS (val),
					   TYPE_LENGTH (value_type (val)));
	  goto handle_immediate;
	}
      return;
    case ',':
      c = *lexptr++;
      if ('@' != c)
	lexptr--;
      scm_lreadr (skipping);
      return;
    case '#':
      c = *lexptr++;
      switch (c)
	{
	case '[':
	case '(':
	  scm_lreadparen (skipping);
	  return;
	case 't':
	case 'T':
	  svalue = SCM_BOOL_T;
	  goto handle_immediate;
	case 'f':
	case 'F':
	  svalue = SCM_BOOL_F;
	  goto handle_immediate;
	case 'b':
	case 'B':
	case 'o':
	case 'O':
	case 'd':
	case 'D':
	case 'x':
	case 'X':
	case 'i':
	case 'I':
	case 'e':
	case 'E':
	  lexptr--;
	  c = '#';
	  goto num;
	case '*':		/* bitvector */
	  scm_read_token (c, 0);
	  return;
	case '{':
	  scm_read_token (c, 1);
	  return;
	case '\\':		/* character */
	  c = *lexptr++;
	  scm_read_token (c, 0);
	  return;
	case '|':
	  j = 1;		/* here j is the comment nesting depth */
	lp:
	  c = *lexptr++;
	lpc:
	  switch (c)
	    {
	    case '\0':
	      error ("unbalanced comment");
	    default:
	      goto lp;
	    case '|':
	      if ('#' != (c = *lexptr++))
		goto lpc;
	      if (--j)
		goto lp;
	      break;
	    case '#':
	      if ('|' != (c = *lexptr++))
		goto lpc;
	      ++j;
	      goto lp;
	    }
	  goto tryagain;
	case '.':
	default:
#if 0
	callshrp:
#endif
	  scm_lreadr (skipping);
	  return;
	}
    case '\"':
      while ('\"' != (c = *lexptr++))
	{
	  if (c == '\\')
	    switch (c = *lexptr++)
	      {
	      case '\0':
		error ("non-terminated string literal");
	      case '\n':
		continue;
	      case '0':
	      case 'f':
	      case 'n':
	      case 'r':
	      case 't':
	      case 'a':
	      case 'v':
		break;
	      }
	}
      return;
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case '.':
    case '-':
    case '+':
    num:
      {
	str.ptr = lexptr - 1;
	scm_read_token (c, 0);
	if (!skipping)
	  {
	    svalue = scm_istring2number (str.ptr, lexptr - str.ptr, 10);
	    if (svalue != SCM_BOOL_F)
	      goto handle_immediate;
	    goto tok;
	  }
      }
      return;
    case ':':
      scm_read_token ('-', 0);
      return;
#if 0
    do_symbol:
#endif
    default:
      str.ptr = lexptr - 1;
      scm_read_token (c, 0);
    tok:
      if (!skipping)
	{
	  str.length = lexptr - str.ptr;
	  if (str.ptr[0] == '$')
	    {
	      write_dollar_variable (str);
	      return;
	    }
	  write_exp_elt_opcode (OP_NAME);
	  write_exp_string (str);
	  write_exp_elt_opcode (OP_NAME);
	}
      return;
    }
handle_immediate:
  if (!skipping)
    {
      write_exp_elt_opcode (OP_LONG);
      write_exp_elt_type (builtin_type_scm);
      write_exp_elt_longcst (svalue);
      write_exp_elt_opcode (OP_LONG);
    }
}

int
scm_parse (void)
{
  char *start;
  while (*lexptr == ' ')
    lexptr++;
  start = lexptr;
  scm_lreadr (USE_EXPRSTRING);
#if USE_EXPRSTRING
  str.length = lexptr - start;
  str.ptr = start;
  write_exp_elt_opcode (OP_EXPRSTRING);
  write_exp_string (str);
  write_exp_elt_opcode (OP_EXPRSTRING);
#endif
  return 0;
}
Commit	Line	Data
c906108c	1	/* Scheme/Guile language support routines for GDB, the GNU debugger.
69517000 AC	2
69517000 AC	3	Copyright 1995, 1996, 2000, 2003 Free Software Foundation, Inc.
c906108c	4
c5aa993b	5	This file is part of GDB.
c906108c	6
c5aa993b JM	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
c906108c	11
c5aa993b JM	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
c906108c	16
c5aa993b JM	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
c906108c SS	21
	22	#include "defs.h"
	23	#include "symtab.h"
	24	#include "gdbtypes.h"
	25	#include "expression.h"
	26	#include "parser-defs.h"
	27	#include "language.h"
	28	#include "value.h"
	29	#include "c-lang.h"
	30	#include "scm-lang.h"
	31	#include "scm-tags.h"
	32
	33	#define USE_EXPRSTRING 0
	34
a14ed312 KB	35	static void scm_lreadparen (int);
	36	static int scm_skip_ws (void);
	37	static void scm_read_token (int, int);
	38	static LONGEST scm_istring2number (char *, int, int);
	39	static LONGEST scm_istr2int (char *, int, int);
	40	static void scm_lreadr (int);
c906108c SS	41
c906108c SS	42	static LONGEST
fba45db2	43	scm_istr2int (char *str, int len, int radix)
c906108c SS	44	{
	45	int i = 0;
	46	LONGEST inum = 0;
	47	int c;
	48	int sign = 0;
	49
c5aa993b JM	50	if (0 >= len)
c5aa993b JM	51	return SCM_BOOL_F; /* zero scm_length */
c906108c	52	switch (str[0])
c5aa993b	53	{ /* leading sign */
c906108c SS	54	case '-':
	55	case '+':
	56	sign = str[0];
c5aa993b JM	57	if (++i == len)
c5aa993b JM	58	return SCM_BOOL_F; /* bad if lone `+' or `-' */
c906108c	59	}
c5aa993b JM	60	do
	61	{
	62	switch (c = str[i++])
	63	{
	64	case '0':
	65	case '1':
	66	case '2':
	67	case '3':
	68	case '4':
	69	case '5':
	70	case '6':
	71	case '7':
	72	case '8':
	73	case '9':
	74	c = c - '0';
	75	goto accumulate;
	76	case 'A':
	77	case 'B':
	78	case 'C':
	79	case 'D':
	80	case 'E':
	81	case 'F':
	82	c = c - 'A' + 10;
	83	goto accumulate;
	84	case 'a':
	85	case 'b':
	86	case 'c':
	87	case 'd':
	88	case 'e':
	89	case 'f':
	90	c = c - 'a' + 10;
	91	accumulate:
	92	if (c >= radix)
	93	return SCM_BOOL_F; /* bad digit for radix */
	94	inum *= radix;
	95	inum += c;
	96	break;
	97	default:
	98	return SCM_BOOL_F; /* not a digit */
	99	}
c906108c	100	}
c5aa993b	101	while (i < len);
c906108c SS	102	if (sign == '-')
	103	inum = -inum;
	104	return SCM_MAKINUM (inum);
	105	}
	106
	107	static LONGEST
fba45db2	108	scm_istring2number (char *str, int len, int radix)
c906108c SS	109	{
	110	int i = 0;
	111	char ex = 0;
	112	char ex_p = 0, rx_p = 0; /* Only allow 1 exactness and 1 radix prefix */
	113	#if 0
	114	SCM res;
	115	#endif
c5aa993b JM	116	if (len == 1)
c5aa993b JM	117	if (str == '+' \|\| str == '-') /* Catches lone `+' and `-' for speed */
c906108c SS	118	return SCM_BOOL_F;
c906108c SS	119
c5aa993b JM	120	while ((len - i) >= 2 && str[i] == '#' && ++i)
	121	switch (str[i++])
	122	{
	123	case 'b':
	124	case 'B':
	125	if (rx_p++)
	126	return SCM_BOOL_F;
	127	radix = 2;
	128	break;
	129	case 'o':
	130	case 'O':
	131	if (rx_p++)
	132	return SCM_BOOL_F;
	133	radix = 8;
	134	break;
	135	case 'd':
	136	case 'D':
	137	if (rx_p++)
	138	return SCM_BOOL_F;
	139	radix = 10;
	140	break;
	141	case 'x':
	142	case 'X':
	143	if (rx_p++)
	144	return SCM_BOOL_F;
	145	radix = 16;
	146	break;
	147	case 'i':
	148	case 'I':
	149	if (ex_p++)
	150	return SCM_BOOL_F;
	151	ex = 2;
	152	break;
	153	case 'e':
	154	case 'E':
	155	if (ex_p++)
	156	return SCM_BOOL_F;
	157	ex = 1;
	158	break;
	159	default:
	160	return SCM_BOOL_F;
	161	}
c906108c	162
c5aa993b JM	163	switch (ex)
	164	{
	165	case 1:
	166	return scm_istr2int (&str[i], len - i, radix);
	167	case 0:
	168	return scm_istr2int (&str[i], len - i, radix);
c906108c	169	#if 0
c5aa993b JM	170	if NFALSEP
c5aa993b JM	171	(res) return res;
c906108c	172	#ifdef FLOATS
c5aa993b JM	173	case 2:
c5aa993b JM	174	return scm_istr2flo (&str[i], len - i, radix);
c906108c SS	175	#endif
c906108c SS	176	#endif
c5aa993b	177	}
c906108c SS	178	return SCM_BOOL_F;
	179	}
	180
	181	static void
fba45db2	182	scm_read_token (int c, int weird)
c906108c SS	183	{
	184	while (1)
	185	{
	186	c = *lexptr++;
	187	switch (c)
	188	{
	189	case '[':
	190	case ']':
	191	case '(':
	192	case ')':
	193	case '\"':
	194	case ';':
c5aa993b JM	195	case ' ':
	196	case '\t':
	197	case '\r':
	198	case '\f':
c906108c SS	199	case '\n':
	200	if (weird)
	201	goto default_case;
c5aa993b	202	case '\0': /* End of line */
c906108c SS	203	eof_case:
	204	--lexptr;
	205	return;
	206	case '\\':
	207	if (!weird)
	208	goto default_case;
	209	else
	210	{
	211	c = *lexptr++;
	212	if (c == '\0')
	213	goto eof_case;
	214	else
	215	goto default_case;
	216	}
	217	case '}':
	218	if (!weird)
	219	goto default_case;
	220
	221	c = *lexptr++;
	222	if (c == '#')
	223	return;
	224	else
	225	{
	226	--lexptr;
	227	c = '}';
	228	goto default_case;
	229	}
	230
	231	default:
	232	default_case:
	233	;
	234	}
	235	}
	236	}
	237
c5aa993b	238	static int
fba45db2	239	scm_skip_ws (void)
c906108c	240	{
52f0bd74	241	int c;
c906108c SS	242	while (1)
	243	switch ((c = *lexptr++))
	244	{
	245	case '\0':
	246	goteof:
	247	return c;
	248	case ';':
	249	lp:
	250	switch ((c = *lexptr++))
	251	{
	252	case '\0':
	253	goto goteof;
	254	default:
	255	goto lp;
	256	case '\n':
	257	break;
	258	}
c5aa993b JM	259	case ' ':
	260	case '\t':
	261	case '\r':
	262	case '\f':
	263	case '\n':
c906108c SS	264	break;
	265	default:
	266	return c;
	267	}
	268	}
	269
	270	static void
fba45db2	271	scm_lreadparen (int skipping)
c906108c SS	272	{
	273	for (;;)
	274	{
	275	int c = scm_skip_ws ();
	276	if (')' == c \|\| ']' == c)
	277	return;
	278	--lexptr;
	279	if (c == '\0')
	280	error ("missing close paren");
	281	scm_lreadr (skipping);
	282	}
	283	}
	284
	285	static void
fba45db2	286	scm_lreadr (int skipping)
c906108c SS	287	{
	288	int c, j;
	289	struct stoken str;
	290	LONGEST svalue = 0;
c5aa993b	291	tryagain:
c906108c SS	292	c = *lexptr++;
	293	switch (c)
	294	{
	295	case '\0':
	296	lexptr--;
	297	return;
	298	case '[':
	299	case '(':
	300	scm_lreadparen (skipping);
	301	return;
	302	case ']':
	303	case ')':
	304	error ("unexpected #\\%c", c);
	305	goto tryagain;
	306	case '\'':
	307	case '`':
	308	str.ptr = lexptr - 1;
	309	scm_lreadr (skipping);
	310	if (!skipping)
	311	{
6943961c	312	struct value *val = scm_evaluate_string (str.ptr, lexptr - str.ptr);
df407dfe	313	if (!is_scmvalue_type (value_type (val)))
c906108c SS	314	error ("quoted scm form yields non-SCM value");
c906108c SS	315	svalue = extract_signed_integer (VALUE_CONTENTS (val),
df407dfe	316	TYPE_LENGTH (value_type (val)));
c906108c SS	317	goto handle_immediate;
	318	}
	319	return;
	320	case ',':
	321	c = *lexptr++;
	322	if ('@' != c)
	323	lexptr--;
	324	scm_lreadr (skipping);
	325	return;
	326	case '#':
	327	c = *lexptr++;
	328	switch (c)
	329	{
	330	case '[':
	331	case '(':
	332	scm_lreadparen (skipping);
	333	return;
c5aa993b JM	334	case 't':
c5aa993b JM	335	case 'T':
c906108c SS	336	svalue = SCM_BOOL_T;
c906108c SS	337	goto handle_immediate;
c5aa993b JM	338	case 'f':
c5aa993b JM	339	case 'F':
c906108c SS	340	svalue = SCM_BOOL_F;
c906108c SS	341	goto handle_immediate;
c5aa993b JM	342	case 'b':
	343	case 'B':
	344	case 'o':
	345	case 'O':
	346	case 'd':
	347	case 'D':
	348	case 'x':
	349	case 'X':
	350	case 'i':
	351	case 'I':
	352	case 'e':
	353	case 'E':
c906108c SS	354	lexptr--;
	355	c = '#';
	356	goto num;
c5aa993b	357	case '': / bitvector */
c906108c SS	358	scm_read_token (c, 0);
	359	return;
	360	case '{':
	361	scm_read_token (c, 1);
	362	return;
c5aa993b	363	case '\\': /* character */
c906108c SS	364	c = *lexptr++;
	365	scm_read_token (c, 0);
	366	return;
	367	case '\|':
	368	j = 1; /* here j is the comment nesting depth */
	369	lp:
	370	c = *lexptr++;
	371	lpc:
	372	switch (c)
	373	{
	374	case '\0':
	375	error ("unbalanced comment");
	376	default:
	377	goto lp;
	378	case '\|':
	379	if ('#' != (c = *lexptr++))
	380	goto lpc;
	381	if (--j)
	382	goto lp;
	383	break;
	384	case '#':
	385	if ('\|' != (c = *lexptr++))
	386	goto lpc;
	387	++j;
	388	goto lp;
	389	}
	390	goto tryagain;
	391	case '.':
	392	default:
	393	#if 0
	394	callshrp:
	395	#endif
	396	scm_lreadr (skipping);
	397	return;
	398	}
	399	case '\"':
	400	while ('\"' != (c = *lexptr++))
	401	{
	402	if (c == '\\')
	403	switch (c = *lexptr++)
	404	{
	405	case '\0':
	406	error ("non-terminated string literal");
	407	case '\n':
	408	continue;
	409	case '0':
	410	case 'f':
	411	case 'n':
	412	case 'r':
	413	case 't':
	414	case 'a':
	415	case 'v':
	416	break;
	417	}
	418	}
	419	return;
c5aa993b JM	420	case '0':
	421	case '1':
	422	case '2':
	423	case '3':
	424	case '4':
	425	case '5':
	426	case '6':
	427	case '7':
	428	case '8':
	429	case '9':
c906108c SS	430	case '.':
	431	case '-':
	432	case '+':
	433	num:
	434	{
c5aa993b	435	str.ptr = lexptr - 1;
c906108c SS	436	scm_read_token (c, 0);
	437	if (!skipping)
	438	{
	439	svalue = scm_istring2number (str.ptr, lexptr - str.ptr, 10);
	440	if (svalue != SCM_BOOL_F)
	441	goto handle_immediate;
	442	goto tok;
	443	}
	444	}
	445	return;
	446	case ':':
	447	scm_read_token ('-', 0);
	448	return;
	449	#if 0
	450	do_symbol:
	451	#endif
	452	default:
c5aa993b	453	str.ptr = lexptr - 1;
c906108c SS	454	scm_read_token (c, 0);
	455	tok:
	456	if (!skipping)
	457	{
	458	str.length = lexptr - str.ptr;
	459	if (str.ptr[0] == '$')
	460	{
	461	write_dollar_variable (str);
	462	return;
	463	}
	464	write_exp_elt_opcode (OP_NAME);
	465	write_exp_string (str);
	466	write_exp_elt_opcode (OP_NAME);
	467	}
	468	return;
	469	}
c5aa993b	470	handle_immediate:
c906108c SS	471	if (!skipping)
	472	{
	473	write_exp_elt_opcode (OP_LONG);
	474	write_exp_elt_type (builtin_type_scm);
	475	write_exp_elt_longcst (svalue);
	476	write_exp_elt_opcode (OP_LONG);
	477	}
	478	}
	479
	480	int
fba45db2	481	scm_parse (void)
c906108c	482	{
c5aa993b	483	char *start;
c906108c SS	484	while (*lexptr == ' ')
	485	lexptr++;
	486	start = lexptr;
	487	scm_lreadr (USE_EXPRSTRING);
	488	#if USE_EXPRSTRING
	489	str.length = lexptr - start;
	490	str.ptr = start;
	491	write_exp_elt_opcode (OP_EXPRSTRING);
	492	write_exp_string (str);
	493	write_exp_elt_opcode (OP_EXPRSTRING);
	494	#endif
	495	return 0;
	496	}