[thirdparty/binutils-gdb.git] / gdb / ada-lex.l

/* FLEX lexer for Ada expressions, for GDB.
   Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007, 2008, 2009
   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 3 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, see <http://www.gnu.org/licenses/>.  */

/*----------------------------------------------------------------------*/

/* The converted version of this file is to be included in ada-exp.y, */
/* the Ada parser for gdb.  The function yylex obtains characters from */
/* the global pointer lexptr.  It returns a syntactic category for */
/* each successive token and places a semantic value into yylval */
/* (ada-lval), defined by the parser.   */

DIG	[0-9]
NUM10	({DIG}({DIG}|_)*)
HEXDIG	[0-9a-f]
NUM16	({HEXDIG}({HEXDIG}|_)*)
OCTDIG	[0-7]
LETTER	[a-z_]
ID	({LETTER}({LETTER}|{DIG})*|"<"{LETTER}({LETTER}|{DIG})*">")
WHITE	[ \t\n]
TICK	("'"{WHITE}*)
GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_|!$%?@\[\]\\^`{}~]
OPER    ([-+*/=<>&]|"<="|">="|"**"|"/="|"and"|"or"|"xor"|"not"|"mod"|"rem"|"abs")

EXP	(e[+-]{NUM10})
POSEXP  (e"+"?{NUM10})

%{

#define NUMERAL_WIDTH 256
#define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))

/* Temporary staging for numeric literals.  */
static char numbuf[NUMERAL_WIDTH];
 static void canonicalizeNumeral (char *s1, const char *);
static struct stoken processString (const char*, int);
static int processInt (const char *, const char *, const char *);
static int processReal (const char *);
static struct stoken processId (const char *, int);
static int processAttribute (const char *);
static int find_dot_all (const char *);

#undef YY_DECL
#define YY_DECL static int yylex ( void )

#undef YY_INPUT
#define YY_INPUT(BUF, RESULT, MAX_SIZE) \
    if ( *lexptr == '\000' ) \
      (RESULT) = YY_NULL; \
    else \
      { \
        *(BUF) = *lexptr; \
        (RESULT) = 1; \
	lexptr += 1; \
      }

static int find_dot_all (const char *);

%}

%option case-insensitive interactive nodefault

%s BEFORE_QUAL_QUOTE

%%

{WHITE}		 { }

"--".*		 { yyterminate(); }

{NUM10}{POSEXP}  {
		   canonicalizeNumeral (numbuf, yytext);
		   return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
		 }

{NUM10}          {
		   canonicalizeNumeral (numbuf, yytext);
		   return processInt (NULL, numbuf, NULL);
		 }

{NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#"{POSEXP} {
		   canonicalizeNumeral (numbuf, yytext);
    		   return processInt (numbuf,
				      strchr (numbuf, '#') + 1,
				      strrchr(numbuf, '#') + 1);
		 }

{NUM10}"#"{HEXDIG}({HEXDIG}|_)*"#" {
		   canonicalizeNumeral (numbuf, yytext);
    		   return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
		 }

"0x"{HEXDIG}+	{
		  canonicalizeNumeral (numbuf, yytext+2);
		  return processInt ("16#", numbuf, NULL);
		}


{NUM10}"."{NUM10}{EXP} {
		   canonicalizeNumeral (numbuf, yytext);
		   return processReal (numbuf);
		}

{NUM10}"."{NUM10} {
		   canonicalizeNumeral (numbuf, yytext);
		   return processReal (numbuf);
		}

{NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
                   error (_("Based real literals not implemented yet."));
		}

{NUM10}"#"{NUM16}"."{NUM16}"#" {
                   error (_("Based real literals not implemented yet."));
		}

<INITIAL>"'"({GRAPHIC}|\")"'" {
		   yylval.typed_val.type = type_char ();
		   yylval.typed_val.val = yytext[1];
		   return CHARLIT;
		}

<INITIAL>"'[\""{HEXDIG}{2}"\"]'"   {
                   int v;
                   yylval.typed_val.type = type_char ();
		   sscanf (yytext+3, "%2x", &v);
		   yylval.typed_val.val = v;
		   return CHARLIT;
		}

\"({GRAPHIC}|"[\""({HEXDIG}{2}|\")"\"]")*\"   {
	           yylval.sval = processString (yytext+1, yyleng-2);
		   return STRING;
		}

\"              {
                   error (_("ill-formed or non-terminated string literal"));
		}


if		{
		  while (*lexptr != 'i' && *lexptr != 'I')
		    lexptr -= 1;
		  yyrestart(NULL);
		  return 0;
		}

task		{
		  while (*lexptr != 't' && *lexptr != 'T')
		    lexptr--;
		  yyrestart(NULL);
		  return 0;
		}

	/* ADA KEYWORDS */

abs		{ return ABS; }
and		{ return _AND_; }
else		{ return ELSE; }
in		{ return IN; }
mod		{ return MOD; }
new		{ return NEW; }
not		{ return NOT; }
null		{ return NULL_PTR; }
or		{ return OR; }
others          { return OTHERS; }
rem		{ return REM; }
then		{ return THEN; }
xor		{ return XOR; }

	/* BOOLEAN "KEYWORDS" */

 /* True and False are not keywords in Ada, but rather enumeration constants.
    However, the boolean type is no longer represented as an enum, so True
    and False are no longer defined in symbol tables.  We compromise by
    making them keywords (when bare). */

true		{ return TRUEKEYWORD; }
false		{ return FALSEKEYWORD; }

        /* ATTRIBUTES */

{TICK}[a-zA-Z][a-zA-Z]+ { return processAttribute (yytext+1); }

	/* PUNCTUATION */

"=>"		{ return ARROW; }
".."		{ return DOTDOT; }
"**"		{ return STARSTAR; }
":="		{ return ASSIGN; }
"/="		{ return NOTEQUAL; }
"<="		{ return LEQ; }
">="		{ return GEQ; }

<BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }

[-&*+./:<>=|;\[\]] { return yytext[0]; }

","		{ if (paren_depth == 0 && comma_terminates)
		    {
		      lexptr -= 1;
		      yyrestart(NULL);
		      return 0;
		    }
		  else
		    return ',';
		}

"("		{ paren_depth += 1; return '('; }
")"		{ if (paren_depth == 0)
		    {
		      lexptr -= 1;
		      yyrestart(NULL);
		      return 0;
		    }
		  else
 		    {
		      paren_depth -= 1;
		      return ')';
		    }
		}

"."{WHITE}*all  { return DOT_ALL; }

"."{WHITE}*{ID} {
	 	  yylval.sval = processId (yytext+1, yyleng-1);
	          return DOT_ID;
		}

{ID}({WHITE}*"."{WHITE}*({ID}|\"{OPER}\"))*(" "*"'")?  {
                  int all_posn = find_dot_all (yytext);

                  if (all_posn == -1 && yytext[yyleng-1] == '\'')
		    {
		      BEGIN BEFORE_QUAL_QUOTE;
		      yyless (yyleng-1);
		    }
                  else if (all_posn >= 0)
		    yyless (all_posn);
                  yylval.sval = processId (yytext, yyleng);
                  return NAME;
               }


	/* GDB EXPRESSION CONSTRUCTS  */

"'"[^']+"'"{WHITE}*:: {
                  yyless (yyleng - 2);
		  yylval.sval = processId (yytext, yyleng);
		  return NAME;
		}

"::"            { return COLONCOLON; }

[{}@]		{ return yytext[0]; }

	/* REGISTERS AND GDB CONVENIENCE VARIABLES */

"$"({LETTER}|{DIG}|"$")*  {
		  yylval.sval.ptr = yytext;
		  yylval.sval.length = yyleng;
		  return SPECIAL_VARIABLE;
		}

	/* CATCH-ALL ERROR CASE */

.		{ error (_("Invalid character '%s' in expression."), yytext); }
%%

#include <ctype.h>
#include "gdb_string.h"

/* Initialize the lexer for processing new expression. */

void
lexer_init (FILE *inp)
{
  BEGIN INITIAL;
  yyrestart (inp);
}


/* Copy S2 to S1, removing all underscores, and downcasing all letters.  */

static void
canonicalizeNumeral (char *s1, const char *s2)
{
  for (; *s2 != '\000'; s2 += 1)
    {
      if (*s2 != '_')
	{
	  *s1 = tolower(*s2);
	  s1 += 1;
	}
    }
  s1[0] = '\000';
}

/* Interprets the prefix of NUM that consists of digits of the given BASE
   as an integer of that BASE, with the string EXP as an exponent.
   Puts value in yylval, and returns INT, if the string is valid.  Causes
   an error if the number is improperly formated.   BASE, if NULL, defaults
   to "10", and EXP to "1".  The EXP does not contain a leading 'e' or 'E'.
 */

static int
processInt (const char *base0, const char *num0, const char *exp0)
{
  ULONGEST result;
  long exp;
  int base;

  char *trailer;

  if (base0 == NULL)
    base = 10;
  else
    {
      base = strtol (base0, (char **) NULL, 10);
      if (base < 2 || base > 16)
	error (_("Invalid base: %d."), base);
    }

  if (exp0 == NULL)
    exp = 0;
  else
    exp = strtol(exp0, (char **) NULL, 10);

  errno = 0;
  result = strtoulst (num0, (const char **) &trailer, base);
  if (errno == ERANGE)
    error (_("Integer literal out of range"));
  if (isxdigit(*trailer))
    error (_("Invalid digit `%c' in based literal"), *trailer);

  while (exp > 0)
    {
      if (result > (ULONG_MAX / base))
	error (_("Integer literal out of range"));
      result *= base;
      exp -= 1;
    }

  if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0)
    yylval.typed_val.type = type_int ();
  else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0)
    yylval.typed_val.type = type_long ();
  else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0)
    {
      /* We have a number representable as an unsigned integer quantity.
         For consistency with the C treatment, we will treat it as an
	 anonymous modular (unsigned) quantity.  Alas, the types are such
	 that we need to store .val as a signed quantity.  Sorry
         for the mess, but C doesn't officially guarantee that a simple
         assignment does the trick (no, it doesn't; read the reference manual).
       */
      yylval.typed_val.type
	= builtin_type (parse_gdbarch)->builtin_unsigned_long;
      if (result & LONGEST_SIGN)
	yylval.typed_val.val =
	  (LONGEST) (result & ~LONGEST_SIGN)
	  - (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
      else
	yylval.typed_val.val = (LONGEST) result;
      return INT;
    }
  else
    yylval.typed_val.type = type_long_long ();

  yylval.typed_val.val = (LONGEST) result;
  return INT;
}

static int
processReal (const char *num0)
{
  sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);

  yylval.typed_val_float.type = type_float ();
  if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch)
			    / TARGET_CHAR_BIT)
    yylval.typed_val_float.type = type_double ();
  if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch)
			    / TARGET_CHAR_BIT)
    yylval.typed_val_float.type = type_long_double ();

  return FLOAT;
}


/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym.  The
   resulting string is valid until the next call to ada_parse.  It differs
   from NAME0 in that:
    + Characters between '...' or <...> are transfered verbatim to 
      yylval.ssym.
    + <, >, and trailing "'" characters in quoted sequences are removed
      (a leading quote is preserved to indicate that the name is not to be
      GNAT-encoded).
    + Unquoted whitespace is removed.
    + Unquoted alphabetic characters are mapped to lower case.
   Result is returned as a struct stoken, but for convenience, the string
   is also null-terminated.  Result string valid until the next call of
   ada_parse.
 */
static struct stoken
processId (const char *name0, int len)
{
  char *name = obstack_alloc (&temp_parse_space, len + 11);
  int i0, i;
  struct stoken result;

  while (len > 0 && isspace (name0[len-1]))
    len -= 1;
  i = i0 = 0;
  while (i0 < len)
    {
      if (isalnum (name0[i0]))
	{
	  name[i] = tolower (name0[i0]);
	  i += 1; i0 += 1;
	}
      else switch (name0[i0])
	{
	default:
	  name[i] = name0[i0];
	  i += 1; i0 += 1;
	  break;
	case ' ': case '\t':
	  i0 += 1;
	  break;
	case '\'':
	  do
	    {
	      name[i] = name0[i0];
	      i += 1; i0 += 1;
	    }
	  while (i0 < len && name0[i0] != '\'');
	  i0 += 1;
	  break;
	case '<':
	  i0 += 1;
	  while (i0 < len && name0[i0] != '>')
	    {
	      name[i] = name0[i0];
	      i += 1; i0 += 1;
	    }
	  i0 += 1;
	  break;
	}
    }
  name[i] = '\000';

  result.ptr = name;
  result.length = i;
  return result;
}

/* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
   with special hex character notations replaced with characters. 
   Result valid until the next call to ada_parse.  */

static struct stoken
processString (const char *text, int len)
{
  const char *p;
  char *q;
  const char *lim = text + len;
  struct stoken result;

  q = result.ptr = obstack_alloc (&temp_parse_space, len);
  p = text;
  while (p < lim)
    {
      if (p[0] == '[' && p[1] == '"' && p+2 < lim)
         {
           if (p[2] == '"')  /* "...["""]... */
             {
               *q = '"';
	       p += 4;
	     }
           else
	     {
               int chr;
	       sscanf (p+2, "%2x", &chr);
	       *q = (char) chr;
	       p += 5;
	     }
         }
       else
         *q = *p;
       q += 1;
       p += 1;
     }
  result.length = q - result.ptr;
  return result;
}

/* Returns the position within STR of the '.' in a
   '.{WHITE}*all' component of a dotted name, or -1 if there is none.
   Note: we actually don't need this routine, since 'all' can never be an
   Ada identifier.  Thus, looking up foo.all or foo.all.x as a name
   must fail, and will eventually be interpreted as (foo).all or
   (foo).all.x.  However, this does avoid an extraneous lookup. */

static int
find_dot_all (const char *str)
{
  int i;
  for (i = 0; str[i] != '\000'; i += 1)
    {
      if (str[i] == '.')
	{
	  int i0 = i;
	  do
	    i += 1;
	  while (isspace (str[i]));
	  if (strncmp (str+i, "all", 3) == 0
	      && ! isalnum (str[i+3]) && str[i+3] != '_')
	    return i0;
	}
    }
  return -1;
}

/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
   case.  */

static int
subseqMatch (const char *subseq, const char *str)
{
  if (subseq[0] == '\0')
    return 1;
  else if (str[0] == '\0')
    return 0;
  else if (tolower (subseq[0]) == tolower (str[0]))
    return subseqMatch (subseq+1, str+1) || subseqMatch (subseq, str+1);
  else
    return subseqMatch (subseq, str+1);
}


static struct { const char *name; int code; }
attributes[] = {
  { "address", TICK_ADDRESS },
  { "unchecked_access", TICK_ACCESS },
  { "unrestricted_access", TICK_ACCESS },
  { "access", TICK_ACCESS },
  { "first", TICK_FIRST },
  { "last", TICK_LAST },
  { "length", TICK_LENGTH },
  { "max", TICK_MAX },
  { "min", TICK_MIN },
  { "modulus", TICK_MODULUS },
  { "pos", TICK_POS },
  { "range", TICK_RANGE },
  { "size", TICK_SIZE },
  { "tag", TICK_TAG },
  { "val", TICK_VAL },
  { NULL, -1 }
};

/* Return the syntactic code corresponding to the attribute name or
   abbreviation STR.  */

static int
processAttribute (const char *str)
{
  int i, k;

  for (i = 0; attributes[i].code != -1; i += 1)
    if (strcasecmp (str, attributes[i].name) == 0)
      return attributes[i].code;

  for (i = 0, k = -1; attributes[i].code != -1; i += 1)
    if (subseqMatch (str, attributes[i].name))
      {
	if (k == -1)
	  k = i;
	else
	  error (_("ambiguous attribute name: `%s'"), str);
      }
  if (k == -1)
    error (_("unrecognized attribute: `%s'"), str);

  return attributes[k].code;
}

int
yywrap(void)
{
  return 1;
}

/* Dummy definition to suppress warnings about unused static definitions. */
typedef void (*dummy_function) ();
dummy_function ada_flex_use[] = 
{ 
  (dummy_function) yyunput
};
Commit	Line	Data
14f9c5c9	1	/* FLEX lexer for Ada expressions, for GDB.
0fb0cc75	2	Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007, 2008, 2009
14f9c5c9 AS	3	Free Software Foundation, Inc.
14f9c5c9 AS	4
5b1ba0e5 NS	5	This file is part of GDB.
	6
	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 3 of the License, or
	10	(at your option) any later version.
	11
	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.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
14f9c5c9 AS	19
	20	/----------------------------------------------------------------------/
	21
	22	/* The converted version of this file is to be included in ada-exp.y, */
	23	/* the Ada parser for gdb. The function yylex obtains characters from */
	24	/* the global pointer lexptr. It returns a syntactic category for */
	25	/* each successive token and places a semantic value into yylval */
	26	/* (ada-lval), defined by the parser. */
	27
14f9c5c9 AS	28	DIG [0-9]
	29	NUM10 ({DIG}({DIG}\|_)*)
	30	HEXDIG [0-9a-f]
	31	NUM16 ({HEXDIG}({HEXDIG}\|_)*)
	32	OCTDIG [0-7]
	33	LETTER [a-z_]
	34	ID ({LETTER}({LETTER}\|{DIG})\|"<"{LETTER}({LETTER}\|{DIG})">")
	35	WHITE [ \t\n]
	36	TICK ("'"{WHITE}*)
	37	GRAPHIC [a-z0-9 #&'()*+,-./:;<>=_\|!$%?@\[\]\\^`{}~]
	38	OPER ([-+/=<>&]\|"<="\|">="\|"*"\|"/="\|"and"\|"or"\|"xor"\|"not"\|"mod"\|"rem"\|"abs")
	39
	40	EXP (e[+-]{NUM10})
	41	POSEXP (e"+"?{NUM10})
	42
	43	%{
4c4b4cd2	44
14f9c5c9 AS	45	#define NUMERAL_WIDTH 256
	46	#define LONGEST_SIGN ((ULONGEST) 1 << (sizeof(LONGEST) * HOST_CHAR_BIT - 1))
	47
4c4b4cd2 PH	48	/* Temporary staging for numeric literals. */
	49	static char numbuf[NUMERAL_WIDTH];
	50	static void canonicalizeNumeral (char s1, const char );
52ce6436	51	static struct stoken processString (const char*, int);
4c4b4cd2 PH	52	static int processInt (const char , const char , const char *);
4c4b4cd2 PH	53	static int processReal (const char *);
52ce6436	54	static struct stoken processId (const char *, int);
4c4b4cd2 PH	55	static int processAttribute (const char *);
4c4b4cd2 PH	56	static int find_dot_all (const char *);
14f9c5c9 AS	57
14f9c5c9 AS	58	#undef YY_DECL
4c4b4cd2	59	#define YY_DECL static int yylex ( void )
14f9c5c9 AS	60
	61	#undef YY_INPUT
	62	#define YY_INPUT(BUF, RESULT, MAX_SIZE) \
	63	if ( *lexptr == '\000' ) \
	64	(RESULT) = YY_NULL; \
	65	else \
	66	{ \
	67	(BUF) = lexptr; \
	68	(RESULT) = 1; \
	69	lexptr += 1; \
	70	}
	71
4c4b4cd2	72	static int find_dot_all (const char *);
14f9c5c9 AS	73
	74	%}
	75
7dc1ef8d PH	76	%option case-insensitive interactive nodefault
7dc1ef8d PH	77
52ce6436	78	%s BEFORE_QUAL_QUOTE
14f9c5c9 AS	79
	80	%%
	81
	82	{WHITE} { }
	83
	84	"--".* { yyterminate(); }
	85
4c4b4cd2 PH	86	{NUM10}{POSEXP} {
4c4b4cd2 PH	87	canonicalizeNumeral (numbuf, yytext);
14f9c5c9 AS	88	return processInt (NULL, numbuf, strrchr(numbuf, 'e')+1);
	89	}
	90
4c4b4cd2 PH	91	{NUM10} {
4c4b4cd2 PH	92	canonicalizeNumeral (numbuf, yytext);
14f9c5c9 AS	93	return processInt (NULL, numbuf, NULL);
	94	}
	95
	96	{NUM10}"#"{HEXDIG}({HEXDIG}\|_)*"#"{POSEXP} {
	97	canonicalizeNumeral (numbuf, yytext);
	98	return processInt (numbuf,
4c4b4cd2	99	strchr (numbuf, '#') + 1,
14f9c5c9 AS	100	strrchr(numbuf, '#') + 1);
	101	}
	102
	103	{NUM10}"#"{HEXDIG}({HEXDIG}\|_)*"#" {
	104	canonicalizeNumeral (numbuf, yytext);
	105	return processInt (numbuf, strchr (numbuf, '#') + 1, NULL);
	106	}
	107
	108	"0x"{HEXDIG}+ {
	109	canonicalizeNumeral (numbuf, yytext+2);
	110	return processInt ("16#", numbuf, NULL);
	111	}
	112
	113
	114	{NUM10}"."{NUM10}{EXP} {
4c4b4cd2	115	canonicalizeNumeral (numbuf, yytext);
14f9c5c9 AS	116	return processReal (numbuf);
	117	}
	118
	119	{NUM10}"."{NUM10} {
4c4b4cd2	120	canonicalizeNumeral (numbuf, yytext);
14f9c5c9 AS	121	return processReal (numbuf);
	122	}
	123
	124	{NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
e1d5a0d2	125	error (_("Based real literals not implemented yet."));
14f9c5c9 AS	126	}
	127
	128	{NUM10}"#"{NUM16}"."{NUM16}"#" {
e1d5a0d2	129	error (_("Based real literals not implemented yet."));
14f9c5c9 AS	130	}
	131
	132	<INITIAL>"'"({GRAPHIC}\|\")"'" {
72d5681a	133	yylval.typed_val.type = type_char ();
14f9c5c9 AS	134	yylval.typed_val.val = yytext[1];
	135	return CHARLIT;
	136	}
	137
	138	<INITIAL>"'[\""{HEXDIG}{2}"\"]'" {
	139	int v;
72d5681a	140	yylval.typed_val.type = type_char ();
14f9c5c9 AS	141	sscanf (yytext+3, "%2x", &v);
	142	yylval.typed_val.val = v;
	143	return CHARLIT;
	144	}
	145
52ce6436 PH	146	\"({GRAPHIC}\|"[\""({HEXDIG}{2}\|\")"\"]")*\" {
52ce6436 PH	147	yylval.sval = processString (yytext+1, yyleng-2);
14f9c5c9 AS	148	return STRING;
	149	}
	150
52ce6436	151	\" {
e1d5a0d2	152	error (_("ill-formed or non-terminated string literal"));
14f9c5c9 AS	153	}
14f9c5c9 AS	154
14f9c5c9	155
4c4b4cd2 PH	156	if {
	157	while (lexptr != 'i' && lexptr != 'I')
	158	lexptr -= 1;
	159	yyrestart(NULL);
14f9c5c9 AS	160	return 0;
	161	}
	162
70575d34 JB	163	task {
	164	while (lexptr != 't' && lexptr != 'T')
	165	lexptr--;
	166	yyrestart(NULL);
	167	return 0;
	168	}
	169
14f9c5c9 AS	170	/* ADA KEYWORDS */
	171
	172	abs { return ABS; }
	173	and { return _AND_; }
	174	else { return ELSE; }
	175	in { return IN; }
	176	mod { return MOD; }
	177	new { return NEW; }
	178	not { return NOT; }
	179	null { return NULL_PTR; }
	180	or { return OR; }
52ce6436	181	others { return OTHERS; }
14f9c5c9 AS	182	rem { return REM; }
	183	then { return THEN; }
	184	xor { return XOR; }
	185
690cc4eb PH	186	/* BOOLEAN "KEYWORDS" */
	187
	188	/* True and False are not keywords in Ada, but rather enumeration constants.
	189	However, the boolean type is no longer represented as an enum, so True
	190	and False are no longer defined in symbol tables. We compromise by
	191	making them keywords (when bare). */
	192
	193	true { return TRUEKEYWORD; }
	194	false { return FALSEKEYWORD; }
	195
14f9c5c9 AS	196	/* ATTRIBUTES */
	197
	198	{TICK}[a-zA-Z][a-zA-Z]+ { return processAttribute (yytext+1); }
	199
	200	/* PUNCTUATION */
	201
	202	"=>" { return ARROW; }
	203	".." { return DOTDOT; }
	204	"**" { return STARSTAR; }
	205	":=" { return ASSIGN; }
	206	"/=" { return NOTEQUAL; }
	207	"<=" { return LEQ; }
	208	">=" { return GEQ; }
	209
	210	<BEFORE_QUAL_QUOTE>"'" { BEGIN INITIAL; return '\''; }
	211
	212	[-&*+./:<>=\|;\[\]] { return yytext[0]; }
	213
	214	"," { if (paren_depth == 0 && comma_terminates)
	215	{
	216	lexptr -= 1;
	217	yyrestart(NULL);
	218	return 0;
	219	}
4c4b4cd2	220	else
14f9c5c9 AS	221	return ',';
	222	}
	223
	224	"(" { paren_depth += 1; return '('; }
4c4b4cd2	225	")" { if (paren_depth == 0)
14f9c5c9 AS	226	{
	227	lexptr -= 1;
	228	yyrestart(NULL);
	229	return 0;
	230	}
4c4b4cd2	231	else
14f9c5c9	232	{
4c4b4cd2	233	paren_depth -= 1;
14f9c5c9 AS	234	return ')';
	235	}
	236	}
	237
	238	"."{WHITE}*all { return DOT_ALL; }
	239
4c4b4cd2	240	"."{WHITE}*{ID} {
52ce6436	241	yylval.sval = processId (yytext+1, yyleng-1);
4c4b4cd2	242	return DOT_ID;
14f9c5c9 AS	243	}
14f9c5c9 AS	244
4c4b4cd2	245	{ID}({WHITE}"."{WHITE}({ID}\|\"{OPER}\"))(" ""'")? {
14f9c5c9	246	int all_posn = find_dot_all (yytext);
14f9c5c9	247
4c4b4cd2	248	if (all_posn == -1 && yytext[yyleng-1] == '\'')
14f9c5c9	249	{
52ce6436 PH	250	BEGIN BEFORE_QUAL_QUOTE;
52ce6436 PH	251	yyless (yyleng-1);
14f9c5c9	252	}
52ce6436	253	else if (all_posn >= 0)
14f9c5c9	254	yyless (all_posn);
52ce6436 PH	255	yylval.sval = processId (yytext, yyleng);
	256	return NAME;
	257	}
14f9c5c9	258
14f9c5c9	259
52ce6436	260	/* GDB EXPRESSION CONSTRUCTS */
14f9c5c9 AS	261
14f9c5c9 AS	262	"'"[^']+"'"{WHITE}*:: {
52ce6436 PH	263	yyless (yyleng - 2);
	264	yylval.sval = processId (yytext, yyleng);
	265	return NAME;
14f9c5c9 AS	266	}
14f9c5c9 AS	267
52ce6436	268	"::" { return COLONCOLON; }
14f9c5c9 AS	269
	270	[{}@] { return yytext[0]; }
	271
14f9c5c9 AS	272	/* REGISTERS AND GDB CONVENIENCE VARIABLES */
14f9c5c9 AS	273
4c4b4cd2	274	"$"({LETTER}\|{DIG}\|"$")* {
14f9c5c9 AS	275	yylval.sval.ptr = yytext;
14f9c5c9 AS	276	yylval.sval.length = yyleng;
4c4b4cd2	277	return SPECIAL_VARIABLE;
14f9c5c9 AS	278	}
	279
	280	/* CATCH-ALL ERROR CASE */
	281
e1d5a0d2	282	. { error (_("Invalid character '%s' in expression."), yytext); }
14f9c5c9 AS	283	%%
	284
	285	#include <ctype.h>
19c1ef65	286	#include "gdb_string.h"
14f9c5c9	287
52ce6436 PH	288	/* Initialize the lexer for processing new expression. */
52ce6436 PH	289
14f9c5c9	290	void
4c4b4cd2	291	lexer_init (FILE *inp)
14f9c5c9 AS	292	{
	293	BEGIN INITIAL;
	294	yyrestart (inp);
	295	}
	296
	297
4c4b4cd2	298	/* Copy S2 to S1, removing all underscores, and downcasing all letters. */
14f9c5c9 AS	299
14f9c5c9 AS	300	static void
4c4b4cd2	301	canonicalizeNumeral (char s1, const char s2)
14f9c5c9	302	{
4c4b4cd2	303	for (; *s2 != '\000'; s2 += 1)
14f9c5c9 AS	304	{
	305	if (*s2 != '_')
	306	{
	307	s1 = tolower(s2);
	308	s1 += 1;
	309	}
	310	}
	311	s1[0] = '\000';
	312	}
	313
14f9c5c9 AS	314	/* Interprets the prefix of NUM that consists of digits of the given BASE
	315	as an integer of that BASE, with the string EXP as an exponent.
	316	Puts value in yylval, and returns INT, if the string is valid. Causes
4c4b4cd2	317	an error if the number is improperly formated. BASE, if NULL, defaults
52ce6436 PH	318	to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'.
52ce6436 PH	319	*/
14f9c5c9 AS	320
14f9c5c9 AS	321	static int
4c4b4cd2	322	processInt (const char base0, const char num0, const char *exp0)
14f9c5c9 AS	323	{
	324	ULONGEST result;
	325	long exp;
	326	int base;
	327
4c4b4cd2	328	char *trailer;
14f9c5c9 AS	329
	330	if (base0 == NULL)
	331	base = 10;
	332	else
4c4b4cd2 PH	333	{
4c4b4cd2 PH	334	base = strtol (base0, (char **) NULL, 10);
14f9c5c9	335	if (base < 2 \|\| base > 16)
e1d5a0d2	336	error (_("Invalid base: %d."), base);
14f9c5c9 AS	337	}
	338
	339	if (exp0 == NULL)
	340	exp = 0;
	341	else
4c4b4cd2	342	exp = strtol(exp0, (char **) NULL, 10);
14f9c5c9 AS	343
14f9c5c9 AS	344	errno = 0;
4c4b4cd2	345	result = strtoulst (num0, (const char **) &trailer, base);
14f9c5c9	346	if (errno == ERANGE)
e1d5a0d2	347	error (_("Integer literal out of range"));
14f9c5c9	348	if (isxdigit(*trailer))
e1d5a0d2	349	error (_("Invalid digit `%c' in based literal"), *trailer);
14f9c5c9	350
4c4b4cd2	351	while (exp > 0)
14f9c5c9 AS	352	{
14f9c5c9 AS	353	if (result > (ULONG_MAX / base))
e1d5a0d2	354	error (_("Integer literal out of range"));
14f9c5c9 AS	355	result *= base;
	356	exp -= 1;
	357	}
4c4b4cd2	358
3e79cecf	359	if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0)
72d5681a	360	yylval.typed_val.type = type_int ();
3e79cecf	361	else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0)
72d5681a	362	yylval.typed_val.type = type_long ();
3e79cecf	363	else if (((result >> (gdbarch_long_bit (parse_gdbarch)-1)) >> 1) == 0)
14f9c5c9 AS	364	{
14f9c5c9 AS	365	/* We have a number representable as an unsigned integer quantity.
4c4b4cd2	366	For consistency with the C treatment, we will treat it as an
14f9c5c9	367	anonymous modular (unsigned) quantity. Alas, the types are such
4c4b4cd2	368	that we need to store .val as a signed quantity. Sorry
14f9c5c9 AS	369	for the mess, but C doesn't officially guarantee that a simple
	370	assignment does the trick (no, it doesn't; read the reference manual).
	371	*/
3e79cecf UW	372	yylval.typed_val.type
3e79cecf UW	373	= builtin_type (parse_gdbarch)->builtin_unsigned_long;
14f9c5c9	374	if (result & LONGEST_SIGN)
4c4b4cd2 PH	375	yylval.typed_val.val =
4c4b4cd2 PH	376	(LONGEST) (result & ~LONGEST_SIGN)
14f9c5c9 AS	377	- (LONGEST_SIGN>>1) - (LONGEST_SIGN>>1);
	378	else
	379	yylval.typed_val.val = (LONGEST) result;
	380	return INT;
	381	}
4c4b4cd2	382	else
72d5681a	383	yylval.typed_val.type = type_long_long ();
14f9c5c9 AS	384
	385	yylval.typed_val.val = (LONGEST) result;
	386	return INT;
	387	}
	388
	389	static int
4c4b4cd2	390	processReal (const char *num0)
14f9c5c9	391	{
689e4e2d	392	sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
14f9c5c9	393
72d5681a	394	yylval.typed_val_float.type = type_float ();
3e79cecf	395	if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch)
ea06eb3d	396	/ TARGET_CHAR_BIT)
72d5681a	397	yylval.typed_val_float.type = type_double ();
3e79cecf	398	if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch)
ea06eb3d	399	/ TARGET_CHAR_BIT)
72d5681a	400	yylval.typed_val_float.type = type_long_double ();
14f9c5c9 AS	401
	402	return FLOAT;
	403	}
	404
52ce6436 PH	405
	406	/* Store a canonicalized version of NAME0[0..LEN-1] in yylval.ssym. The
	407	resulting string is valid until the next call to ada_parse. It differs
	408	from NAME0 in that:
	409	+ Characters between '...' or <...> are transfered verbatim to
	410	yylval.ssym.
	411	+ <, >, and trailing "'" characters in quoted sequences are removed
	412	(a leading quote is preserved to indicate that the name is not to be
	413	GNAT-encoded).
	414	+ Unquoted whitespace is removed.
	415	+ Unquoted alphabetic characters are mapped to lower case.
	416	Result is returned as a struct stoken, but for convenience, the string
	417	is also null-terminated. Result string valid until the next call of
	418	ada_parse.
	419	*/
	420	static struct stoken
4c4b4cd2	421	processId (const char *name0, int len)
14f9c5c9	422	{
4c4b4cd2	423	char *name = obstack_alloc (&temp_parse_space, len + 11);
14f9c5c9	424	int i0, i;
52ce6436	425	struct stoken result;
4c4b4cd2	426
14f9c5c9 AS	427	while (len > 0 && isspace (name0[len-1]))
	428	len -= 1;
	429	i = i0 = 0;
4c4b4cd2	430	while (i0 < len)
14f9c5c9 AS	431	{
	432	if (isalnum (name0[i0]))
	433	{
	434	name[i] = tolower (name0[i0]);
	435	i += 1; i0 += 1;
	436	}
4c4b4cd2	437	else switch (name0[i0])
14f9c5c9 AS	438	{
	439	default:
	440	name[i] = name0[i0];
	441	i += 1; i0 += 1;
	442	break;
	443	case ' ': case '\t':
	444	i0 += 1;
	445	break;
	446	case '\'':
52ce6436	447	do
14f9c5c9 AS	448	{
	449	name[i] = name0[i0];
	450	i += 1; i0 += 1;
	451	}
52ce6436	452	while (i0 < len && name0[i0] != '\'');
14f9c5c9 AS	453	i0 += 1;
	454	break;
	455	case '<':
	456	i0 += 1;
	457	while (i0 < len && name0[i0] != '>')
	458	{
	459	name[i] = name0[i0];
	460	i += 1; i0 += 1;
	461	}
	462	i0 += 1;
	463	break;
	464	}
	465	}
	466	name[i] = '\000';
	467
52ce6436 PH	468	result.ptr = name;
	469	result.length = i;
	470	return result;
14f9c5c9 AS	471	}
14f9c5c9 AS	472
52ce6436 PH	473	/* Return TEXT[0..LEN-1], a string literal without surrounding quotes,
	474	with special hex character notations replaced with characters.
	475	Result valid until the next call to ada_parse. */
14f9c5c9	476
52ce6436 PH	477	static struct stoken
52ce6436 PH	478	processString (const char *text, int len)
14f9c5c9	479	{
52ce6436 PH	480	const char *p;
	481	char *q;
	482	const char *lim = text + len;
	483	struct stoken result;
	484
	485	q = result.ptr = obstack_alloc (&temp_parse_space, len);
	486	p = text;
	487	while (p < lim)
14f9c5c9	488	{
52ce6436 PH	489	if (p[0] == '[' && p[1] == '"' && p+2 < lim)
	490	{
	491	if (p[2] == '"') /* "...["""]... */
	492	{
	493	*q = '"';
	494	p += 4;
	495	}
	496	else
	497	{
	498	int chr;
	499	sscanf (p+2, "%2x", &chr);
	500	*q = (char) chr;
	501	p += 5;
	502	}
	503	}
	504	else
	505	q = p;
	506	q += 1;
	507	p += 1;
	508	}
	509	result.length = q - result.ptr;
	510	return result;
14f9c5c9 AS	511	}
	512
	513	/* Returns the position within STR of the '.' in a
52ce6436 PH	514	'.{WHITE}*all' component of a dotted name, or -1 if there is none.
	515	Note: we actually don't need this routine, since 'all' can never be an
	516	Ada identifier. Thus, looking up foo.all or foo.all.x as a name
	517	must fail, and will eventually be interpreted as (foo).all or
	518	(foo).all.x. However, this does avoid an extraneous lookup. */
	519
14f9c5c9	520	static int
4c4b4cd2	521	find_dot_all (const char *str)
14f9c5c9 AS	522	{
	523	int i;
	524	for (i = 0; str[i] != '\000'; i += 1)
	525	{
	526	if (str[i] == '.')
	527	{
	528	int i0 = i;
4c4b4cd2	529	do
14f9c5c9 AS	530	i += 1;
14f9c5c9 AS	531	while (isspace (str[i]));
52ce6436	532	if (strncmp (str+i, "all", 3) == 0
14f9c5c9 AS	533	&& ! isalnum (str[i+3]) && str[i+3] != '_')
	534	return i0;
	535	}
	536	}
	537	return -1;
4c4b4cd2	538	}
14f9c5c9 AS	539
14f9c5c9 AS	540	/* Returns non-zero iff string SUBSEQ matches a subsequence of STR, ignoring
4c4b4cd2	541	case. */
14f9c5c9 AS	542
14f9c5c9 AS	543	static int
4c4b4cd2	544	subseqMatch (const char subseq, const char str)
14f9c5c9 AS	545	{
	546	if (subseq[0] == '\0')
	547	return 1;
	548	else if (str[0] == '\0')
	549	return 0;
	550	else if (tolower (subseq[0]) == tolower (str[0]))
	551	return subseqMatch (subseq+1, str+1) \|\| subseqMatch (subseq, str+1);
	552	else
	553	return subseqMatch (subseq, str+1);
	554	}
14f9c5c9	555
4c4b4cd2 PH	556
4c4b4cd2 PH	557	static struct { const char *name; int code; }
14f9c5c9 AS	558	attributes[] = {
	559	{ "address", TICK_ADDRESS },
	560	{ "unchecked_access", TICK_ACCESS },
	561	{ "unrestricted_access", TICK_ACCESS },
	562	{ "access", TICK_ACCESS },
	563	{ "first", TICK_FIRST },
	564	{ "last", TICK_LAST },
	565	{ "length", TICK_LENGTH },
	566	{ "max", TICK_MAX },
	567	{ "min", TICK_MIN },
	568	{ "modulus", TICK_MODULUS },
	569	{ "pos", TICK_POS },
	570	{ "range", TICK_RANGE },
	571	{ "size", TICK_SIZE },
	572	{ "tag", TICK_TAG },
	573	{ "val", TICK_VAL },
	574	{ NULL, -1 }
	575	};
	576
	577	/* Return the syntactic code corresponding to the attribute name or
	578	abbreviation STR. */
	579
	580	static int
4c4b4cd2	581	processAttribute (const char *str)
14f9c5c9 AS	582	{
	583	int i, k;
	584
	585	for (i = 0; attributes[i].code != -1; i += 1)
	586	if (strcasecmp (str, attributes[i].name) == 0)
	587	return attributes[i].code;
	588
	589	for (i = 0, k = -1; attributes[i].code != -1; i += 1)
4c4b4cd2	590	if (subseqMatch (str, attributes[i].name))
14f9c5c9 AS	591	{
	592	if (k == -1)
	593	k = i;
4c4b4cd2	594	else
e1d5a0d2	595	error (_("ambiguous attribute name: `%s'"), str);
14f9c5c9 AS	596	}
14f9c5c9 AS	597	if (k == -1)
e1d5a0d2	598	error (_("unrecognized attribute: `%s'"), str);
14f9c5c9 AS	599
	600	return attributes[k].code;
	601	}
	602
	603	int
4c4b4cd2	604	yywrap(void)
14f9c5c9 AS	605	{
	606	return 1;
	607	}
23485554 PH	608
	609	/* Dummy definition to suppress warnings about unused static definitions. */
	610	typedef void (*dummy_function) ();
	611	dummy_function ada_flex_use[] =
	612	{
375c0479	613	(dummy_function) yyunput
23485554	614	};