OSDN Git Service

213a80f3c5dfe2ed9a3dec4bc9d5bce8205f5bfe
[pf3gnuchains/gcc-fork.git] / gcc / java / lex.h
1 /* Language lexer definitions for the GNU compiler for the Java(TM) language.
2    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
3    Free Software Foundation, Inc.
4    Contributed by Alexandre Petit-Bianco (apbianco@cygnus.com)
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.
22
23 Java and all Java-based marks are trademarks or registered trademarks
24 of Sun Microsystems, Inc. in the United States and other countries.
25 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
26
27 #ifndef GCC_JAVA_LEX_H
28 #define GCC_JAVA_LEX_H
29
30 #include "input.h"
31
32 /* Extern global variables declarations  */
33 extern FILE *finput;
34
35 /* A Unicode character, as read from the input file  */
36 typedef unsigned short unicode_t;
37
38 #if defined HAVE_ICONV_H && defined HAVE_ICONV
39 #include <iconv.h>
40 #endif /* HAVE_ICONV */
41
42 /* Default encoding to use if no encoding is specified.  */
43 #define DEFAULT_ENCODING "UTF-8"
44
45 /* Debug macro to print-out what we match  */
46 #ifdef JAVA_LEX_DEBUG
47 #ifdef JAVA_LEX_DEBUG_CHAR
48 #define JAVA_LEX_CHAR(c)      printf ("java_lex:%d: char '%c'.%d\n",    \
49                                       lineno, (c < 128 ? c : '.'), c);
50 #else
51 #define JAVA_LEX_CHAR(c)
52 #endif
53 #define JAVA_LEX_KW(c)        printf ("java_lex:%d: keyword: '%s'\n", lineno,c)
54 #define JAVA_LEX_ID(s)        printf ("java_lex:%d: ID: '%s'\n",        \
55                                       lineno,                           \
56                                       (all_ascii ? s : "<U>"))
57 #define JAVA_LEX_LIT(s, r)    printf ("java_lex:%d: literal '%s'_%d\n", \
58                                       lineno, s, r)
59 #define JAVA_LEX_CHAR_LIT(s)  printf ("java_lex:%d: literal '%d'\n", lineno, s)
60 #define JAVA_LEX_STR_LIT(s)   {                                          \
61                                  int i;                                  \
62                                  printf ("java_lex:%d: literal '%s'\n",  \
63                                          lineno, s);                     \
64                                }
65 #define JAVA_LEX_SEP(c)       printf ("java_lex:%d: separator '%c'\n",lineno,c)
66 #define JAVA_LEX_OP(c)        printf ("java_lex:%d: operator '%s'\n", lineno,c)
67 #else
68 #define JAVA_LEX_CHAR(c)
69 #define JAVA_LEX_KW(c)
70 #define JAVA_LEX_ID(s)
71 #define JAVA_LEX_LIT(s,r)
72 #define JAVA_LEX_CHAR_LIT(s)
73 #define JAVA_LEX_STR_LIT(s)
74 #define JAVA_LEX_SEP(c)
75 #define JAVA_LEX_OP(s)
76 #endif
77
78 /* Line information containers  */
79 struct java_line {
80   unicode_t *line;              /* The line's unicode */
81   char      *unicode_escape_p;  /* The matching char was a unicode escape */
82   unicode_t ahead[1];           /* Character ahead */
83   char unicode_escape_ahead_p;  /* Character ahead is a unicode escape */
84   int max;                      /* buffer's max size */
85   int size;                     /* number of unicodes */
86   int current;                  /* Current position, unicode based */
87   int char_col;                 /* Current position, input char based */
88   int lineno;                   /* Its line number */
89   int white_space_only;         /* If it contains only white spaces */
90 };
91 #define JAVA_COLUMN_DELTA(p)                                            \
92   (ctxp->c_line->unicode_escape_p [ctxp->c_line->current+(p)] ? 6 :     \
93    (ctxp->c_line->line [ctxp->c_line->current+(p)] == '\t' ? 8 : 1))
94
95 struct java_error {
96   struct java_line *line;
97   int error;
98 };
99
100 typedef struct java_lc_s GTY(()) {
101   int line;
102   int prev_col;
103   int col;
104 } java_lc;
105
106 struct java_lexer
107 {
108   /* The file from which we're reading.  */
109   FILE *finput;
110
111   /* Number of consecutive backslashes we've read.  */
112   int bs_count;
113
114   /* If nonzero, a value that was pushed back.  */
115   unicode_t unget_value;
116
117   /* If nonzero, we've hit EOF.  Used only by java_get_unicode().  */
118   int hit_eof : 1;
119   
120   /* Name of the character encoding we're using.  */
121   const char *encoding;
122
123 #ifdef HAVE_ICONV
124   /* Nonzero if we've read any bytes.  We only recognize the
125      byte-order-marker (BOM) as the first word.  */
126   int read_anything : 1;
127
128   /* Nonzero if we have to byte swap.  */
129   int byte_swap : 1;
130
131   /* Nonzero if we're using the fallback decoder.  */
132   int use_fallback : 1;
133
134   /* The handle for the iconv converter we're using.  */
135   iconv_t handle;
136
137   /* Bytes we've read from the file but have not sent to iconv.  */
138   char buffer[1024];
139
140   /* Index of first valid character in buffer, -1 if no valid
141      characters.  */
142   int first;
143
144   /* Index of last valid character in buffer, plus one.  -1 if no
145      valid characters in buffer.  */
146   int last;
147
148   /* This is a buffer of characters already converted by iconv.  We
149      use `char' here because we're assuming that iconv() converts to
150      UCS-2, and then we convert it ourselves.  */
151   unsigned char out_buffer[1024];
152
153   /* Index of first valid output character.  -1 if no valid
154      characters.  */
155   int out_first;
156
157   /* Index of last valid output character, plus one.  -1 if no valid
158      characters.  */
159   int out_last;
160
161 #endif /* HAVE_ICONV */
162 };
163 typedef struct java_lexer java_lexer;
164
165 /* Destroy a lexer object.  */
166 extern void java_destroy_lexer (java_lexer *);
167
168 #define JAVA_LINE_MAX 80
169
170 /* Build a location compound integer */
171 #define BUILD_LOCATION() ((ctxp->elc.line << 12) | (ctxp->elc.col & 0xfff))
172
173 /* Those macros are defined differently if we compile jc1-lite
174    (JC1_LITE defined) or jc1.  */
175 #ifdef JC1_LITE
176
177 #define DCONST0 0
178 #define REAL_VALUE_TYPE int
179 #define GET_IDENTIFIER(S) xstrdup ((S))
180 #define REAL_VALUE_ATOF(LIT,MODE) 0
181 #define REAL_VALUE_ISINF(VALUE)   0
182 #define REAL_VALUE_ISNAN(VALUE)   0
183 #define SET_REAL_VALUE_ATOF(TARGET,SOURCE)
184 #define FLOAT_TYPE_NODE 0
185 #define DOUBLE_TYPE_NODE 0
186 #define SET_MODIFIER_CTX(TOKEN) java_lval->value = (TOKEN)
187 #define GET_TYPE_PRECISION(NODE) 4
188 #define BUILD_OPERATOR(TOKEN)   return TOKEN
189 #define BUILD_OPERATOR2(TOKEN)  return ASSIGN_ANY_TK
190 #define SET_LVAL_NODE(NODE)
191 #define SET_LVAL_NODE_TYPE(NODE, TYPE)
192 #define BUILD_ID_WFL(EXP) (EXP)
193 #define JAVA_FLOAT_RANGE_ERROR(S) {}
194 #define JAVA_INTEGRAL_RANGE_ERROR(S) do { } while (0)
195
196 #else
197
198 #define DCONST0 dconst0
199 #define GET_IDENTIFIER(S) get_identifier ((S))
200 #define SET_REAL_VALUE_ATOF(TARGET,SOURCE) (TARGET) = (SOURCE)
201 #define FLOAT_TYPE_NODE float_type_node
202 #define DOUBLE_TYPE_NODE double_type_node
203 /* Set modifier_ctx according to TOKEN */
204 #define SET_MODIFIER_CTX(TOKEN)                                            \
205   {                                                                        \
206     ctxp->modifier_ctx [(TOKEN)-PUBLIC_TK] = build_wfl_node (NULL_TREE); \
207     java_lval->value = (TOKEN)-PUBLIC_TK;                                  \
208   }
209 /* Type precision for long */
210 #define GET_TYPE_PRECISION(NODE) TYPE_PRECISION (long_type_node) / 8;
211 /* Build an operator tree node and return TOKEN */
212 #define BUILD_OPERATOR(TOKEN)                           \
213   {                                                     \
214     java_lval->operator.token = (TOKEN);                \
215     java_lval->operator.location = BUILD_LOCATION();    \
216     return (TOKEN);                                     \
217   }
218
219 /* Build an operator tree node but return ASSIGN_ANY_TK */
220 #define BUILD_OPERATOR2(TOKEN)                          \
221   {                                                     \
222     java_lval->operator.token = (TOKEN);                \
223     java_lval->operator.location = BUILD_LOCATION();    \
224     return ASSIGN_ANY_TK;                               \
225   }
226 /* Set java_lval->node and TREE_TYPE(java_lval->node) in macros */
227 #define SET_LVAL_NODE(NODE) java_lval->node = (NODE)
228 #define SET_LVAL_NODE_TYPE(NODE,TYPE)           \
229   {                                             \
230     java_lval->node = (NODE);                   \
231     TREE_TYPE (java_lval->node) = (TYPE);       \
232   }
233 /* Wrap identifier around a wfl */
234 #define BUILD_ID_WFL(EXP) build_wfl_node ((EXP))
235 /* Special ways to report error on numeric literals  */
236 #define JAVA_FLOAT_RANGE_ERROR(m)                                         \
237   {                                                                       \
238     char msg [1024];                                                      \
239     int i = ctxp->c_line->current;                                        \
240     ctxp->c_line->current = number_beginning;                             \
241     sprintf (msg, "Floating point literal exceeds range of `%s'", (m)); \
242     java_lex_error (msg, 0);                                              \
243     ctxp->c_line->current = i;                                            \
244   }
245 #define JAVA_INTEGRAL_RANGE_ERROR(m)            \
246   do {                                          \
247     int i = ctxp->c_line->current;              \
248     ctxp->c_line->current = number_beginning;   \
249     java_lex_error (m, 0);                      \
250     ctxp->c_line->current = i;                  \
251   } while (0)
252
253 #endif /* Definitions for jc1 compilation only */
254
255 /* Macros to decode character ranges */
256 #define RANGE(c, l, h)           (((c) >= l && (c) <= h))
257 #define JAVA_WHITE_SPACE_P(c) (c == ' ' || c == '\t' || c == '\f')
258 #define JAVA_START_CHAR_P(c) ((c < 128                                        \
259                                && (ISIDST (c) || c == '$'))                   \
260                               || (c >= 128 && java_start_char_p (c)))
261 #define JAVA_PART_CHAR_P(c) ((c < 128                                         \
262                                && (ISIDNUM (c)                                \
263                                    || c == '$'                                \
264                                    || c == 0x0000                             \
265                                    || RANGE (c, 0x01, 0x08)                   \
266                                    || RANGE (c, 0x0e, 0x1b)                   \
267                                    || c == 0x7f))                             \
268                               || (c >= 128 && java_part_char_p (c)))
269 #define JAVA_ASCII_DIGIT(c)    ISDIGIT (c)
270 #define JAVA_ASCII_OCTDIGIT(c) RANGE (c, '0', '7')
271 #define JAVA_ASCII_HEXDIGIT(c) ISXDIGIT (c)
272 #define JAVA_ASCII_FPCHAR(c)   (RANGE (c, 'd', 'f') || RANGE (c, 'D', 'F') || \
273                                 c == '.' || JAVA_ASCII_DIGIT (c))
274 #define JAVA_FP_SUFFIX(c)      (c == 'D' || c == 'd' || c == 'f' || c == 'F')
275 #define JAVA_FP_EXP(c)         (c == 'E' || c == 'F')
276 #define JAVA_FP_PM(c)          (c == '-' || c == '+')
277 #define JAVA_ASCII_LETTER(c)   ISALPHA (c)
278
279 /* Constants  */
280 #define JAVA_READ_BUFFER 256
281 #define JAVA_CHAR_ERROR -2
282 #define UEOF -1
283
284 #endif /* ! GCC_JAVA_LEX_H */