/* FLEX lexer for Ada expressions, for GDB.
- Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003
+ Copyright (C) 1994, 1997, 1998, 2000, 2001, 2002, 2003, 2007, 2008
Free Software Foundation, Inc.
This file is part of GDB.
}
{NUM10}"#"{NUM16}"."{NUM16}"#"{EXP} {
- error ("Based real literals not implemented yet.");
+ error (_("Based real literals not implemented yet."));
}
{NUM10}"#"{NUM16}"."{NUM16}"#" {
- error ("Based real literals not implemented yet.");
+ error (_("Based real literals not implemented yet."));
}
<INITIAL>"'"({GRAPHIC}|\")"'" {
}
\" {
- error ("ill-formed or non-terminated string literal");
+ error (_("ill-formed or non-terminated string literal"));
}
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); }
/* CATCH-ALL ERROR CASE */
-. { error ("Invalid character '%s' in expression.", yytext); }
+. { error (_("Invalid character '%s' in expression."), yytext); }
%%
#include <ctype.h>
s1[0] = '\000';
}
-#define HIGH_BYTE_POSN ((sizeof (ULONGEST) - 1) * HOST_CHAR_BIT)
-
-/* True (non-zero) iff DIGIT is a valid digit in radix BASE,
- where 2 <= BASE <= 16. */
-
-static int
-is_digit_in_base (unsigned char digit, int base)
-{
- if (!isxdigit (digit))
- return 0;
- if (base <= 10)
- return (isdigit (digit) && digit < base + '0');
- else
- return (isdigit (digit) || tolower (digit) < base - 10 + 'a');
-}
-
-static int
-digit_to_int (unsigned char c)
-{
- if (isdigit (c))
- return c - '0';
- else
- return tolower (c) - 'a' + 10;
-}
-
-/* As for strtoul, but for ULONGEST results. */
-
-ULONGEST
-strtoulst (const char *num, const char **trailer, int base)
-{
- unsigned int high_part;
- ULONGEST result;
- int i;
- unsigned char lim;
-
- if (base < 2 || base > 16)
- {
- errno = EINVAL;
- return 0;
- }
- lim = base - 1 + '0';
-
- result = high_part = 0;
- for (i = 0; is_digit_in_base (num[i], base); i += 1)
- {
- result = result*base + digit_to_int (num[i]);
- high_part = high_part*base + (unsigned int) (result >> HIGH_BYTE_POSN);
- result &= ((ULONGEST) 1 << HIGH_BYTE_POSN) - 1;
- if (high_part > 0xff)
- {
- errno = ERANGE;
- result = high_part = 0;
- break;
- }
- }
-
- if (trailer != NULL)
- *trailer = &num[i];
-
- return result + ((ULONGEST) high_part << HIGH_BYTE_POSN);
-}
-
/* 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
{
base = strtol (base0, (char **) NULL, 10);
if (base < 2 || base > 16)
- error ("Invalid base: %d.", base);
+ error (_("Invalid base: %d."), base);
}
if (exp0 == NULL)
errno = 0;
result = strtoulst (num0, (const char **) &trailer, base);
if (errno == ERANGE)
- error ("Integer literal out of range");
+ error (_("Integer literal out of range"));
if (isxdigit(*trailer))
- error ("Invalid digit `%c' in based literal", *trailer);
+ error (_("Invalid digit `%c' in based literal"), *trailer);
while (exp > 0)
{
if (result > (ULONG_MAX / base))
- error ("Integer literal out of range");
+ error (_("Integer literal out of range"));
result *= base;
exp -= 1;
}
- if ((result >> (TARGET_INT_BIT-1)) == 0)
+ if ((result >> (gdbarch_int_bit (parse_gdbarch)-1)) == 0)
yylval.typed_val.type = type_int ();
- else if ((result >> (TARGET_LONG_BIT-1)) == 0)
+ else if ((result >> (gdbarch_long_bit (parse_gdbarch)-1)) == 0)
yylval.typed_val.type = type_long ();
- else if (((result >> (TARGET_LONG_BIT-1)) >> 1) == 0)
+ 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
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_unsigned_long;
+ yylval.typed_val.type
+ = builtin_type (parse_gdbarch)->builtin_unsigned_long;
if (result & LONGEST_SIGN)
yylval.typed_val.val =
(LONGEST) (result & ~LONGEST_SIGN)
return INT;
}
-#if defined (PRINTF_HAS_LONG_DOUBLE)
-# undef PRINTF_HAS_LONG_DOUBLE
-# define PRINTF_HAS_LONG_DOUBLE 1
-#else
-# define PRINTF_HAS_LONG_DOUBLE 0
-#endif
-
static int
processReal (const char *num0)
{
-#if defined (PRINTF_HAS_LONG_DOUBLE)
- if (sizeof (DOUBLEST) > sizeof (double))
- sscanf (num0, "%Lg", &yylval.typed_val_float.dval);
- else
-#endif
- {
- double temp;
- sscanf (num0, "%lg", &temp);
- yylval.typed_val_float.dval = temp;
- }
+ sscanf (num0, "%" DOUBLEST_SCAN_FORMAT, &yylval.typed_val_float.dval);
yylval.typed_val_float.type = type_float ();
- if (sizeof(DOUBLEST) >= TARGET_DOUBLE_BIT / TARGET_CHAR_BIT)
+ if (sizeof(DOUBLEST) >= gdbarch_double_bit (parse_gdbarch)
+ / TARGET_CHAR_BIT)
yylval.typed_val_float.type = type_double ();
- if (sizeof(DOUBLEST) >= TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT)
+ if (sizeof(DOUBLEST) >= gdbarch_long_double_bit (parse_gdbarch)
+ / TARGET_CHAR_BIT)
yylval.typed_val_float.type = type_long_double ();
return FLOAT;
if (k == -1)
k = i;
else
- error ("ambiguous attribute name: `%s'", str);
+ error (_("ambiguous attribute name: `%s'"), str);
}
if (k == -1)
- error ("unrecognized attribute: `%s'", str);
+ error (_("unrecognized attribute: `%s'"), str);
return attributes[k].code;
}
projects / deliverable / binutils-gdb.git / blobdiff