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

/* Utility macros to read Java(TM) .class files and byte codes.

   Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.

This program 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 2, or (at your option)
any later version.

This program 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 GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  

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 DEFUN
#if defined (__STDC__)
#define AND             ,
#define PTR             void *
#define DEFUN(name, arglist, args)      name(args)
#else
#define PTR             char *
#define AND             ;
#define DEFUN(name, arglist, args)      name arglist args;
#endif
#endif /* !DEFUN */

#ifndef PARAMS
#if defined (__STDC__)
#define PARAMS (paramlist)    paramlist
#else
#define PARAMS (paramlist)    ()
#endif
#endif

#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

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

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

  /* The constant_pool_count. */
  int		count;

  uint8*	tags;

  jword*	data;
} CPool;

struct ZipDirectory;

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

typedef struct JCF {
  unsigned char *buffer;
  unsigned char *buffer_end;
  unsigned char *read_ptr;
  unsigned char *read_end;
  int java_source : 1;
  int right_zip : 1;
  int finished : 1;
  jcf_filbuf_t filbuf;
  void *read_state;
  const char *filename;
  const char *classname;
  struct ZipDirectory *zipd;	/* Directory entry where it was found */
  JCF_u2 access_flags, this_class, 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])
#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] & 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] >> 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) { \
  if ((CPOOL)->tags) FREE ((CPOOL)->tags); \
  if ((CPOOL)->data) FREE ((CPOOL)->data); }

#define JCF_FINISH(JCF) { \
  CPOOL_FINISH(&(JCF)->cpool); \
  if ((JCF)->buffer) FREE ((JCF)->buffer); \
  if ((JCF)->filename) FREE ((char *) (JCF)->filename); \
  if ((JCF)->classname) FREE ((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)->java_source = 0, (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_VOLATILE 0x0040
#define ACC_TRANSIENT 0x0080
#define ACC_NATIVE 0x0100
#define ACC_INTERFACE 0x0200
#define ACC_ABSTRACT 0x0400

#define ACC_VISIBILITY (ACC_PUBLIC | ACC_PRIVATE | ACC_PROTECTED)

#define CONSTANT_Class 7
#define CONSTANT_Fieldref 9
#define CONSTANT_Methodref 10
#define CONSTANT_InterfaceMethodref 11
#define CONSTANT_String 8
#define CONSTANT_Integer 3
#define CONSTANT_Float 4
#define CONSTANT_Long 5
#define CONSTANT_Double 6
#define CONSTANT_NameAndType 12
#define CONSTANT_Utf8 1
#define CONSTANT_Unicode 2

#define DEFAULT_CLASS_PATH "."

extern const char *find_class PARAMS ((const char *, int, JCF*, int));
extern const char *find_classfile PARAMS ((char *, JCF*, const char *));
extern int jcf_filbuf_from_stdio PARAMS ((JCF *jcf, int count));
extern int jcf_unexpected_eof PARAMS ((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 thta gets returns.
 * 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 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 PARAMS ((void));
extern void jcf_dependency_set_target PARAMS ((const char *));
extern void jcf_dependency_add_target PARAMS ((const char *));
extern void jcf_dependency_set_dep_file PARAMS ((const char *));
extern void jcf_dependency_add_file PARAMS ((const char *, int));
extern void jcf_dependency_write PARAMS ((void));
extern void jcf_dependency_init PARAMS ((int));
extern void jcf_dependency_print_dummies PARAMS ((void));

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

#endif /* ! GCC_JCF_H */
Commit	Line	Data
e04a16fb AG	1	/* Utility macros to read Java(TM) .class files and byte codes.
e04a16fb AG	2
3852e8af	3	Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
e04a16fb AG	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
88657302 RH	26	#ifndef GCC_JCF_H
88657302 RH	27	#define GCC_JCF_H
e04a16fb AG	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;
e04a16fb AG	38	#endif
	39	#endif /* !DEFUN */
	40
df32d2ce	41	#ifndef PARAMS
e04a16fb	42	#if defined (__STDC__)
df32d2ce	43	#define PARAMS (paramlist) paramlist
e04a16fb	44	#else
df32d2ce	45	#define PARAMS (paramlist) ()
e04a16fb AG	46	#endif
	47	#endif
	48
	49	#ifndef JCF_u4
	50	#define JCF_u4 unsigned long
	51	#endif
	52	#ifndef JCF_u2
	53	#define JCF_u2 unsigned short
	54	#endif
	55
c2e3db92 KG	56	#define ALLOC xmalloc
c2e3db92 KG	57	#define REALLOC xrealloc
e04a16fb AG	58	#ifndef FREE
	59	#define FREE(PTR) free(PTR)
	60	#endif
	61
	62	#ifdef JCF_word
	63	#define JCF_word JCF_u4
	64	#endif
	65
e04a16fb	66	struct JCF;
df32d2ce	67	typedef int (jcf_filbuf_t) PARAMS ((struct JCF, int needed));
e04a16fb AG	68
	69	typedef struct CPool {
	70	/* Available number of elements in the constants array, before it
	71	must be re-allocated. */
	72	int capacity;
	73
	74	/* The constant_pool_count. */
	75	int count;
	76
	77	uint8* tags;
	78
	79	jword* data;
	80	} CPool;
	81
a4796c80 PB	82	struct ZipDirectory;
a4796c80 PB	83
e04a16fb AG	84	/* JCF encapsulates the state of reading a Java Class File. */
	85
	86	typedef struct JCF {
	87	unsigned char *buffer;
	88	unsigned char *buffer_end;
	89	unsigned char *read_ptr;
	90	unsigned char *read_end;
b124f72e APB	91	int java_source : 1;
b124f72e APB	92	int right_zip : 1;
51e23701	93	int finished : 1;
e04a16fb AG	94	jcf_filbuf_t filbuf;
e04a16fb AG	95	void *read_state;
3b304f5b ZW	96	const char *filename;
3b304f5b ZW	97	const char *classname;
a4796c80	98	struct ZipDirectory zipd; / Directory entry where it was found */
e04a16fb AG	99	JCF_u2 access_flags, this_class, super_class;
	100	CPool cpool;
	101	} JCF;
	102	/typedef JCF JCF_FILE;*/
	103
a4796c80 PB	104	#define JCF_SEEN_IN_ZIP(JCF) ((JCF)->zipd != NULL)
a4796c80 PB	105
e04a16fb AG	106	/* The CPOOL macros take a (pointer to a) CPool.
	107	The JPOOL macros take a (pointer to a) JCF.
	108	Some of the latter should perhaps be deprecated or removed. */
	109
	110	#define CPOOL_COUNT(CPOOL) ((CPOOL)->count)
	111	#define JPOOL_SIZE(JCF) CPOOL_COUNT(&(JCF)->cpool)
	112	#define JPOOL_TAG(JCF, INDEX) ((JCF)->cpool.tags[INDEX])
	113	/* The INDEX'th constant pool entry as a JCF_u4. */
	114	#define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX])
	115	#define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /deprecated/
	116	/* The first uint16 of the INDEX'th constant pool entry. */
	117	#define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX] & 0xFFFF)
	118	#define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
	119	/* The second uint16 of the INDEX'th constant pool entry. */
	120	#define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX] >> 16)
	121	#define JPOOL_USHORT2(JCF, INDEX) CPOOL_USHORT2(&(JCF)->cpool, INDEX)
	122	#define JPOOL_LONG(JCF, INDEX) \
	123	WORDS_TO_LONG (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
	124	#define JPOOL_DOUBLE(JCF, INDEX) \
	125	WORDS_TO_DOUBLE (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
	126	#ifndef JPOOL_UTF_LENGTH
	127	#define JPOOL_UTF_LENGTH(JCF, INDEX) \
	128	GET_u2 ((JCF)->buffer+JPOOL_UINT(JCF, INDEX))
	129	#endif
	130	#ifndef JPOOL_UTF_DATA
	131	#define JPOOL_UTF_DATA(JCF, INDEX) \
	132	((JCF)->buffer+JPOOL_UINT(JCF, INDEX)+2)
	133	#endif
dd5d6281	134	#define JPOOL_INT(JCF, INDEX) (WORD_TO_INT(JPOOL_UINT (JCF, INDEX)))
e04a16fb AG	135	#define JPOOL_FLOAT(JCF, INDEX) WORD_TO_FLOAT (JPOOL_UINT (JCF, INDEX))
	136
	137	#define CPOOL_INDEX_IN_RANGE(CPOOL, INDEX) \
	138	((INDEX) > 0 && (INDEX) < CPOOL_COUNT(CPOOL))
	139
	140	#define CPOOL_FINISH(CPOOL) { \
	141	if ((CPOOL)->tags) FREE ((CPOOL)->tags); \
	142	if ((CPOOL)->data) FREE ((CPOOL)->data); }
	143
	144	#define JCF_FINISH(JCF) { \
	145	CPOOL_FINISH(&(JCF)->cpool); \
	146	if ((JCF)->buffer) FREE ((JCF)->buffer); \
3b304f5b	147	if ((JCF)->filename) FREE ((char *) (JCF)->filename); \
51e23701 APB	148	if ((JCF)->classname) FREE ((char *) (JCF)->classname); \
51e23701 APB	149	(JCF)->finished = 1; }
e04a16fb AG	150
	151	#define CPOOL_INIT(CPOOL) \
	152	((CPOOL)->capacity = 0, (CPOOL)->count = 0, (CPOOL)->tags = 0, (CPOOL)->data = 0)
	153
	154	#define CPOOL_REINIT(CPOOL) ((CPOOL)->count = 0)
	155
	156	#define JCF_ZERO(JCF) \
	157	((JCF)->buffer = (JCF)->buffer_end = (JCF)->read_ptr = (JCF)->read_end = 0,\
	158	(JCF)->read_state = 0, (JCF)->filename = (JCF)->classname = 0, \
51e23701 APB	159	CPOOL_INIT(&(JCF)->cpool), (JCF)->java_source = 0, (JCF)->zipd = 0, \
51e23701 APB	160	(JCF)->finished = 0)
e04a16fb AG	161
	162	/* Given that PTR points to a 2-byte unsigned integer in network
	163	(big-endian) byte-order, return that integer. */
	164	#define GET_u2(PTR) (((PTR)[0] << 8) \| ((PTR)[1]))
	165	/* Like GET_u2, but for little-endian format. */
	166	#define GET_u2_le(PTR) (((PTR)[1] << 8) \| ((PTR)[0]))
	167
	168	/* Given that PTR points to a 4-byte unsigned integer in network
	169	(big-endian) byte-order, return that integer. */
	170	#define GET_u4(PTR) (((JCF_u4)(PTR)[0] << 24) \| ((JCF_u4)(PTR)[1] << 16) \
	171	\| ((JCF_u4)(PTR)[2] << 8) \| ((JCF_u4)(PTR)[3]))
	172	/* Like GET_u4, but for little-endian order. */
	173	#define GET_u4_le(PTR) (((JCF_u4)(PTR)[3] << 24) \| ((JCF_u4)(PTR)[2] << 16) \
	174	\| ((JCF_u4)(PTR)[1] << 8) \| ((JCF_u4)(PTR)[0]))
	175
	176	/* Make sure there are COUNT bytes readable. */
	177	#define JCF_FILL(JCF, COUNT) \
	178	((JCF)->read_end-(JCF)->read_ptr >= (COUNT) ? 0 : (*(JCF)->filbuf)(JCF, COUNT))
	179	#define JCF_GETC(JCF) (JCF_FILL(JCF, 1) ? -1 : *(JCF)->read_ptr++)
	180	#define JCF_READ(JCF, BUFFER, N) \
	181	(memcpy (BUFFER, (JCF)->read_ptr, N), (JCF)->read_ptr += (N))
	182	#define JCF_SKIP(JCF,N) ((JCF)->read_ptr += (N))
	183	#define JCF_readu(JCF) (*(JCF)->read_ptr++)
	184
	185	/* Reads an unsigned 2-byte integer in network (big-endian) byte-order
	186	from JCF. Returns that integer.
	187	Does not check for EOF (make sure to call JCF_FILL before-hand). */
	188	#define JCF_readu2(JCF) ((JCF)->read_ptr += 2, GET_u2 ((JCF)->read_ptr-2))
	189	#define JCF_readu2_le(JCF) ((JCF)->read_ptr += 2, GET_u2_le((JCF)->read_ptr-2))
	190
	191	/* Like JCF_readu2, but read a 4-byte unsigned integer. */
	192	#define JCF_readu4(JCF) ((JCF)->read_ptr += 4, GET_u4 ((JCF)->read_ptr-4))
	193	#define JCF_readu4_le(JCF) ((JCF)->read_ptr += 4, GET_u4_le((JCF)->read_ptr-4))
	194
	195	#define JCF_TELL(JCF) ((JCF)->read_ptr - (JCF)->buffer)
	196	#define JCF_SEEK(JCF, POS) ((JCF)->read_ptr = (JCF)->buffer + (POS))
	197
	198	#define ACC_PUBLIC 0x0001
	199	#define ACC_PRIVATE 0x0002
	200	#define ACC_PROTECTED 0x0004
	201	#define ACC_STATIC 0x0008
	202	#define ACC_FINAL 0x0010
	203	#define ACC_SYNCHRONIZED 0x0020
	204	#define ACC_SUPER 0x0020
	205	#define ACC_VOLATILE 0x0040
	206	#define ACC_TRANSIENT 0x0080
	207	#define ACC_NATIVE 0x0100
	208	#define ACC_INTERFACE 0x0200
	209	#define ACC_ABSTRACT 0x0400
	210
a003f638 JB	211	#define ACC_VISIBILITY (ACC_PUBLIC \| ACC_PRIVATE \| ACC_PROTECTED)
a003f638 JB	212
e04a16fb AG	213	#define CONSTANT_Class 7
	214	#define CONSTANT_Fieldref 9
	215	#define CONSTANT_Methodref 10
	216	#define CONSTANT_InterfaceMethodref 11
	217	#define CONSTANT_String 8
	218	#define CONSTANT_Integer 3
	219	#define CONSTANT_Float 4
	220	#define CONSTANT_Long 5
	221	#define CONSTANT_Double 6
	222	#define CONSTANT_NameAndType 12
	223	#define CONSTANT_Utf8 1
	224	#define CONSTANT_Unicode 2
	225
e04a16fb AG	226	#define DEFAULT_CLASS_PATH "."
e04a16fb AG	227
df32d2ce KG	228	extern const char find_class PARAMS ((const char , int, JCF*, int));
	229	extern const char find_classfile PARAMS ((char , JCF, const char ));
	230	extern int jcf_filbuf_from_stdio PARAMS ((JCF *jcf, int count));
	231	extern int jcf_unexpected_eof PARAMS ((JCF*, int)) ATTRIBUTE_NORETURN;
e04a16fb AG	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 \
a3299934	245	? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
e04a16fb AG	246	: ((PTR)++, -1))
e04a16fb AG	247
df66b566 TT	248	extern char *jcf_write_base_directory;
df66b566 TT	249
e04a16fb AG	250	/* Debug macros, for the front end */
	251
	252	extern int quiet_flag;
5e942c50	253	#ifdef VERBOSE_SKELETON
e04a16fb AG	254	#undef SOURCE_FRONTEND_DEBUG
	255	#define SOURCE_FRONTEND_DEBUG(X) \
	256	{if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
	257	#else
	258	#define SOURCE_FRONTEND_DEBUG(X)
	259	#endif
	260
fc45c7ef	261	/* Declarations for dependency code. */
df32d2ce KG	262	extern void jcf_dependency_reset PARAMS ((void));
	263	extern void jcf_dependency_set_target PARAMS ((const char *));
	264	extern void jcf_dependency_add_target PARAMS ((const char *));
	265	extern void jcf_dependency_set_dep_file PARAMS ((const char *));
	266	extern void jcf_dependency_add_file PARAMS ((const char *, int));
	267	extern void jcf_dependency_write PARAMS ((void));
	268	extern void jcf_dependency_init PARAMS ((int));
316a06a1	269	extern void jcf_dependency_print_dummies PARAMS ((void));
fc45c7ef	270
8603f9c5	271	/* Declarations for path handling code. */
df32d2ce KG	272	extern void jcf_path_init PARAMS ((void));
	273	extern void jcf_path_classpath_arg PARAMS ((const char *));
	274	extern void jcf_path_CLASSPATH_arg PARAMS ((const char *));
	275	extern void jcf_path_include_arg PARAMS ((const char *));
	276	extern void jcf_path_seal PARAMS ((void));
	277	extern void *jcf_path_start PARAMS ((void));
	278	extern void jcf_path_next PARAMS ((void ));
	279	extern char jcf_path_name PARAMS ((void ));
	280	extern int jcf_path_is_zipfile PARAMS ((void *));
	281	extern int jcf_path_is_system PARAMS ((void *));
	282	extern int jcf_path_max_len PARAMS ((void));
8603f9c5	283
88657302	284	#endif /* ! GCC_JCF_H */