[thirdparty/gcc.git] / gcc / java / jcf.h

/* Utility macros to read Java(TM) .class files and byte codes.
   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   2006, 2007, 2008 Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  

Java and all Java-based marks are trademarks or registered trademarks
of Sun Microsystems, Inc. in the United States and other countries.
The Free Software Foundation is independent of Sun Microsystems, Inc.  */

/* Written by Per Bothner <bothner@cygnus.com>, February 1996. */

#ifndef GCC_JCF_H
#define GCC_JCF_H
#include "javaop.h"

#ifndef JCF_u4
#define JCF_u4 unsigned long
#endif
#ifndef JCF_u2
#define JCF_u2 unsigned short
#endif

#define ALLOC xmalloc
#define REALLOC xrealloc
#ifndef FREE
#define FREE(PTR) free(PTR)
#endif

#ifdef JCF_word
#define JCF_word JCF_u4
#endif

/* On case-insensitive file systems, we need to ensure that a request
   to open a .java or .class file is honored only if the file to be
   opened is of the exact case we are asking for. In other words, we
   want to override the inherent case insensitivity of the underlying
   file system. On other platforms, this macro becomes the vanilla
   open() call.

   If you want to add another host, add your define to the list below
   (i.e. defined(WIN32) || defined(YOUR_HOST)) and add a host-specific
   .c file to Make-lang.in similar to win32-host.c.  */
#if defined(WIN32)
extern int
jcf_open_exact_case (const char* filename, int oflag);
#define JCF_OPEN_EXACT_CASE(X, Y) jcf_open_exact_case (X, Y)
#else
#define JCF_OPEN_EXACT_CASE open
#endif /* WIN32 */

struct JCF;
typedef int (*jcf_filbuf_t) (struct JCF*, int needed);

union cpool_entry GTY(()) {
  jword GTY ((tag ("0"))) w;
  tree GTY ((tag ("1"))) t;
};

#define cpool_entry_is_tree(tag) \
  (tag & CONSTANT_ResolvedFlag) || tag == CONSTANT_Utf8

typedef struct CPool GTY(()) {
  /* Available number of elements in the constants array, before it
     must be re-allocated. */
  int capacity;

  /* The constant_pool_count. */
  int		count;

  uint8* GTY((length ("%h.count")))	tags;

  union cpool_entry * GTY((length ("%h.count"),
			   desc ("cpool_entry_is_tree (%1.tags%a)")))	data;
} CPool;

struct ZipDirectory;

/* JCF encapsulates the state of reading a Java Class File. */

typedef struct JCF GTY(()) {
  unsigned char * GTY ((skip)) buffer;
  unsigned char * GTY ((skip)) buffer_end;
  unsigned char * GTY ((skip)) read_ptr;
  unsigned char * GTY ((skip)) read_end;
  unsigned int right_zip : 1;
  unsigned int finished : 1;
  jcf_filbuf_t filbuf;
  PTR GTY ((skip)) read_state;
  const char *filename;
  const char *classname;
  /* Directory entry where it was found.  */
  struct ZipDirectory * GTY ((skip)) zipd;
  JCF_u2 access_flags;
  JCF_u2 this_class;
  JCF_u2 super_class;
  CPool cpool;
} JCF;
/*typedef JCF*  JCF_FILE;*/

#define JCF_SEEN_IN_ZIP(JCF) ((JCF)->zipd != NULL)

/* The CPOOL macros take a (pointer to a) CPool.
   The JPOOL macros take a (pointer to a) JCF.
   Some of the latter should perhaps be deprecated or removed. */

#define CPOOL_COUNT(CPOOL) ((CPOOL)->count)
#define JPOOL_SIZE(JCF) CPOOL_COUNT(&(JCF)->cpool)
#define JPOOL_TAG(JCF, INDEX) ((JCF)->cpool.tags[INDEX])
/* The INDEX'th constant pool entry as a JCF_u4. */
#define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX].w)
#define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /*deprecated*/
/* The first uint16 of the INDEX'th constant pool entry. */
#define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX].w & 0xFFFF)
#define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
/* The second uint16 of the INDEX'th constant pool entry. */
#define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX].w >> 16)
#define JPOOL_USHORT2(JCF, INDEX) CPOOL_USHORT2(&(JCF)->cpool, INDEX)
#define JPOOL_LONG(JCF, INDEX) \
  WORDS_TO_LONG (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
#define JPOOL_DOUBLE(JCF, INDEX) \
  WORDS_TO_DOUBLE  (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
#ifndef JPOOL_UTF_LENGTH
#define JPOOL_UTF_LENGTH(JCF, INDEX) \
  GET_u2 ((JCF)->buffer+JPOOL_UINT(JCF, INDEX))
#endif
#ifndef JPOOL_UTF_DATA
#define JPOOL_UTF_DATA(JCF, INDEX) \
  ((JCF)->buffer+JPOOL_UINT(JCF, INDEX)+2)
#endif
#define JPOOL_INT(JCF, INDEX) (WORD_TO_INT(JPOOL_UINT (JCF, INDEX)))
#define JPOOL_FLOAT(JCF, INDEX) WORD_TO_FLOAT (JPOOL_UINT (JCF, INDEX))

#define CPOOL_INDEX_IN_RANGE(CPOOL, INDEX) \
 ((INDEX) > 0 && (INDEX) < CPOOL_COUNT(CPOOL))

#define CPOOL_FINISH(CPOOL) {			\
    (CPOOL)->tags = 0;				\
    (CPOOL)->data = 0;				\
  }

#define JCF_FINISH(JCF) { \
  CPOOL_FINISH(&(JCF)->cpool); \
  if ((JCF)->buffer) free ((JCF)->buffer); \
  if ((JCF)->filename) free (CONST_CAST (char *, (JCF)->filename)); \
  if ((JCF)->classname) free (CONST_CAST (char *, (JCF)->classname)); \
  (JCF)->finished = 1; }
  
#define CPOOL_INIT(CPOOL) \
  ((CPOOL)->capacity = 0, (CPOOL)->count = 0, (CPOOL)->tags = 0, (CPOOL)->data = 0)

#define CPOOL_REINIT(CPOOL) ((CPOOL)->count = 0)

#define JCF_ZERO(JCF)  \
  ((JCF)->buffer = (JCF)->buffer_end = (JCF)->read_ptr = (JCF)->read_end = 0,\
   (JCF)->read_state = 0, (JCF)->filename = (JCF)->classname = 0, \
   CPOOL_INIT(&(JCF)->cpool), (JCF)->zipd = 0, \
   (JCF)->finished = 0)

/* Given that PTR points to a 2-byte unsigned integer in network
   (big-endian) byte-order, return that integer. */
#define GET_u2(PTR) (((PTR)[0] << 8) | ((PTR)[1]))
/* Like GET_u2, but for little-endian format. */
#define GET_u2_le(PTR) (((PTR)[1] << 8) | ((PTR)[0]))

/* Given that PTR points to a 4-byte unsigned integer in network
   (big-endian) byte-order, return that integer. */
#define GET_u4(PTR) (((JCF_u4)(PTR)[0] << 24) | ((JCF_u4)(PTR)[1] << 16) \
  | ((JCF_u4)(PTR)[2] << 8) | ((JCF_u4)(PTR)[3]))
/* Like GET_u4, but for little-endian order. */
#define GET_u4_le(PTR) (((JCF_u4)(PTR)[3] << 24) | ((JCF_u4)(PTR)[2] << 16) \
  | ((JCF_u4)(PTR)[1] << 8) | ((JCF_u4)(PTR)[0]))

/* Make sure there are COUNT bytes readable. */
#define JCF_FILL(JCF, COUNT) \
  ((JCF)->read_end-(JCF)->read_ptr >= (COUNT) ? 0 : (*(JCF)->filbuf)(JCF, COUNT))
#define JCF_GETC(JCF) (JCF_FILL(JCF, 1) ? -1 : *(JCF)->read_ptr++)
#define JCF_READ(JCF, BUFFER, N) \
    (memcpy (BUFFER, (JCF)->read_ptr, N), (JCF)->read_ptr += (N))
#define JCF_SKIP(JCF,N) ((JCF)->read_ptr += (N))
#define JCF_readu(JCF) (*(JCF)->read_ptr++)

/* Reads an unsigned 2-byte integer in network (big-endian) byte-order
   from JCF.  Returns that integer.
   Does not check for EOF (make sure to call JCF_FILL before-hand). */
#define JCF_readu2(JCF) ((JCF)->read_ptr += 2, GET_u2 ((JCF)->read_ptr-2))
#define JCF_readu2_le(JCF) ((JCF)->read_ptr += 2, GET_u2_le((JCF)->read_ptr-2))

/* Like JCF_readu2, but read a 4-byte unsigned integer. */
#define JCF_readu4(JCF) ((JCF)->read_ptr += 4, GET_u4 ((JCF)->read_ptr-4))
#define JCF_readu4_le(JCF) ((JCF)->read_ptr += 4, GET_u4_le((JCF)->read_ptr-4))

#define JCF_TELL(JCF) ((JCF)->read_ptr - (JCF)->buffer)
#define JCF_SEEK(JCF, POS) ((JCF)->read_ptr = (JCF)->buffer + (POS))

#define ACC_PUBLIC 0x0001
#define ACC_PRIVATE 0x0002
#define ACC_PROTECTED 0x0004
#define ACC_STATIC 0x0008
#define ACC_FINAL 0x0010
#define ACC_SYNCHRONIZED 0x0020
#define ACC_SUPER 0x0020
#define ACC_BRIDGE 0x0040
#define ACC_VOLATILE 0x0040
#define ACC_TRANSIENT 0x0080
#define ACC_VARARGS 0x0080
#define ACC_NATIVE 0x0100
#define ACC_INTERFACE 0x0200
#define ACC_ABSTRACT 0x0400
#define ACC_STRICT 0x0800
#define ACC_SYNTHETIC 0x01000
#define ACC_ANNOTATION 0x02000
#define ACC_ENUM 0x04000
/* "Invisible" refers to Miranda methods inserted into an abstract
   class.  It is also used in the runtime.  */
#define ACC_INVISIBLE 0x8000

#define ACC_VISIBILITY (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED)

enum cpool_tag
{
  CONSTANT_Class = 7,
  CONSTANT_Fieldref = 9,
  CONSTANT_Methodref = 10,
  CONSTANT_InterfaceMethodref = 11,
  CONSTANT_String = 8,
  CONSTANT_Integer = 3,
  CONSTANT_Float = 4,
  CONSTANT_Long = 5,
  CONSTANT_Double = 6,
  CONSTANT_NameAndType = 12,
  CONSTANT_Utf8 = 1,
  CONSTANT_Unicode = 2,
  CONSTANT_None = 0
};

#define DEFAULT_CLASS_PATH "."

extern const char *find_class (const char *, int, JCF *);
extern const char *find_classfile (char *, JCF*, const char *);
extern int jcf_filbuf_from_stdio (JCF *jcf, int count);
extern int jcf_unexpected_eof (JCF*, int) ATTRIBUTE_NORETURN;

/* Extract a character from a Java-style Utf8 string.
 * PTR points to the current character.
 * LIMIT points to the end of the Utf8 string.
 * PTR is incremented to point after the character that gets returned.
 * On an error, -1 is returned. */
#define UTF8_GET(PTR, LIMIT) \
  ((PTR) >= (LIMIT) ? -1 \
   : *(PTR) < 128 ? *(PTR)++ \
   : (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
   ? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
   : (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
   && ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
   ? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
   : ((PTR)++, -1))

extern const char *jcf_write_base_directory;

/* Debug macros, for the front end */

extern int quiet_flag;
#ifdef VERBOSE_SKELETON
#undef SOURCE_FRONTEND_DEBUG
#define SOURCE_FRONTEND_DEBUG(X)				\
  {if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
#else
#define SOURCE_FRONTEND_DEBUG(X)
#endif

/* Declarations for dependency code.  */
extern void jcf_dependency_reset (void);
extern void jcf_dependency_set_target (const char *);
extern void jcf_dependency_add_target (const char *);
extern void jcf_dependency_set_dep_file (const char *);
extern void jcf_dependency_add_file (const char *, int);
extern void jcf_dependency_write (void);
extern void jcf_dependency_init (int);
extern void jcf_dependency_print_dummies (void);

/* Declarations for path handling code.  */
extern void jcf_path_init (void);
extern void jcf_path_classpath_arg (const char *);
extern void jcf_path_bootclasspath_arg (const char *);
extern void jcf_path_extdirs_arg (const char *);
extern void jcf_path_include_arg (const char *);
extern void jcf_path_seal (int);
extern void *jcf_path_start (void);
extern void *jcf_path_next (void *);
extern char *jcf_path_name (void *);
extern char *jcf_path_compute (const char *);
extern int jcf_path_is_zipfile (void *);
extern int jcf_path_is_system (void *);
extern int jcf_path_max_len (void);

#endif /* ! GCC_JCF_H */
Commit	Line	Data
e04a16fb	1	/* Utility macros to read Java(TM) .class files and byte codes.
6ef795d2	2	Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
dcef3dac	3	2006, 2007, 2008 Free Software Foundation, Inc.
e04a16fb	4
f309ff0a	5	This file is part of GCC.
e04a16fb	6
f309ff0a	7	GCC is free software; you can redistribute it and/or modify
e04a16fb	8	it under the terms of the GNU General Public License as published by
8328d52a	9	the Free Software Foundation; either version 3, or (at your option)
e04a16fb AG	10	any later version.
e04a16fb AG	11
f309ff0a	12	GCC is distributed in the hope that it will be useful,
e04a16fb AG	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
8328d52a NC	18	along with GCC; see the file COPYING3. If not see
8328d52a NC	19	<http://www.gnu.org/licenses/>.
e04a16fb AG	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
88657302 RH	27	#ifndef GCC_JCF_H
88657302 RH	28	#define GCC_JCF_H
e04a16fb	29	#include "javaop.h"
e04a16fb AG	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
c2e3db92 KG	38	#define ALLOC xmalloc
c2e3db92 KG	39	#define REALLOC xrealloc
e04a16fb AG	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
72f339d2 AH	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
cd64dc98 KH	56	(i.e. defined(WIN32) \|\| defined(YOUR_HOST)) and add a host-specific
cd64dc98 KH	57	.c file to Make-lang.in similar to win32-host.c. */
72f339d2 AH	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
e04a16fb	66	struct JCF;
35222de2	67	typedef int (jcf_filbuf_t) (struct JCF, int needed);
e04a16fb	68
17211ab5 GK	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(()) {
e04a16fb AG	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
17211ab5	85	uint8* GTY((length ("%h.count"))) tags;
e04a16fb	86
17211ab5 GK	87	union cpool_entry * GTY((length ("%h.count"),
17211ab5 GK	88	desc ("cpool_entry_is_tree (%1.tags%a)"))) data;
e04a16fb AG	89	} CPool;
e04a16fb AG	90
a4796c80 PB	91	struct ZipDirectory;
a4796c80 PB	92
e04a16fb AG	93	/* JCF encapsulates the state of reading a Java Class File. */
e04a16fb AG	94
17211ab5	95	typedef struct JCF GTY(()) {
1431042e ZW	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;
b40410b9 JM	100	unsigned int right_zip : 1;
b40410b9 JM	101	unsigned int finished : 1;
e04a16fb	102	jcf_filbuf_t filbuf;
1431042e	103	PTR GTY ((skip)) read_state;
3b304f5b ZW	104	const char *filename;
3b304f5b ZW	105	const char *classname;
17211ab5	106	/* Directory entry where it was found. */
1431042e	107	struct ZipDirectory * GTY ((skip)) zipd;
17211ab5 GK	108	JCF_u2 access_flags;
	109	JCF_u2 this_class;
	110	JCF_u2 super_class;
e04a16fb AG	111	CPool cpool;
	112	} JCF;
	113	/typedef JCF JCF_FILE;*/
	114
a4796c80 PB	115	#define JCF_SEEN_IN_ZIP(JCF) ((JCF)->zipd != NULL)
a4796c80 PB	116
e04a16fb AG	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. */
17211ab5	125	#define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX].w)
e04a16fb AG	126	#define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /deprecated/
e04a16fb AG	127	/* The first uint16 of the INDEX'th constant pool entry. */
17211ab5	128	#define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX].w & 0xFFFF)
e04a16fb AG	129	#define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
e04a16fb AG	130	/* The second uint16 of the INDEX'th constant pool entry. */
17211ab5	131	#define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX].w >> 16)
e04a16fb AG	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
dd5d6281	145	#define JPOOL_INT(JCF, INDEX) (WORD_TO_INT(JPOOL_UINT (JCF, INDEX)))
e04a16fb AG	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
17211ab5 GK	151	#define CPOOL_FINISH(CPOOL) { \
	152	(CPOOL)->tags = 0; \
	153	(CPOOL)->data = 0; \
	154	}
e04a16fb AG	155
	156	#define JCF_FINISH(JCF) { \
	157	CPOOL_FINISH(&(JCF)->cpool); \
5ed6ace5	158	if ((JCF)->buffer) free ((JCF)->buffer); \
b1d5455a KG	159	if ((JCF)->filename) free (CONST_CAST (char *, (JCF)->filename)); \
b1d5455a KG	160	if ((JCF)->classname) free (CONST_CAST (char *, (JCF)->classname)); \
51e23701	161	(JCF)->finished = 1; }
e04a16fb AG	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, \
6ef795d2	171	CPOOL_INIT(&(JCF)->cpool), (JCF)->zipd = 0, \
51e23701	172	(JCF)->finished = 0)
e04a16fb AG	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
c02174ab	217	#define ACC_BRIDGE 0x0040
e04a16fb AG	218	#define ACC_VOLATILE 0x0040
e04a16fb AG	219	#define ACC_TRANSIENT 0x0080
c02174ab	220	#define ACC_VARARGS 0x0080
e04a16fb AG	221	#define ACC_NATIVE 0x0100
	222	#define ACC_INTERFACE 0x0200
	223	#define ACC_ABSTRACT 0x0400
6b6294f1	224	#define ACC_STRICT 0x0800
c02174ab TT	225	#define ACC_SYNTHETIC 0x01000
	226	#define ACC_ANNOTATION 0x02000
	227	#define ACC_ENUM 0x04000
aecf4109	228	/* "Invisible" refers to Miranda methods inserted into an abstract
5aca4c41 TT	229	class. It is also used in the runtime. */
5aca4c41 TT	230	#define ACC_INVISIBLE 0x8000
e04a16fb	231
a003f638 JB	232	#define ACC_VISIBILITY (ACC_PUBLIC \| ACC_PRIVATE \| ACC_PROTECTED)
a003f638 JB	233
97b8365c TT	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	};
e04a16fb	250
e04a16fb AG	251	#define DEFAULT_CLASS_PATH "."
e04a16fb AG	252
6ef795d2	253	extern const char find_class (const char , int, JCF *);
d2097937 KG	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;
e04a16fb AG	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.
98a63868	261	* PTR is incremented to point after the character that gets returned.
e04a16fb AG	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 \
a3299934	270	? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
e04a16fb AG	271	: ((PTR)++, -1))
e04a16fb AG	272
95ca6d8b	273	extern const char *jcf_write_base_directory;
df66b566	274
e04a16fb AG	275	/* Debug macros, for the front end */
	276
	277	extern int quiet_flag;
5e942c50	278	#ifdef VERBOSE_SKELETON
e04a16fb AG	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
fc45c7ef	286	/* Declarations for dependency code. */
d2097937 KG	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);
fc45c7ef	295
8603f9c5	296	/* Declarations for path handling code. */
d2097937 KG	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 );
97b8365c	306	extern char jcf_path_compute (const char );
d2097937 KG	307	extern int jcf_path_is_zipfile (void *);
	308	extern int jcf_path_is_system (void *);
	309	extern int jcf_path_max_len (void);
8603f9c5	310
88657302	311	#endif /* ! GCC_JCF_H */