OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [java/] [jcf.h] - Blame information for rev 294

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.