[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
   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 2, 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 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 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

/* If we have both "scandir" and "alphasort", we can cache directory
   listings to reduce the time taken to search the classpath.  */
#if defined(HAVE_SCANDIR) && defined(HAVE_ALPHASORT)
#define JCF_USE_SCANDIR 1
#else
#define JCF_USE_SCANDIR 0
#endif 

/* On case-insensitive file systems, file name components must be 
   compared using "strcasecmp", if available, instead of "strcmp".
   Assumes "config.h" has already been included.  */
#if defined (HAVE_DOS_BASED_FILE_SYSTEM) && defined (HAVE_STRCASECMP)
#define COMPARE_FILENAMES(X, Y) strcasecmp ((X), (Y))
#else
#define COMPARE_FILENAMES(X, Y) strcmp ((X), (Y))
#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 an 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) PARAMS ((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;
  int java_source : 1;
  int right_zip : 1;
  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 ((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_STRICT 0x0800

#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 (const char *, int, JCF*, int);
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 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.
f309ff0a SB	2	Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
f309ff0a SB	3	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 AG	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
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
f309ff0a	18	along with GCC; see the file COPYING. If not, write to
e04a16fb AG	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
88657302 RH	28	#ifndef GCC_JCF_H
88657302 RH	29	#define GCC_JCF_H
e04a16fb	30	#include "javaop.h"
e04a16fb AG	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
c2e3db92 KG	39	#define ALLOC xmalloc
c2e3db92 KG	40	#define REALLOC xrealloc
e04a16fb AG	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
a15135c9 MM	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
530d4230 RM	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
72f339d2 AH	66	/* On case-insensitive file systems, we need to ensure that a request
	67	to open a .java or .class file is honored only if the file to be
	68	opened is of the exact case we are asking for. In other words, we
	69	want to override the inherent case insensitivity of the underlying
	70	file system. On other platforms, this macro becomes the vanilla
	71	open() call.
	72
	73	If you want to add another host, add your define to the list below
	74	(i.e. defined(WIN32) \|\| defined(YOUR_HOST)) and add an host-specific
	75	.c file to Make-lang.in similar to win32-host.c */
	76	#if defined(WIN32)
	77	extern int
	78	jcf_open_exact_case (const char* filename, int oflag);
	79	#define JCF_OPEN_EXACT_CASE(X, Y) jcf_open_exact_case (X, Y)
	80	#else
	81	#define JCF_OPEN_EXACT_CASE open
	82	#endif /* WIN32 */
	83
e04a16fb	84	struct JCF;
17211ab5	85	typedef int (jcf_filbuf_t) PARAMS ((struct JCF, int needed));
e04a16fb	86
17211ab5 GK	87	union cpool_entry GTY(()) {
	88	jword GTY ((tag ("0"))) w;
	89	tree GTY ((tag ("1"))) t;
	90	};
	91
	92	#define cpool_entry_is_tree(tag) \
	93	(tag & CONSTANT_ResolvedFlag) \|\| tag == CONSTANT_Utf8
	94
	95	typedef struct CPool GTY(()) {
e04a16fb AG	96	/* Available number of elements in the constants array, before it
	97	must be re-allocated. */
	98	int capacity;
	99
	100	/* The constant_pool_count. */
	101	int count;
	102
17211ab5	103	uint8* GTY((length ("%h.count"))) tags;
e04a16fb	104
17211ab5 GK	105	union cpool_entry * GTY((length ("%h.count"),
17211ab5 GK	106	desc ("cpool_entry_is_tree (%1.tags%a)"))) data;
e04a16fb AG	107	} CPool;
e04a16fb AG	108
a4796c80 PB	109	struct ZipDirectory;
a4796c80 PB	110
e04a16fb AG	111	/* JCF encapsulates the state of reading a Java Class File. */
e04a16fb AG	112
17211ab5 GK	113	typedef struct JCF GTY(()) {
	114	unsigned char * GTY ((skip (""))) buffer;
	115	unsigned char * GTY ((skip (""))) buffer_end;
	116	unsigned char * GTY ((skip (""))) read_ptr;
	117	unsigned char * GTY ((skip (""))) read_end;
b124f72e APB	118	int java_source : 1;
b124f72e APB	119	int right_zip : 1;
51e23701	120	int finished : 1;
e04a16fb	121	jcf_filbuf_t filbuf;
17211ab5	122	PTR GTY ((skip (""))) read_state;
3b304f5b ZW	123	const char *filename;
3b304f5b ZW	124	const char *classname;
17211ab5 GK	125	/* Directory entry where it was found. */
	126	struct ZipDirectory * GTY ((skip (""))) zipd;
	127	JCF_u2 access_flags;
	128	JCF_u2 this_class;
	129	JCF_u2 super_class;
e04a16fb AG	130	CPool cpool;
	131	} JCF;
	132	/typedef JCF JCF_FILE;*/
	133
a4796c80 PB	134	#define JCF_SEEN_IN_ZIP(JCF) ((JCF)->zipd != NULL)
a4796c80 PB	135
e04a16fb AG	136	/* The CPOOL macros take a (pointer to a) CPool.
	137	The JPOOL macros take a (pointer to a) JCF.
	138	Some of the latter should perhaps be deprecated or removed. */
	139
	140	#define CPOOL_COUNT(CPOOL) ((CPOOL)->count)
	141	#define JPOOL_SIZE(JCF) CPOOL_COUNT(&(JCF)->cpool)
	142	#define JPOOL_TAG(JCF, INDEX) ((JCF)->cpool.tags[INDEX])
	143	/* The INDEX'th constant pool entry as a JCF_u4. */
17211ab5	144	#define CPOOL_UINT(CPOOL, INDEX) ((CPOOL)->data[INDEX].w)
e04a16fb AG	145	#define JPOOL_UINT(JCF, INDEX) CPOOL_UINT(&(JCF)->cpool, INDEX) /deprecated/
e04a16fb AG	146	/* The first uint16 of the INDEX'th constant pool entry. */
17211ab5	147	#define CPOOL_USHORT1(CPOOL, INDEX) ((CPOOL)->data[INDEX].w & 0xFFFF)
e04a16fb AG	148	#define JPOOL_USHORT1(JCF, INDEX) CPOOL_USHORT1(&(JCF)->cpool, INDEX)
e04a16fb AG	149	/* The second uint16 of the INDEX'th constant pool entry. */
17211ab5	150	#define CPOOL_USHORT2(CPOOL, INDEX) ((CPOOL)->data[INDEX].w >> 16)
e04a16fb AG	151	#define JPOOL_USHORT2(JCF, INDEX) CPOOL_USHORT2(&(JCF)->cpool, INDEX)
	152	#define JPOOL_LONG(JCF, INDEX) \
	153	WORDS_TO_LONG (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
	154	#define JPOOL_DOUBLE(JCF, INDEX) \
	155	WORDS_TO_DOUBLE (JPOOL_UINT(JCF, INDEX), JPOOL_UINT(JCF, (INDEX)+1))
	156	#ifndef JPOOL_UTF_LENGTH
	157	#define JPOOL_UTF_LENGTH(JCF, INDEX) \
	158	GET_u2 ((JCF)->buffer+JPOOL_UINT(JCF, INDEX))
	159	#endif
	160	#ifndef JPOOL_UTF_DATA
	161	#define JPOOL_UTF_DATA(JCF, INDEX) \
	162	((JCF)->buffer+JPOOL_UINT(JCF, INDEX)+2)
	163	#endif
dd5d6281	164	#define JPOOL_INT(JCF, INDEX) (WORD_TO_INT(JPOOL_UINT (JCF, INDEX)))
e04a16fb AG	165	#define JPOOL_FLOAT(JCF, INDEX) WORD_TO_FLOAT (JPOOL_UINT (JCF, INDEX))
	166
	167	#define CPOOL_INDEX_IN_RANGE(CPOOL, INDEX) \
	168	((INDEX) > 0 && (INDEX) < CPOOL_COUNT(CPOOL))
	169
17211ab5 GK	170	#define CPOOL_FINISH(CPOOL) { \
	171	(CPOOL)->tags = 0; \
	172	(CPOOL)->data = 0; \
	173	}
e04a16fb AG	174
	175	#define JCF_FINISH(JCF) { \
	176	CPOOL_FINISH(&(JCF)->cpool); \
	177	if ((JCF)->buffer) FREE ((JCF)->buffer); \
3b304f5b	178	if ((JCF)->filename) FREE ((char *) (JCF)->filename); \
51e23701 APB	179	if ((JCF)->classname) FREE ((char *) (JCF)->classname); \
51e23701 APB	180	(JCF)->finished = 1; }
e04a16fb AG	181
	182	#define CPOOL_INIT(CPOOL) \
	183	((CPOOL)->capacity = 0, (CPOOL)->count = 0, (CPOOL)->tags = 0, (CPOOL)->data = 0)
	184
	185	#define CPOOL_REINIT(CPOOL) ((CPOOL)->count = 0)
	186
	187	#define JCF_ZERO(JCF) \
	188	((JCF)->buffer = (JCF)->buffer_end = (JCF)->read_ptr = (JCF)->read_end = 0,\
	189	(JCF)->read_state = 0, (JCF)->filename = (JCF)->classname = 0, \
51e23701 APB	190	CPOOL_INIT(&(JCF)->cpool), (JCF)->java_source = 0, (JCF)->zipd = 0, \
51e23701 APB	191	(JCF)->finished = 0)
e04a16fb AG	192
	193	/* Given that PTR points to a 2-byte unsigned integer in network
	194	(big-endian) byte-order, return that integer. */
	195	#define GET_u2(PTR) (((PTR)[0] << 8) \| ((PTR)[1]))
	196	/* Like GET_u2, but for little-endian format. */
	197	#define GET_u2_le(PTR) (((PTR)[1] << 8) \| ((PTR)[0]))
	198
	199	/* Given that PTR points to a 4-byte unsigned integer in network
	200	(big-endian) byte-order, return that integer. */
	201	#define GET_u4(PTR) (((JCF_u4)(PTR)[0] << 24) \| ((JCF_u4)(PTR)[1] << 16) \
	202	\| ((JCF_u4)(PTR)[2] << 8) \| ((JCF_u4)(PTR)[3]))
	203	/* Like GET_u4, but for little-endian order. */
	204	#define GET_u4_le(PTR) (((JCF_u4)(PTR)[3] << 24) \| ((JCF_u4)(PTR)[2] << 16) \
	205	\| ((JCF_u4)(PTR)[1] << 8) \| ((JCF_u4)(PTR)[0]))
	206
	207	/* Make sure there are COUNT bytes readable. */
	208	#define JCF_FILL(JCF, COUNT) \
	209	((JCF)->read_end-(JCF)->read_ptr >= (COUNT) ? 0 : (*(JCF)->filbuf)(JCF, COUNT))
	210	#define JCF_GETC(JCF) (JCF_FILL(JCF, 1) ? -1 : *(JCF)->read_ptr++)
	211	#define JCF_READ(JCF, BUFFER, N) \
	212	(memcpy (BUFFER, (JCF)->read_ptr, N), (JCF)->read_ptr += (N))
	213	#define JCF_SKIP(JCF,N) ((JCF)->read_ptr += (N))
	214	#define JCF_readu(JCF) (*(JCF)->read_ptr++)
	215
	216	/* Reads an unsigned 2-byte integer in network (big-endian) byte-order
	217	from JCF. Returns that integer.
	218	Does not check for EOF (make sure to call JCF_FILL before-hand). */
	219	#define JCF_readu2(JCF) ((JCF)->read_ptr += 2, GET_u2 ((JCF)->read_ptr-2))
	220	#define JCF_readu2_le(JCF) ((JCF)->read_ptr += 2, GET_u2_le((JCF)->read_ptr-2))
	221
	222	/* Like JCF_readu2, but read a 4-byte unsigned integer. */
	223	#define JCF_readu4(JCF) ((JCF)->read_ptr += 4, GET_u4 ((JCF)->read_ptr-4))
	224	#define JCF_readu4_le(JCF) ((JCF)->read_ptr += 4, GET_u4_le((JCF)->read_ptr-4))
	225
	226	#define JCF_TELL(JCF) ((JCF)->read_ptr - (JCF)->buffer)
	227	#define JCF_SEEK(JCF, POS) ((JCF)->read_ptr = (JCF)->buffer + (POS))
	228
	229	#define ACC_PUBLIC 0x0001
	230	#define ACC_PRIVATE 0x0002
	231	#define ACC_PROTECTED 0x0004
	232	#define ACC_STATIC 0x0008
	233	#define ACC_FINAL 0x0010
	234	#define ACC_SYNCHRONIZED 0x0020
	235	#define ACC_SUPER 0x0020
	236	#define ACC_VOLATILE 0x0040
	237	#define ACC_TRANSIENT 0x0080
	238	#define ACC_NATIVE 0x0100
	239	#define ACC_INTERFACE 0x0200
	240	#define ACC_ABSTRACT 0x0400
6b6294f1	241	#define ACC_STRICT 0x0800
e04a16fb	242
a003f638 JB	243	#define ACC_VISIBILITY (ACC_PUBLIC \| ACC_PRIVATE \| ACC_PROTECTED)
a003f638 JB	244
e04a16fb AG	245	#define CONSTANT_Class 7
	246	#define CONSTANT_Fieldref 9
	247	#define CONSTANT_Methodref 10
	248	#define CONSTANT_InterfaceMethodref 11
	249	#define CONSTANT_String 8
	250	#define CONSTANT_Integer 3
	251	#define CONSTANT_Float 4
	252	#define CONSTANT_Long 5
	253	#define CONSTANT_Double 6
	254	#define CONSTANT_NameAndType 12
	255	#define CONSTANT_Utf8 1
	256	#define CONSTANT_Unicode 2
	257
e04a16fb AG	258	#define DEFAULT_CLASS_PATH "."
e04a16fb AG	259
d2097937 KG	260	extern const char find_class (const char , int, JCF*, int);
	261	extern const char find_classfile (char , JCF, const char );
	262	extern int jcf_filbuf_from_stdio (JCF *jcf, int count);
	263	extern int jcf_unexpected_eof (JCF*, int) ATTRIBUTE_NORETURN;
e04a16fb AG	264
	265	/* Extract a character from a Java-style Utf8 string.
	266	* PTR points to the current character.
	267	* LIMIT points to the end of the Utf8 string.
98a63868	268	* PTR is incremented to point after the character that gets returned.
e04a16fb AG	269	* On an error, -1 is returned. */
	270	#define UTF8_GET(PTR, LIMIT) \
	271	((PTR) >= (LIMIT) ? -1 \
	272	: (PTR) < 128 ? (PTR)++ \
	273	: (*(PTR)&0xE0) == 0xC0 && ((PTR)+=2)<=(LIMIT) && ((PTR)[-1]&0xC0) == 0x80 \
	274	? (((PTR)[-2] & 0x1F) << 6) + ((PTR)[-1] & 0x3F) \
	275	: (*(PTR) & 0xF0) == 0xE0 && ((PTR) += 3) <= (LIMIT) \
	276	&& ((PTR)[-2] & 0xC0) == 0x80 && ((PTR)[-1] & 0xC0) == 0x80 \
a3299934	277	? (((PTR)[-3]&0x0F) << 12) + (((PTR)[-2]&0x3F) << 6) + ((PTR)[-1]&0x3F) \
e04a16fb AG	278	: ((PTR)++, -1))
e04a16fb AG	279
95ca6d8b	280	extern const char *jcf_write_base_directory;
df66b566	281
e04a16fb AG	282	/* Debug macros, for the front end */
	283
	284	extern int quiet_flag;
5e942c50	285	#ifdef VERBOSE_SKELETON
e04a16fb AG	286	#undef SOURCE_FRONTEND_DEBUG
	287	#define SOURCE_FRONTEND_DEBUG(X) \
	288	{if (!quiet_flag) {printf ("* "); printf X; putchar ('\n');} }
	289	#else
	290	#define SOURCE_FRONTEND_DEBUG(X)
	291	#endif
	292
fc45c7ef	293	/* Declarations for dependency code. */
d2097937 KG	294	extern void jcf_dependency_reset (void);
	295	extern void jcf_dependency_set_target (const char *);
	296	extern void jcf_dependency_add_target (const char *);
	297	extern void jcf_dependency_set_dep_file (const char *);
	298	extern void jcf_dependency_add_file (const char *, int);
	299	extern void jcf_dependency_write (void);
	300	extern void jcf_dependency_init (int);
	301	extern void jcf_dependency_print_dummies (void);
fc45c7ef	302
8603f9c5	303	/* Declarations for path handling code. */
d2097937 KG	304	extern void jcf_path_init (void);
	305	extern void jcf_path_classpath_arg (const char *);
	306	extern void jcf_path_bootclasspath_arg (const char *);
	307	extern void jcf_path_extdirs_arg (const char *);
	308	extern void jcf_path_include_arg (const char *);
	309	extern void jcf_path_seal (int);
	310	extern void *jcf_path_start (void);
	311	extern void jcf_path_next (void );
	312	extern char jcf_path_name (void );
	313	extern int jcf_path_is_zipfile (void *);
	314	extern int jcf_path_is_system (void *);
	315	extern int jcf_path_max_len (void);
8603f9c5	316
88657302	317	#endif /* ! GCC_JCF_H */