gcc/java/jcf.h

   1 /* Utility macros to read Java(TM) .class files and byte codes.
   2
   3    Copyright (C) 1996, 1998 Free Software Foundation, Inc.
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with GNU CC; see the file COPYING.  If not, write to
  17 the Free Software Foundation, 59 Temple Place - Suite 330,
  18 Boston, MA 02111-1307, USA.
  19
  20 Java and all Java-based marks are trademarks or registered trademarks
  21 of Sun Microsystems, Inc. in the United States and other countries.
  22 The Free Software Foundation is independent of Sun Microsystems, Inc.  */
  23
  24 /* Written by Per Bothner <bothner@cygnus.com>, February 1996. */
  25
  26 #ifndef JCF_H
  27 #define JCF_H
  28 #include "javaop.h"
  29 #ifndef DEFUN
  30 #if defined (__STDC__)
  31 #define AND             ,
  32 #define PTR             void *
  33 #define DEFUN(name, arglist, args)      name(args)
  34 #else
  35 #define PTR             char *
  36 #define AND             ;
  37 #define DEFUN(name, arglist, args)      name arglist args;
  38 #define inline static
  39 #endif
  40 #endif /* !DEFUN */
  41
  42 #ifndef PROTO
  43 #if defined (__STDC__)
  44 #define PROTO(paramlist)    paramlist
  45 #else
  46 #define PROTO(paramlist)    ()
  47 #endif
  48 #endif
  49
  50 #ifndef JCF_u4
  51 #define JCF_u4 unsigned long
  52 #endif
  53 #ifndef JCF_u2
  54 #define JCF_u2 unsigned short
  55 #endif
  56
  57 #define ALLOC (void*)malloc
  58 #define REALLOC (void*)realloc
  59 #ifndef FREE
  60 #define FREE(PTR) free(PTR)
  61 #endif
  62
  63 #ifdef JCF_word
  64 #define JCF_word JCF_u4
  65 #endif
  66
  67 #define JCF_ZIP    1
  68 #define JCF_CLASS  2
  69 #define JCF_SOURCE 3
  70
  71 struct JCF;
  72 typedef int (*jcf_filbuf_t) PROTO ((struct JCF*, int needed));
  73
  74 typedef struct CPool {
  75   /* Available number of elements in the constants array, before it
  76      must be re-allocated. */
  77   int capacity;
  78
  79   /* The constant_pool_count. */
  80   int           count;
  81
  82   uint8*        tags;
  83
  84   jword*        data;
  85 } CPool;
  86
  87 /* JCF encapsulates the state of reading a Java Class File. */
  88
  89 typedef struct JCF {
  90   unsigned char *buffer;
  91   unsigned char *buffer_end;
  92   unsigned char *read_ptr;
  93   unsigned char *read_end;
  94   int seen_in_zip;
  95   int java_source;
  96   int  outofsynch;              /* Found a class file out of synch
  97                                    with the matching source file. */
  98   long zip_offset;
  99   jcf_filbuf_t filbuf;
 100   void *read_state;
 101   char *filename;
 102   char *classname;
 103   void *zipd;                   /* Directory entry where it was found */
 104   JCF_u2 access_flags, this_class, super_class;
 105   CPool cpool;
 106 } JCF;
 107 /*typedef JCF*  JCF_FILE;*/
 108
 109 /* The CPOOL macros take a (pointer to a) CPool.
 110    The JPOOL macros take a (pointer to a) JCF.
 111    Some of the latter should perhaps be deprecated or removed. */
 112
 113 #define CPOOL_COUNT(CPOOL) ((CPOOL)->count)
 114 #define JPOOL_SIZE(JCF) CPOOL_COUNT(&(JCF)->cpool)
 115 #define JPOOL_TAG(JCF, INDEX) ((JCF)->cpool.tags[INDEX])
 116 /* The INDEX'th constant pool entry as a JCF_u4. */
 117 #define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX])
 118 #define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /*deprecated*/
 119 /* The first uint16 of the INDEX'th constant pool entry. */
 120 #define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX] & 0xFFFF)
 121 #define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
 122 /* The second uint16 of the INDEX'th constant pool entry. */
 123 #define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX] >> 16)
 124 #define JPOOL_USHORT2(JCF, INDEX) CPOOL_USHORT2(&(JCF)->cpool, INDEX)
 125 #define JPOOL_LONG(JCF, INDEX) \
 126   WORDS_TO_LONG (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
 127 #define JPOOL_DOUBLE(JCF, INDEX) \
 128   WORDS_TO_DOUBLE  (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
 129 #ifndef JPOOL_UTF_LENGTH
 130 #define JPOOL_UTF_LENGTH(JCF, INDEX) \
 131   GET_u2 ((JCF)->buffer+JPOOL_UINT(JCF, INDEX))
 132 #endif
 133 #ifndef JPOOL_UTF_DATA
 134 #define JPOOL_UTF_DATA(JCF, INDEX) \
 135   ((JCF)->buffer+JPOOL_UINT(JCF, INDEX)+2)
 136 #endif
 137 #define JPOOL_INT(JCF, INDEX) ((jint) JPOOL_UINT (JCF, INDEX))
 138 #define JPOOL_FLOAT(JCF, INDEX) WORD_TO_FLOAT (JPOOL_UINT (JCF, INDEX))
 139
 140 #define CPOOL_INDEX_IN_RANGE(CPOOL, INDEX) \
 141  ((INDEX) > 0 && (INDEX) < CPOOL_COUNT(CPOOL))
 142
 143 #define CPOOL_FINISH(CPOOL) { \
 144   if ((CPOOL)->tags) FREE ((CPOOL)->tags); \
 145   if ((CPOOL)->data) FREE ((CPOOL)->data); }
 146
 147 #define JCF_FINISH(JCF) { \
 148   CPOOL_FINISH(&(JCF)->cpool); \
 149   if ((JCF)->buffer) FREE ((JCF)->buffer); \
 150   if ((JCF)->filename) FREE ((JCF)->filename); \
 151   if ((JCF)->classname) FREE ((JCF)->classname); }
 152
 153 #define CPOOL_INIT(CPOOL) \
 154   ((CPOOL)->capacity = 0, (CPOOL)->count = 0, (CPOOL)->tags = 0, (CPOOL)->data = 0)
 155
 156 #define CPOOL_REINIT(CPOOL) ((CPOOL)->count = 0)
 157
 158 #define JCF_ZERO(JCF)  \
 159   ((JCF)->buffer = (JCF)->buffer_end = (JCF)->read_ptr = (JCF)->read_end = 0,\
 160    (JCF)->read_state = 0, (JCF)->filename = (JCF)->classname = 0, \
 161    CPOOL_INIT(&(JCF)->cpool), (JCF)->java_source = 0)
 162
 163 /* Given that PTR points to a 2-byte unsigned integer in network
 164    (big-endian) byte-order, return that integer. */
 165 #define GET_u2(PTR) (((PTR)[0] << 8) | ((PTR)[1]))
 166 /* Like GET_u2, but for little-endian format. */
 167 #define GET_u2_le(PTR) (((PTR)[1] << 8) | ((PTR)[0]))
 168
 169 /* Given that PTR points to a 4-byte unsigned integer in network
 170    (big-endian) byte-order, return that integer. */
 171 #define GET_u4(PTR) (((JCF_u4)(PTR)[0] << 24) | ((JCF_u4)(PTR)[1] << 16) \
 172   | ((JCF_u4)(PTR)[2] << 8) | ((JCF_u4)(PTR)[3]))
 173 /* Like GET_u4, but for little-endian order. */
 174 #define GET_u4_le(PTR) (((JCF_u4)(PTR)[3] << 24) | ((JCF_u4)(PTR)[2] << 16) \
 175   | ((JCF_u4)(PTR)[1] << 8) | ((JCF_u4)(PTR)[0]))
 176
 177 /* Make sure there are COUNT bytes readable. */
 178 #define JCF_FILL(JCF, COUNT) \
 179   ((JCF)->read_end-(JCF)->read_ptr >= (COUNT) ? 0 : (*(JCF)->filbuf)(JCF, COUNT))
 180 #define JCF_GETC(JCF) (JCF_FILL(JCF, 1) ? -1 : *(JCF)->read_ptr++)
 181 #define JCF_READ(JCF, BUFFER, N) \
 182     (memcpy (BUFFER, (JCF)->read_ptr, N), (JCF)->read_ptr += (N))
 183 #define JCF_SKIP(JCF,N) ((JCF)->read_ptr += (N))
 184 #define JCF_readu(JCF) (*(JCF)->read_ptr++)
 185
 186 /* Reads an unsigned 2-byte integer in network (big-endian) byte-order
 187    from JCF.  Returns that integer.
 188    Does not check for EOF (make sure to call JCF_FILL before-hand). */
 189 #define JCF_readu2(JCF) ((JCF)->read_ptr += 2, GET_u2 ((JCF)->read_ptr-2))
 190 #define JCF_readu2_le(JCF) ((JCF)->read_ptr += 2, GET_u2_le((JCF)->read_ptr-2))
 191
 192 /* Like JCF_readu2, but read a 4-byte unsigned integer. */
 193 #define JCF_readu4(JCF) ((JCF)->read_ptr += 4, GET_u4 ((JCF)->read_ptr-4))
 194 #define JCF_readu4_le(JCF) ((JCF)->read_ptr += 4, GET_u4_le((JCF)->read_ptr-4))
 195
 196 #define JCF_TELL(JCF) ((JCF)->read_ptr - (JCF)->buffer)
 197 #define JCF_SEEK(JCF, POS) ((JCF)->read_ptr = (JCF)->buffer + (POS))
 198
 199 #define ACC_PUBLIC 0x0001
 200 #define ACC_PRIVATE 0x0002
 201 #define ACC_PROTECTED 0x0004
 202 #define ACC_STATIC 0x0008
 203 #define ACC_FINAL 0x0010
 204 #define ACC_SYNCHRONIZED 0x0020
 205 #define ACC_SUPER 0x0020
 206 #define ACC_VOLATILE 0x0040
 207 #define ACC_TRANSIENT 0x0080
 208 #define ACC_NATIVE 0x0100
 209 #define ACC_INTERFACE 0x0200
 210 #define ACC_ABSTRACT 0x0400
 211
 212 #define CONSTANT_Class 7
 213 #define CONSTANT_Fieldref 9
 214 #define CONSTANT_Methodref 10
 215 #define CONSTANT_InterfaceMethodref 11
 216 #define CONSTANT_String 8
 217 #define CONSTANT_Integer 3
 218 #define CONSTANT_Float 4
 219 #define CONSTANT_Long 5
 220 #define CONSTANT_Double 6
 221 #define CONSTANT_NameAndType 12
 222 #define CONSTANT_Utf8 1
 223 #define CONSTANT_Unicode 2
 224
 225 #define DEFAULT_CLASS_PATH "."
 226
 227 extern char *find_class PROTO ((const char *, int, JCF*, int));
 228 extern char *find_classfile PROTO ((char *, JCF*, char *));
 229 extern int jcf_filbuf_from_stdio PROTO ((JCF *jcf, int count));
 230 extern void jcf_out_of_synch PROTO((JCF *));
 231 extern int jcf_unexpected_eof PROTO ((JCF*, int));
 232
 233 /* Extract a character from a Java-style Utf8 string.
 234  * PTR points to the current character.
 235  * LIMIT points to the end of the Utf8 string.
 236  * PTR is incremented to point after the character thta gets returns.
 237  * On an error, -1 is returned. */
 238 #define UTF8_GET(PTR, LIMIT) \
 239   ((PTR) >= (LIMIT) ? -1 \
 240    : *(PTR) < 128 ? *(PTR)++ \
 241    : (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
 242    ? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
 243    : (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
 244    && ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
 245    ? (((PTR)[-3]&0x1F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
 246    : ((PTR)++, -1))
 247
 248 /* Debug macros, for the front end */
 249
 250 extern int quiet_flag;
 251 #ifdef SOURCE_FRONTEND_DEBUG
 252 #undef SOURCE_FRONTEND_DEBUG
 253 #define SOURCE_FRONTEND_DEBUG(X)                                \
 254   {if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
 255 #else
 256 #define SOURCE_FRONTEND_DEBUG(X)
 257 #endif
 258
 259 /* Declarations for dependency code.  */
 260 extern void jcf_dependency_reset PROTO ((void));
 261 extern void jcf_dependency_set_target PROTO ((char *));
 262 extern void jcf_dependency_add_target PROTO ((char *));
 263 extern void jcf_dependency_set_dep_file PROTO ((const char *));
 264 extern void jcf_dependency_add_file PROTO ((const char *, int));
 265 extern void jcf_dependency_write PROTO ((void));
 266 extern void jcf_dependency_init PROTO ((int));
 267
 268 /* Declarations for path handling code.  */
 269 extern void jcf_path_init PROTO ((void));
 270 extern void jcf_path_classpath_arg PROTO ((char *));
 271 extern void jcf_path_CLASSPATH_arg PROTO ((char *));
 272 extern void jcf_path_include_arg PROTO ((char *));
 273 extern void jcf_path_seal PROTO ((void));
 274 extern void *jcf_path_start PROTO ((void));
 275 extern void *jcf_path_next PROTO ((void *));
 276 extern char *jcf_path_name PROTO ((void *));
 277 extern int jcf_path_is_zipfile PROTO ((void *));
 278 extern int jcf_path_is_system PROTO ((void *));
 279 extern int jcf_path_max_len PROTO ((void));
 280
 281 #endif