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, file name components must be
  58    compared using "strcasecmp", if available, instead of "strcmp".
  59    Assumes "config.h" has already been included.  */
  60 #if defined (HAVE_DOS_BASED_FILE_SYSTEM) && defined (HAVE_STRCASECMP)
  61 #define COMPARE_FILENAMES(X, Y) strcasecmp ((X), (Y))
  62 #else
  63 #define COMPARE_FILENAMES(X, Y) strcmp ((X), (Y))
  64 #endif
  65
  66 /* On case-insensitive file systems, we need to ensure that a request
  67    to open a .java or .class file is honored only if the file to be
  68    opened is of the exact case we are asking for. In other words, we
  69    want to override the inherent case insensitivity of the underlying
  70    file system. On other platforms, this macro becomes the vanilla
  71    open() call.
  72
  73    If you want to add another host, add your define to the list below
  74    (i.e. defined(WIN32) || defined(YOUR_HOST)) and add an host-specific
  75    .c file to Make-lang.in similar to win32-host.c  */
  76 #if defined(WIN32)
  77 extern int
  78 jcf_open_exact_case (const char* filename, int oflag);
  79 #define JCF_OPEN_EXACT_CASE(X, Y) jcf_open_exact_case (X, Y)
  80 #else
  81 #define JCF_OPEN_EXACT_CASE open
  82 #endif /* WIN32 */
  83
  84 struct JCF;
  85 typedef int (*jcf_filbuf_t) PARAMS ((struct JCF*, int needed));
  86
  87 union cpool_entry GTY(()) {
  88   jword GTY ((tag ("0"))) w;
  89   tree GTY ((tag ("1"))) t;
  90 };
  91
  92 #define cpool_entry_is_tree(tag) \
  93   (tag & CONSTANT_ResolvedFlag) || tag == CONSTANT_Utf8
  94
  95 typedef struct CPool GTY(()) {
  96   /* Available number of elements in the constants array, before it
  97      must be re-allocated. */
  98   int capacity;
  99
 100   /* The constant_pool_count. */
 101   int           count;
 102
 103   uint8* GTY((length ("%h.count")))     tags;
 104
 105   union cpool_entry * GTY((length ("%h.count"),
 106                            desc ("cpool_entry_is_tree (%1.tags%a)")))   data;
 107 } CPool;
 108
 109 struct ZipDirectory;
 110
 111 /* JCF encapsulates the state of reading a Java Class File. */
 112
 113 typedef struct JCF GTY(()) {
 114   unsigned char * GTY ((skip (""))) buffer;
 115   unsigned char * GTY ((skip (""))) buffer_end;
 116   unsigned char * GTY ((skip (""))) read_ptr;
 117   unsigned char * GTY ((skip (""))) read_end;
 118   int java_source : 1;
 119   int right_zip : 1;
 120   int finished : 1;
 121   jcf_filbuf_t filbuf;
 122   PTR GTY ((skip (""))) read_state;
 123   const char *filename;
 124   const char *classname;
 125   /* Directory entry where it was found.  */
 126   struct ZipDirectory * GTY ((skip (""))) zipd;
 127   JCF_u2 access_flags;
 128   JCF_u2 this_class;
 129   JCF_u2 super_class;
 130   CPool cpool;
 131 } JCF;
 132 /*typedef JCF*  JCF_FILE;*/
 133
 134 #define JCF_SEEN_IN_ZIP(JCF) ((JCF)->zipd != NULL)
 135
 136 /* The CPOOL macros take a (pointer to a) CPool.
 137    The JPOOL macros take a (pointer to a) JCF.
 138    Some of the latter should perhaps be deprecated or removed. */
 139
 140 #define CPOOL_COUNT(CPOOL) ((CPOOL)->count)
 141 #define JPOOL_SIZE(JCF) CPOOL_COUNT(&(JCF)->cpool)
 142 #define JPOOL_TAG(JCF, INDEX) ((JCF)->cpool.tags[INDEX])
 143 /* The INDEX'th constant pool entry as a JCF_u4. */
 144 #define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX].w)
 145 #define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /*deprecated*/
 146 /* The first uint16 of the INDEX'th constant pool entry. */
 147 #define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX].w & 0xFFFF)
 148 #define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
 149 /* The second uint16 of the INDEX'th constant pool entry. */
 150 #define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX].w >> 16)
 151 #define JPOOL_USHORT2(JCF, INDEX) CPOOL_USHORT2(&(JCF)->cpool, INDEX)
 152 #define JPOOL_LONG(JCF, INDEX) \
 153   WORDS_TO_LONG (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
 154 #define JPOOL_DOUBLE(JCF, INDEX) \
 155   WORDS_TO_DOUBLE  (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
 156 #ifndef JPOOL_UTF_LENGTH
 157 #define JPOOL_UTF_LENGTH(JCF, INDEX) \
 158   GET_u2 ((JCF)->buffer+JPOOL_UINT(JCF, INDEX))
 159 #endif
 160 #ifndef JPOOL_UTF_DATA
 161 #define JPOOL_UTF_DATA(JCF, INDEX) \
 162   ((JCF)->buffer+JPOOL_UINT(JCF, INDEX)+2)
 163 #endif
 164 #define JPOOL_INT(JCF, INDEX) (WORD_TO_INT(JPOOL_UINT (JCF, INDEX)))
 165 #define JPOOL_FLOAT(JCF, INDEX) WORD_TO_FLOAT (JPOOL_UINT (JCF, INDEX))
 166
 167 #define CPOOL_INDEX_IN_RANGE(CPOOL, INDEX) \
 168  ((INDEX) > 0 && (INDEX) < CPOOL_COUNT(CPOOL))
 169
 170 #define CPOOL_FINISH(CPOOL) {                   \
 171     (CPOOL)->tags = 0;                          \
 172     (CPOOL)->data = 0;                          \
 173   }
 174
 175 #define JCF_FINISH(JCF) { \
 176   CPOOL_FINISH(&(JCF)->cpool); \
 177   if ((JCF)->buffer) FREE ((JCF)->buffer); \
 178   if ((JCF)->filename) FREE ((char *) (JCF)->filename); \
 179   if ((JCF)->classname) FREE ((char *) (JCF)->classname); \
 180   (JCF)->finished = 1; }
 181
 182 #define CPOOL_INIT(CPOOL) \
 183   ((CPOOL)->capacity = 0, (CPOOL)->count = 0, (CPOOL)->tags = 0, (CPOOL)->data = 0)
 184
 185 #define CPOOL_REINIT(CPOOL) ((CPOOL)->count = 0)
 186
 187 #define JCF_ZERO(JCF)  \
 188   ((JCF)->buffer = (JCF)->buffer_end = (JCF)->read_ptr = (JCF)->read_end = 0,\
 189    (JCF)->read_state = 0, (JCF)->filename = (JCF)->classname = 0, \
 190    CPOOL_INIT(&(JCF)->cpool), (JCF)->java_source = 0, (JCF)->zipd = 0, \
 191    (JCF)->finished = 0)
 192
 193 /* Given that PTR points to a 2-byte unsigned integer in network
 194    (big-endian) byte-order, return that integer. */
 195 #define GET_u2(PTR) (((PTR)[0] << 8) | ((PTR)[1]))
 196 /* Like GET_u2, but for little-endian format. */
 197 #define GET_u2_le(PTR) (((PTR)[1] << 8) | ((PTR)[0]))
 198
 199 /* Given that PTR points to a 4-byte unsigned integer in network
 200    (big-endian) byte-order, return that integer. */
 201 #define GET_u4(PTR) (((JCF_u4)(PTR)[0] << 24) | ((JCF_u4)(PTR)[1] << 16) \
 202   | ((JCF_u4)(PTR)[2] << 8) | ((JCF_u4)(PTR)[3]))
 203 /* Like GET_u4, but for little-endian order. */
 204 #define GET_u4_le(PTR) (((JCF_u4)(PTR)[3] << 24) | ((JCF_u4)(PTR)[2] << 16) \
 205   | ((JCF_u4)(PTR)[1] << 8) | ((JCF_u4)(PTR)[0]))
 206
 207 /* Make sure there are COUNT bytes readable. */
 208 #define JCF_FILL(JCF, COUNT) \
 209   ((JCF)->read_end-(JCF)->read_ptr >= (COUNT) ? 0 : (*(JCF)->filbuf)(JCF, COUNT))
 210 #define JCF_GETC(JCF) (JCF_FILL(JCF, 1) ? -1 : *(JCF)->read_ptr++)
 211 #define JCF_READ(JCF, BUFFER, N) \
 212     (memcpy (BUFFER, (JCF)->read_ptr, N), (JCF)->read_ptr += (N))
 213 #define JCF_SKIP(JCF,N) ((JCF)->read_ptr += (N))
 214 #define JCF_readu(JCF) (*(JCF)->read_ptr++)
 215
 216 /* Reads an unsigned 2-byte integer in network (big-endian) byte-order
 217    from JCF.  Returns that integer.
 218    Does not check for EOF (make sure to call JCF_FILL before-hand). */
 219 #define JCF_readu2(JCF) ((JCF)->read_ptr += 2, GET_u2 ((JCF)->read_ptr-2))
 220 #define JCF_readu2_le(JCF) ((JCF)->read_ptr += 2, GET_u2_le((JCF)->read_ptr-2))
 221
 222 /* Like JCF_readu2, but read a 4-byte unsigned integer. */
 223 #define JCF_readu4(JCF) ((JCF)->read_ptr += 4, GET_u4 ((JCF)->read_ptr-4))
 224 #define JCF_readu4_le(JCF) ((JCF)->read_ptr += 4, GET_u4_le((JCF)->read_ptr-4))
 225
 226 #define JCF_TELL(JCF) ((JCF)->read_ptr - (JCF)->buffer)
 227 #define JCF_SEEK(JCF, POS) ((JCF)->read_ptr = (JCF)->buffer + (POS))
 228
 229 #define ACC_PUBLIC 0x0001
 230 #define ACC_PRIVATE 0x0002
 231 #define ACC_PROTECTED 0x0004
 232 #define ACC_STATIC 0x0008
 233 #define ACC_FINAL 0x0010
 234 #define ACC_SYNCHRONIZED 0x0020
 235 #define ACC_SUPER 0x0020
 236 #define ACC_VOLATILE 0x0040
 237 #define ACC_TRANSIENT 0x0080
 238 #define ACC_NATIVE 0x0100
 239 #define ACC_INTERFACE 0x0200
 240 #define ACC_ABSTRACT 0x0400
 241 #define ACC_STRICT 0x0800
 242
 243 #define ACC_VISIBILITY (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED)
 244
 245 #define CONSTANT_Class 7
 246 #define CONSTANT_Fieldref 9
 247 #define CONSTANT_Methodref 10
 248 #define CONSTANT_InterfaceMethodref 11
 249 #define CONSTANT_String 8
 250 #define CONSTANT_Integer 3
 251 #define CONSTANT_Float 4
 252 #define CONSTANT_Long 5
 253 #define CONSTANT_Double 6
 254 #define CONSTANT_NameAndType 12
 255 #define CONSTANT_Utf8 1
 256 #define CONSTANT_Unicode 2
 257
 258 #define DEFAULT_CLASS_PATH "."
 259
 260 extern const char *find_class (const char *, int, JCF*, int);
 261 extern const char *find_classfile (char *, JCF*, const char *);
 262 extern int jcf_filbuf_from_stdio (JCF *jcf, int count);
 263 extern int jcf_unexpected_eof (JCF*, int) ATTRIBUTE_NORETURN;
 264
 265 /* Extract a character from a Java-style Utf8 string.
 266  * PTR points to the current character.
 267  * LIMIT points to the end of the Utf8 string.
 268  * PTR is incremented to point after the character that gets returned.
 269  * On an error, -1 is returned. */
 270 #define UTF8_GET(PTR, LIMIT) \
 271   ((PTR) >= (LIMIT) ? -1 \
 272    : *(PTR) < 128 ? *(PTR)++ \
 273    : (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
 274    ? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
 275    : (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
 276    && ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
 277    ? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
 278    : ((PTR)++, -1))
 279
 280 extern const char *jcf_write_base_directory;
 281
 282 /* Debug macros, for the front end */
 283
 284 extern int quiet_flag;
 285 #ifdef VERBOSE_SKELETON
 286 #undef SOURCE_FRONTEND_DEBUG
 287 #define SOURCE_FRONTEND_DEBUG(X)                                \
 288   {if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
 289 #else
 290 #define SOURCE_FRONTEND_DEBUG(X)
 291 #endif
 292
 293 /* Declarations for dependency code.  */
 294 extern void jcf_dependency_reset (void);
 295 extern void jcf_dependency_set_target (const char *);
 296 extern void jcf_dependency_add_target (const char *);
 297 extern void jcf_dependency_set_dep_file (const char *);
 298 extern void jcf_dependency_add_file (const char *, int);
 299 extern void jcf_dependency_write (void);
 300 extern void jcf_dependency_init (int);
 301 extern void jcf_dependency_print_dummies (void);
 302
 303 /* Declarations for path handling code.  */
 304 extern void jcf_path_init (void);
 305 extern void jcf_path_classpath_arg (const char *);
 306 extern void jcf_path_bootclasspath_arg (const char *);
 307 extern void jcf_path_extdirs_arg (const char *);
 308 extern void jcf_path_include_arg (const char *);
 309 extern void jcf_path_seal (int);
 310 extern void *jcf_path_start (void);
 311 extern void *jcf_path_next (void *);
 312 extern char *jcf_path_name (void *);
 313 extern int jcf_path_is_zipfile (void *);
 314 extern int jcf_path_is_system (void *);
 315 extern int jcf_path_max_len (void);
 316
 317 #endif /* ! GCC_JCF_H */