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 struct JCF;
  67 typedef int (*jcf_filbuf_t) PARAMS ((struct JCF*, int needed));
  68
  69 union cpool_entry GTY(()) {
  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 CPool GTY(()) {
  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 JCF GTY(()) {
  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   int java_source : 1;
 101   int right_zip : 1;
 102   int finished : 1;
 103   jcf_filbuf_t filbuf;
 104   PTR GTY ((skip (""))) read_state;
 105   const char *filename;
 106   const char *classname;
 107   /* Directory entry where it was found.  */
 108   struct ZipDirectory * GTY ((skip (""))) zipd;
 109   JCF_u2 access_flags;
 110   JCF_u2 this_class;
 111   JCF_u2 super_class;
 112   CPool cpool;
 113 } JCF;
 114 /*typedef JCF*  JCF_FILE;*/
 115
 116 #define JCF_SEEN_IN_ZIP(JCF) ((JCF)->zipd != NULL)
 117
 118 /* The CPOOL macros take a (pointer to a) CPool.
 119    The JPOOL macros take a (pointer to a) JCF.
 120    Some of the latter should perhaps be deprecated or removed. */
 121
 122 #define CPOOL_COUNT(CPOOL) ((CPOOL)->count)
 123 #define JPOOL_SIZE(JCF) CPOOL_COUNT(&(JCF)->cpool)
 124 #define JPOOL_TAG(JCF, INDEX) ((JCF)->cpool.tags[INDEX])
 125 /* The INDEX'th constant pool entry as a JCF_u4. */
 126 #define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX].w)
 127 #define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /*deprecated*/
 128 /* The first uint16 of the INDEX'th constant pool entry. */
 129 #define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX].w & 0xFFFF)
 130 #define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
 131 /* The second uint16 of the INDEX'th constant pool entry. */
 132 #define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX].w >> 16)
 133 #define JPOOL_USHORT2(JCF, INDEX) CPOOL_USHORT2(&(JCF)->cpool, INDEX)
 134 #define JPOOL_LONG(JCF, INDEX) \
 135   WORDS_TO_LONG (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
 136 #define JPOOL_DOUBLE(JCF, INDEX) \
 137   WORDS_TO_DOUBLE  (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
 138 #ifndef JPOOL_UTF_LENGTH
 139 #define JPOOL_UTF_LENGTH(JCF, INDEX) \
 140   GET_u2 ((JCF)->buffer+JPOOL_UINT(JCF, INDEX))
 141 #endif
 142 #ifndef JPOOL_UTF_DATA
 143 #define JPOOL_UTF_DATA(JCF, INDEX) \
 144   ((JCF)->buffer+JPOOL_UINT(JCF, INDEX)+2)
 145 #endif
 146 #define JPOOL_INT(JCF, INDEX) (WORD_TO_INT(JPOOL_UINT (JCF, INDEX)))
 147 #define JPOOL_FLOAT(JCF, INDEX) WORD_TO_FLOAT (JPOOL_UINT (JCF, INDEX))
 148
 149 #define CPOOL_INDEX_IN_RANGE(CPOOL, INDEX) \
 150  ((INDEX) > 0 && (INDEX) < CPOOL_COUNT(CPOOL))
 151
 152 #define CPOOL_FINISH(CPOOL) {                   \
 153     (CPOOL)->tags = 0;                          \
 154     (CPOOL)->data = 0;                          \
 155   }
 156
 157 #define JCF_FINISH(JCF) { \
 158   CPOOL_FINISH(&(JCF)->cpool); \
 159   if ((JCF)->buffer) FREE ((JCF)->buffer); \
 160   if ((JCF)->filename) FREE ((char *) (JCF)->filename); \
 161   if ((JCF)->classname) FREE ((char *) (JCF)->classname); \
 162   (JCF)->finished = 1; }
 163
 164 #define CPOOL_INIT(CPOOL) \
 165   ((CPOOL)->capacity = 0, (CPOOL)->count = 0, (CPOOL)->tags = 0, (CPOOL)->data = 0)
 166
 167 #define CPOOL_REINIT(CPOOL) ((CPOOL)->count = 0)
 168
 169 #define JCF_ZERO(JCF)  \
 170   ((JCF)->buffer = (JCF)->buffer_end = (JCF)->read_ptr = (JCF)->read_end = 0,\
 171    (JCF)->read_state = 0, (JCF)->filename = (JCF)->classname = 0, \
 172    CPOOL_INIT(&(JCF)->cpool), (JCF)->java_source = 0, (JCF)->zipd = 0, \
 173    (JCF)->finished = 0)
 174
 175 /* Given that PTR points to a 2-byte unsigned integer in network
 176    (big-endian) byte-order, return that integer. */
 177 #define GET_u2(PTR) (((PTR)[0] << 8) | ((PTR)[1]))
 178 /* Like GET_u2, but for little-endian format. */
 179 #define GET_u2_le(PTR) (((PTR)[1] << 8) | ((PTR)[0]))
 180
 181 /* Given that PTR points to a 4-byte unsigned integer in network
 182    (big-endian) byte-order, return that integer. */
 183 #define GET_u4(PTR) (((JCF_u4)(PTR)[0] << 24) | ((JCF_u4)(PTR)[1] << 16) \
 184   | ((JCF_u4)(PTR)[2] << 8) | ((JCF_u4)(PTR)[3]))
 185 /* Like GET_u4, but for little-endian order. */
 186 #define GET_u4_le(PTR) (((JCF_u4)(PTR)[3] << 24) | ((JCF_u4)(PTR)[2] << 16) \
 187   | ((JCF_u4)(PTR)[1] << 8) | ((JCF_u4)(PTR)[0]))
 188
 189 /* Make sure there are COUNT bytes readable. */
 190 #define JCF_FILL(JCF, COUNT) \
 191   ((JCF)->read_end-(JCF)->read_ptr >= (COUNT) ? 0 : (*(JCF)->filbuf)(JCF, COUNT))
 192 #define JCF_GETC(JCF) (JCF_FILL(JCF, 1) ? -1 : *(JCF)->read_ptr++)
 193 #define JCF_READ(JCF, BUFFER, N) \
 194     (memcpy (BUFFER, (JCF)->read_ptr, N), (JCF)->read_ptr += (N))
 195 #define JCF_SKIP(JCF,N) ((JCF)->read_ptr += (N))
 196 #define JCF_readu(JCF) (*(JCF)->read_ptr++)
 197
 198 /* Reads an unsigned 2-byte integer in network (big-endian) byte-order
 199    from JCF.  Returns that integer.
 200    Does not check for EOF (make sure to call JCF_FILL before-hand). */
 201 #define JCF_readu2(JCF) ((JCF)->read_ptr += 2, GET_u2 ((JCF)->read_ptr-2))
 202 #define JCF_readu2_le(JCF) ((JCF)->read_ptr += 2, GET_u2_le((JCF)->read_ptr-2))
 203
 204 /* Like JCF_readu2, but read a 4-byte unsigned integer. */
 205 #define JCF_readu4(JCF) ((JCF)->read_ptr += 4, GET_u4 ((JCF)->read_ptr-4))
 206 #define JCF_readu4_le(JCF) ((JCF)->read_ptr += 4, GET_u4_le((JCF)->read_ptr-4))
 207
 208 #define JCF_TELL(JCF) ((JCF)->read_ptr - (JCF)->buffer)
 209 #define JCF_SEEK(JCF, POS) ((JCF)->read_ptr = (JCF)->buffer + (POS))
 210
 211 #define ACC_PUBLIC 0x0001
 212 #define ACC_PRIVATE 0x0002
 213 #define ACC_PROTECTED 0x0004
 214 #define ACC_STATIC 0x0008
 215 #define ACC_FINAL 0x0010
 216 #define ACC_SYNCHRONIZED 0x0020
 217 #define ACC_SUPER 0x0020
 218 #define ACC_VOLATILE 0x0040
 219 #define ACC_TRANSIENT 0x0080
 220 #define ACC_NATIVE 0x0100
 221 #define ACC_INTERFACE 0x0200
 222 #define ACC_ABSTRACT 0x0400
 223 #define ACC_STRICT 0x0800
 224
 225 #define ACC_VISIBILITY (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED)
 226
 227 #define CONSTANT_Class 7
 228 #define CONSTANT_Fieldref 9
 229 #define CONSTANT_Methodref 10
 230 #define CONSTANT_InterfaceMethodref 11
 231 #define CONSTANT_String 8
 232 #define CONSTANT_Integer 3
 233 #define CONSTANT_Float 4
 234 #define CONSTANT_Long 5
 235 #define CONSTANT_Double 6
 236 #define CONSTANT_NameAndType 12
 237 #define CONSTANT_Utf8 1
 238 #define CONSTANT_Unicode 2
 239
 240 #define DEFAULT_CLASS_PATH "."
 241
 242 extern const char *find_class (const char *, int, JCF*, int);
 243 extern const char *find_classfile (char *, JCF*, const char *);
 244 extern int jcf_filbuf_from_stdio (JCF *jcf, int count);
 245 extern int jcf_unexpected_eof (JCF*, int) ATTRIBUTE_NORETURN;
 246
 247 /* Extract a character from a Java-style Utf8 string.
 248  * PTR points to the current character.
 249  * LIMIT points to the end of the Utf8 string.
 250  * PTR is incremented to point after the character that gets returned.
 251  * On an error, -1 is returned. */
 252 #define UTF8_GET(PTR, LIMIT) \
 253   ((PTR) >= (LIMIT) ? -1 \
 254    : *(PTR) < 128 ? *(PTR)++ \
 255    : (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
 256    ? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
 257    : (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
 258    && ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
 259    ? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
 260    : ((PTR)++, -1))
 261
 262 extern char *jcf_write_base_directory;
 263
 264 /* Debug macros, for the front end */
 265
 266 extern int quiet_flag;
 267 #ifdef VERBOSE_SKELETON
 268 #undef SOURCE_FRONTEND_DEBUG
 269 #define SOURCE_FRONTEND_DEBUG(X)                                \
 270   {if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
 271 #else
 272 #define SOURCE_FRONTEND_DEBUG(X)
 273 #endif
 274
 275 /* Declarations for dependency code.  */
 276 extern void jcf_dependency_reset (void);
 277 extern void jcf_dependency_set_target (const char *);
 278 extern void jcf_dependency_add_target (const char *);
 279 extern void jcf_dependency_set_dep_file (const char *);
 280 extern void jcf_dependency_add_file (const char *, int);
 281 extern void jcf_dependency_write (void);
 282 extern void jcf_dependency_init (int);
 283 extern void jcf_dependency_print_dummies (void);
 284
 285 /* Declarations for path handling code.  */
 286 extern void jcf_path_init (void);
 287 extern void jcf_path_classpath_arg (const char *);
 288 extern void jcf_path_bootclasspath_arg (const char *);
 289 extern void jcf_path_extdirs_arg (const char *);
 290 extern void jcf_path_include_arg (const char *);
 291 extern void jcf_path_seal (int);
 292 extern void *jcf_path_start (void);
 293 extern void *jcf_path_next (void *);
 294 extern char *jcf_path_name (void *);
 295 extern int jcf_path_is_zipfile (void *);
 296 extern int jcf_path_is_system (void *);
 297 extern int jcf_path_max_len (void);
 298
 299 #endif /* ! GCC_JCF_H */