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, 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 */