OSDN Git Service

* tree-alias-common.h (struct tree_alias_ops): Change ip and
[pf3gnuchains/gcc-fork.git] / gcc / java / jcf.h
1 /* Utility macros to read Java(TM) .class files and byte codes.
2    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
3    Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
7 GCC 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, or (at your option)
10 any later version.
11
12 GCC 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 GCC; see the file COPYING.  If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA.  
21
22 Java and all Java-based marks are trademarks or registered trademarks
23 of Sun Microsystems, Inc. in the United States and other countries.
24 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
25
26 /* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
27
28 #ifndef GCC_JCF_H
29 #define GCC_JCF_H
30 #include "javaop.h"
31
32 #ifndef JCF_u4
33 #define JCF_u4 unsigned long
34 #endif
35 #ifndef JCF_u2
36 #define JCF_u2 unsigned short
37 #endif
38
39 #define ALLOC xmalloc
40 #define REALLOC xrealloc
41 #ifndef FREE
42 #define FREE(PTR) free(PTR)
43 #endif
44
45 #ifdef JCF_word
46 #define JCF_word JCF_u4
47 #endif
48
49 /* If we have both "scandir" and "alphasort", we can cache directory
50    listings to reduce the time taken to search the classpath.  */
51 #if defined(HAVE_SCANDIR) && defined(HAVE_ALPHASORT)
52 #define JCF_USE_SCANDIR 1
53 #else
54 #define JCF_USE_SCANDIR 0
55 #endif 
56
57 /* On case-insensitive file systems, we need to ensure that a request
58    to open a .java or .class file is honored only if the file to be
59    opened is of the exact case we are asking for. In other words, we
60    want to override the inherent case insensitivity of the underlying
61    file system. On other platforms, this macro becomes the vanilla
62    open() call.
63
64    If you want to add another host, add your define to the list below
65    (i.e. defined(WIN32) || defined(YOUR_HOST)) and add an host-specific
66    .c file to Make-lang.in similar to win32-host.c  */
67 #if defined(WIN32)
68 extern int
69 jcf_open_exact_case (const char* filename, int oflag);
70 #define JCF_OPEN_EXACT_CASE(X, Y) jcf_open_exact_case (X, Y)
71 #else
72 #define JCF_OPEN_EXACT_CASE open
73 #endif /* WIN32 */
74
75 struct JCF;
76 typedef int (*jcf_filbuf_t) (struct JCF*, int needed);
77
78 union cpool_entry GTY(()) {
79   jword GTY ((tag ("0"))) w;
80   tree GTY ((tag ("1"))) t;
81 };
82
83 #define cpool_entry_is_tree(tag) \
84   (tag & CONSTANT_ResolvedFlag) || tag == CONSTANT_Utf8
85
86 typedef struct CPool GTY(()) {
87   /* Available number of elements in the constants array, before it
88      must be re-allocated. */
89   int capacity;
90
91   /* The constant_pool_count. */
92   int           count;
93
94   uint8* GTY((length ("%h.count")))     tags;
95
96   union cpool_entry * GTY((length ("%h.count"),
97                            desc ("cpool_entry_is_tree (%1.tags%a)")))   data;
98 } CPool;
99
100 struct ZipDirectory;
101
102 /* JCF encapsulates the state of reading a Java Class File. */
103
104 typedef struct JCF GTY(()) {
105   unsigned char * GTY ((skip)) buffer;
106   unsigned char * GTY ((skip)) buffer_end;
107   unsigned char * GTY ((skip)) read_ptr;
108   unsigned char * GTY ((skip)) read_end;
109   unsigned int java_source : 1;
110   unsigned int right_zip : 1;
111   unsigned int finished : 1;
112   jcf_filbuf_t filbuf;
113   PTR GTY ((skip)) read_state;
114   const char *filename;
115   const char *classname;
116   /* Directory entry where it was found.  */
117   struct ZipDirectory * GTY ((skip)) zipd;
118   JCF_u2 access_flags;
119   JCF_u2 this_class;
120   JCF_u2 super_class;
121   CPool cpool;
122 } JCF;
123 /*typedef JCF*  JCF_FILE;*/
124
125 #define JCF_SEEN_IN_ZIP(JCF) ((JCF)->zipd != NULL)
126
127 /* The CPOOL macros take a (pointer to a) CPool.
128    The JPOOL macros take a (pointer to a) JCF.
129    Some of the latter should perhaps be deprecated or removed. */
130
131 #define CPOOL_COUNT(CPOOL) ((CPOOL)->count)
132 #define JPOOL_SIZE(JCF) CPOOL_COUNT(&(JCF)->cpool)
133 #define JPOOL_TAG(JCF, INDEX) ((JCF)->cpool.tags[INDEX])
134 /* The INDEX'th constant pool entry as a JCF_u4. */
135 #define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX].w)
136 #define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /*deprecated*/
137 /* The first uint16 of the INDEX'th constant pool entry. */
138 #define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX].w & 0xFFFF)
139 #define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
140 /* The second uint16 of the INDEX'th constant pool entry. */
141 #define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX].w >> 16)
142 #define JPOOL_USHORT2(JCF, INDEX) CPOOL_USHORT2(&(JCF)->cpool, INDEX)
143 #define JPOOL_LONG(JCF, INDEX) \
144   WORDS_TO_LONG (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
145 #define JPOOL_DOUBLE(JCF, INDEX) \
146   WORDS_TO_DOUBLE  (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
147 #ifndef JPOOL_UTF_LENGTH
148 #define JPOOL_UTF_LENGTH(JCF, INDEX) \
149   GET_u2 ((JCF)->buffer+JPOOL_UINT(JCF, INDEX))
150 #endif
151 #ifndef JPOOL_UTF_DATA
152 #define JPOOL_UTF_DATA(JCF, INDEX) \
153   ((JCF)->buffer+JPOOL_UINT(JCF, INDEX)+2)
154 #endif
155 #define JPOOL_INT(JCF, INDEX) (WORD_TO_INT(JPOOL_UINT (JCF, INDEX)))
156 #define JPOOL_FLOAT(JCF, INDEX) WORD_TO_FLOAT (JPOOL_UINT (JCF, INDEX))
157
158 #define CPOOL_INDEX_IN_RANGE(CPOOL, INDEX) \
159  ((INDEX) > 0 && (INDEX) < CPOOL_COUNT(CPOOL))
160
161 #define CPOOL_FINISH(CPOOL) {                   \
162     (CPOOL)->tags = 0;                          \
163     (CPOOL)->data = 0;                          \
164   }
165
166 #define JCF_FINISH(JCF) { \
167   CPOOL_FINISH(&(JCF)->cpool); \
168   if ((JCF)->buffer) FREE ((JCF)->buffer); \
169   if ((JCF)->filename) FREE ((char *) (JCF)->filename); \
170   if ((JCF)->classname) FREE ((char *) (JCF)->classname); \
171   (JCF)->finished = 1; }
172   
173 #define CPOOL_INIT(CPOOL) \
174   ((CPOOL)->capacity = 0, (CPOOL)->count = 0, (CPOOL)->tags = 0, (CPOOL)->data = 0)
175
176 #define CPOOL_REINIT(CPOOL) ((CPOOL)->count = 0)
177
178 #define JCF_ZERO(JCF)  \
179   ((JCF)->buffer = (JCF)->buffer_end = (JCF)->read_ptr = (JCF)->read_end = 0,\
180    (JCF)->read_state = 0, (JCF)->filename = (JCF)->classname = 0, \
181    CPOOL_INIT(&(JCF)->cpool), (JCF)->java_source = 0, (JCF)->zipd = 0, \
182    (JCF)->finished = 0)
183
184 /* Given that PTR points to a 2-byte unsigned integer in network
185    (big-endian) byte-order, return that integer. */
186 #define GET_u2(PTR) (((PTR)[0] << 8) | ((PTR)[1]))
187 /* Like GET_u2, but for little-endian format. */
188 #define GET_u2_le(PTR) (((PTR)[1] << 8) | ((PTR)[0]))
189
190 /* Given that PTR points to a 4-byte unsigned integer in network
191    (big-endian) byte-order, return that integer. */
192 #define GET_u4(PTR) (((JCF_u4)(PTR)[0] << 24) | ((JCF_u4)(PTR)[1] << 16) \
193   | ((JCF_u4)(PTR)[2] << 8) | ((JCF_u4)(PTR)[3]))
194 /* Like GET_u4, but for little-endian order. */
195 #define GET_u4_le(PTR) (((JCF_u4)(PTR)[3] << 24) | ((JCF_u4)(PTR)[2] << 16) \
196   | ((JCF_u4)(PTR)[1] << 8) | ((JCF_u4)(PTR)[0]))
197
198 /* Make sure there are COUNT bytes readable. */
199 #define JCF_FILL(JCF, COUNT) \
200   ((JCF)->read_end-(JCF)->read_ptr >= (COUNT) ? 0 : (*(JCF)->filbuf)(JCF, COUNT))
201 #define JCF_GETC(JCF) (JCF_FILL(JCF, 1) ? -1 : *(JCF)->read_ptr++)
202 #define JCF_READ(JCF, BUFFER, N) \
203     (memcpy (BUFFER, (JCF)->read_ptr, N), (JCF)->read_ptr += (N))
204 #define JCF_SKIP(JCF,N) ((JCF)->read_ptr += (N))
205 #define JCF_readu(JCF) (*(JCF)->read_ptr++)
206
207 /* Reads an unsigned 2-byte integer in network (big-endian) byte-order
208    from JCF.  Returns that integer.
209    Does not check for EOF (make sure to call JCF_FILL before-hand). */
210 #define JCF_readu2(JCF) ((JCF)->read_ptr += 2, GET_u2 ((JCF)->read_ptr-2))
211 #define JCF_readu2_le(JCF) ((JCF)->read_ptr += 2, GET_u2_le((JCF)->read_ptr-2))
212
213 /* Like JCF_readu2, but read a 4-byte unsigned integer. */
214 #define JCF_readu4(JCF) ((JCF)->read_ptr += 4, GET_u4 ((JCF)->read_ptr-4))
215 #define JCF_readu4_le(JCF) ((JCF)->read_ptr += 4, GET_u4_le((JCF)->read_ptr-4))
216
217 #define JCF_TELL(JCF) ((JCF)->read_ptr - (JCF)->buffer)
218 #define JCF_SEEK(JCF, POS) ((JCF)->read_ptr = (JCF)->buffer + (POS))
219
220 #define ACC_PUBLIC 0x0001
221 #define ACC_PRIVATE 0x0002
222 #define ACC_PROTECTED 0x0004
223 #define ACC_STATIC 0x0008
224 #define ACC_FINAL 0x0010
225 #define ACC_SYNCHRONIZED 0x0020
226 #define ACC_SUPER 0x0020
227 #define ACC_VOLATILE 0x0040
228 #define ACC_TRANSIENT 0x0080
229 #define ACC_NATIVE 0x0100
230 #define ACC_INTERFACE 0x0200
231 #define ACC_ABSTRACT 0x0400
232 #define ACC_STRICT 0x0800
233 /* "Invisible" refers to Miranda methods inserted into an abstract
234    #class.  It is also used in the runtime.  */
235 #define ACC_INVISIBLE 0x1000
236
237 #define ACC_VISIBILITY (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED)
238
239 #define CONSTANT_Class 7
240 #define CONSTANT_Fieldref 9
241 #define CONSTANT_Methodref 10
242 #define CONSTANT_InterfaceMethodref 11
243 #define CONSTANT_String 8
244 #define CONSTANT_Integer 3
245 #define CONSTANT_Float 4
246 #define CONSTANT_Long 5
247 #define CONSTANT_Double 6
248 #define CONSTANT_NameAndType 12
249 #define CONSTANT_Utf8 1
250 #define CONSTANT_Unicode 2
251
252 #define DEFAULT_CLASS_PATH "."
253
254 extern const char *find_class (const char *, int, JCF*, int);
255 extern const char *find_classfile (char *, JCF*, const char *);
256 extern int jcf_filbuf_from_stdio (JCF *jcf, int count);
257 extern int jcf_unexpected_eof (JCF*, int) ATTRIBUTE_NORETURN;
258
259 /* Extract a character from a Java-style Utf8 string.
260  * PTR points to the current character.
261  * LIMIT points to the end of the Utf8 string.
262  * PTR is incremented to point after the character that gets returned.
263  * On an error, -1 is returned. */
264 #define UTF8_GET(PTR, LIMIT) \
265   ((PTR) >= (LIMIT) ? -1 \
266    : *(PTR) < 128 ? *(PTR)++ \
267    : (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
268    ? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
269    : (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
270    && ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
271    ? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
272    : ((PTR)++, -1))
273
274 extern const char *jcf_write_base_directory;
275
276 /* Debug macros, for the front end */
277
278 extern int quiet_flag;
279 #ifdef VERBOSE_SKELETON
280 #undef SOURCE_FRONTEND_DEBUG
281 #define SOURCE_FRONTEND_DEBUG(X)                                \
282   {if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
283 #else
284 #define SOURCE_FRONTEND_DEBUG(X)
285 #endif
286
287 /* Declarations for dependency code.  */
288 extern void jcf_dependency_reset (void);
289 extern void jcf_dependency_set_target (const char *);
290 extern void jcf_dependency_add_target (const char *);
291 extern void jcf_dependency_set_dep_file (const char *);
292 extern void jcf_dependency_add_file (const char *, int);
293 extern void jcf_dependency_write (void);
294 extern void jcf_dependency_init (int);
295 extern void jcf_dependency_print_dummies (void);
296
297 /* Declarations for path handling code.  */
298 extern void jcf_path_init (void);
299 extern void jcf_path_classpath_arg (const char *);
300 extern void jcf_path_bootclasspath_arg (const char *);
301 extern void jcf_path_extdirs_arg (const char *);
302 extern void jcf_path_include_arg (const char *);
303 extern void jcf_path_seal (int);
304 extern void *jcf_path_start (void);
305 extern void *jcf_path_next (void *);
306 extern char *jcf_path_name (void *);
307 extern int jcf_path_is_zipfile (void *);
308 extern int jcf_path_is_system (void *);
309 extern int jcf_path_max_len (void);
310
311 #endif /* ! GCC_JCF_H */