[thirdparty/glibc.git] / dirent / dirent.h

/* Copyright (C) 1991-1999, 2000, 2003 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

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

   The GNU C Library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA.  */

/*
 *	POSIX Standard: 5.1.2 Directory Operations	<dirent.h>
 */

#ifndef	_DIRENT_H
#define	_DIRENT_H	1

#include <features.h>

__BEGIN_DECLS

#include <bits/types.h>

#ifdef __USE_XOPEN
# ifndef __ino_t_defined
#  ifndef __USE_FILE_OFFSET64
typedef __ino_t ino_t;
#  else
typedef __ino64_t ino_t;
#  endif
#  define __ino_t_defined
# endif
# if defined __USE_LARGEFILE64 && !defined __ino64_t_defined
typedef __ino64_t ino64_t;
#  define __ino64_t_defined
# endif
#endif

/* This file defines `struct dirent'.

   It defines the macro `_DIRENT_HAVE_D_NAMLEN' iff there is a `d_namlen'
   member that gives the length of `d_name'.

   It defines the macro `_DIRENT_HAVE_D_RECLEN' iff there is a `d_reclen'
   member that gives the size of the entire directory entry.

   It defines the macro `_DIRENT_HAVE_D_OFF' iff there is a `d_off'
   member that gives the file offset of the next directory entry.

   It defines the macro `_DIRENT_HAVE_D_TYPE' iff there is a `d_type'
   member that gives the type of the file.
 */

#include <bits/dirent.h>

#if (defined __USE_BSD || defined __USE_MISC) && !defined d_fileno
# define d_ino	d_fileno		 /* Backward compatibility.  */
#endif

/* These macros extract size information from a `struct dirent *'.
   They may evaluate their argument multiple times, so it must not
   have side effects.  Each of these may involve a relatively costly
   call to `strlen' on some systems, so these values should be cached.

   _D_EXACT_NAMLEN (DP)	returns the length of DP->d_name, not including
   its terminating null character.

   _D_ALLOC_NAMLEN (DP)	returns a size at least (_D_EXACT_NAMLEN (DP) + 1);
   that is, the allocation size needed to hold the DP->d_name string.
   Use this macro when you don't need the exact length, just an upper bound.
   This macro is less likely to require calling `strlen' than _D_EXACT_NAMLEN.
   */

#ifdef _DIRENT_HAVE_D_NAMLEN
# define _D_EXACT_NAMLEN(d) ((d)->d_namlen)
# define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
#else
# define _D_EXACT_NAMLEN(d) (strlen ((d)->d_name))
# ifdef _DIRENT_HAVE_D_RECLEN
#  define _D_ALLOC_NAMLEN(d) (((char *) (d) + (d)->d_reclen) - &(d)->d_name[0])
# else
#  define _D_ALLOC_NAMLEN(d) (sizeof (d)->d_name > 1 ? sizeof (d)->d_name : \
			      _D_EXACT_NAMLEN (d) + 1)
# endif
#endif


#ifdef __USE_BSD
/* File types for `d_type'.  */
enum
  {
    DT_UNKNOWN = 0,
# define DT_UNKNOWN	DT_UNKNOWN
    DT_FIFO = 1,
# define DT_FIFO	DT_FIFO
    DT_CHR = 2,
# define DT_CHR		DT_CHR
    DT_DIR = 4,
# define DT_DIR		DT_DIR
    DT_BLK = 6,
# define DT_BLK		DT_BLK
    DT_REG = 8,
# define DT_REG		DT_REG
    DT_LNK = 10,
# define DT_LNK		DT_LNK
    DT_SOCK = 12,
# define DT_SOCK	DT_SOCK
    DT_WHT = 14
# define DT_WHT		DT_WHT
  };

/* Convert between stat structure types and directory types.  */
# define IFTODT(mode)	(((mode) & 0170000) >> 12)
# define DTTOIF(dirtype)	((dirtype) << 12)
#endif


/* This is the data type of directory stream objects.
   The actual structure is opaque to users.  */
typedef struct __dirstream DIR;

/* Open a directory stream on NAME.
   Return a DIR stream on the directory, or NULL if it could not be opened.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern DIR *opendir (__const char *__name);

/* Close the directory stream DIRP.
   Return 0 if successful, -1 if not.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern int closedir (DIR *__dirp);

/* Read a directory entry from DIRP.  Return a pointer to a `struct
   dirent' describing the entry, or NULL for EOF or error.  The
   storage returned may be overwritten by a later readdir call on the
   same DIR stream.

   If the Large File Support API is selected we have to use the
   appropriate interface.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
#ifndef __USE_FILE_OFFSET64
extern struct dirent *readdir (DIR *__dirp);
#else
# ifdef __REDIRECT
extern struct dirent *__REDIRECT (readdir, (DIR *__dirp), readdir64);
# else
#  define readdir readdir64
# endif
#endif

#ifdef __USE_LARGEFILE64
extern struct dirent64 *readdir64 (DIR *__dirp);
#endif

#if defined __USE_POSIX || defined __USE_MISC
/* Reentrant version of `readdir'.  Return in RESULT a pointer to the
   next entry.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
# ifndef __USE_FILE_OFFSET64
extern int readdir_r (DIR *__restrict __dirp,
		      struct dirent *__restrict __entry,
		      struct dirent **__restrict __result);
# else
#  ifdef __REDIRECT
extern int __REDIRECT (readdir_r,
		       (DIR *__restrict __dirp,
			struct dirent *__restrict __entry,
			struct dirent **__restrict __result),
		       readdir64_r);
#  else
#   define readdir_r readdir64_r
#  endif
# endif

# ifdef __USE_LARGEFILE64
extern int readdir64_r (DIR *__restrict __dirp,
			struct dirent64 *__restrict __entry,
			struct dirent64 **__restrict __result);
# endif
#endif	/* POSIX or misc */

/* Rewind DIRP to the beginning of the directory.  */
extern void rewinddir (DIR *__dirp) __THROW;

#if defined __USE_BSD || defined __USE_MISC || defined __USE_XOPEN
# include <bits/types.h>

/* Seek to position POS on DIRP.  */
extern void seekdir (DIR *__dirp, long int __pos) __THROW;

/* Return the current position of DIRP.  */
extern long int telldir (DIR *__dirp) __THROW;
#endif

#if defined __USE_BSD || defined __USE_MISC

/* Return the file descriptor used by DIRP.  */
extern int dirfd (DIR *__dirp) __THROW;

# if defined __OPTIMIZE__ && defined _DIR_dirfd
#  define dirfd(dirp)	_DIR_dirfd (dirp)
# endif

# ifndef MAXNAMLEN
/* Get the definitions of the POSIX.1 limits.  */
#  include <bits/posix1_lim.h>

/* `MAXNAMLEN' is the BSD name for what POSIX calls `NAME_MAX'.  */
#  ifdef NAME_MAX
#   define MAXNAMLEN	NAME_MAX
#  else
#   define MAXNAMLEN	255
#  endif
# endif

# define __need_size_t
# include <stddef.h>

/* Scan the directory DIR, calling SELECTOR on each directory entry.
   Entries for which SELECT returns nonzero are individually malloc'd,
   sorted using qsort with CMP, and collected in a malloc'd array in
   *NAMELIST.  Returns the number of entries selected, or -1 on error.  */
# ifndef __USE_FILE_OFFSET64
extern int scandir (__const char *__restrict __dir,
		    struct dirent ***__restrict __namelist,
		    int (*__selector) (__const struct dirent *),
		    int (*__cmp) (__const void *, __const void *));
# else
#  ifdef __REDIRECT
extern int __REDIRECT (scandir,
		       (__const char *__restrict __dir,
			struct dirent ***__restrict __namelist,
			int (*__selector) (__const struct dirent *),
			int (*__cmp) (__const void *, __const void *)),
		       scandir64);
#  else
#   define scandir scandir64
#  endif
# endif

# if defined __USE_GNU && defined __USE_LARGEFILE64
/* This function is like `scandir' but it uses the 64bit dirent structure.
   Please note that the CMP function must now work with struct dirent64 **.  */
extern int scandir64 (__const char *__restrict __dir,
		      struct dirent64 ***__restrict __namelist,
		      int (*__selector) (__const struct dirent64 *),
		      int (*__cmp) (__const void *, __const void *));
# endif

/* Function to compare two `struct dirent's alphabetically.  */
# ifndef __USE_FILE_OFFSET64
extern int alphasort (__const void *__e1, __const void *__e2)
     __THROW __attribute_pure__;
# else
#  ifdef __REDIRECT
extern int __REDIRECT (alphasort,
		       (__const void *__e1, __const void *__e2) __THROW,
		       alphasort64) __attribute_pure__;
#  else
#   define alphasort alphasort64
#  endif
# endif

# if defined __USE_GNU && defined __USE_LARGEFILE64
extern int alphasort64 (__const void *__e1, __const void *__e2)
     __THROW __attribute_pure__;
# endif

# ifdef __USE_GNU
/* Function to compare two `struct dirent's by name & version.  */
#  ifndef __USE_FILE_OFFSET64
extern int versionsort (__const void *__e1, __const void *__e2)
     __THROW __attribute_pure__;
#  else
#   ifdef __REDIRECT
extern int __REDIRECT (versionsort,
		       (__const void *__e1, __const void *__e2) __THROW,
		       versionsort64) __attribute_pure__;
#   else
#    define versionsort versionsort64
#   endif
#  endif

#  ifdef __USE_LARGEFILE64
extern int versionsort64 (__const void *__e1, __const void *__e2)
     __THROW __attribute_pure__;
#  endif
# endif

/* Read directory entries from FD into BUF, reading at most NBYTES.
   Reading starts at offset *BASEP, and *BASEP is updated with the new
   position after reading.  Returns the number of bytes read; zero when at
   end of directory; or -1 for errors.  */
# ifndef __USE_FILE_OFFSET64
extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
				size_t __nbytes,
				__off_t *__restrict __basep) __THROW;
# else
#  ifdef __REDIRECT
extern __ssize_t __REDIRECT (getdirentries,
			     (int __fd, char *__restrict __buf,
			      size_t __nbytes,
			      __off64_t *__restrict __basep) __THROW,
			     getdirentries64);
#  else
#   define getdirentries getdirentries64
#  endif
# endif

# ifdef __USE_LARGEFILE64
extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
				  size_t __nbytes,
				  __off64_t *__restrict __basep) __THROW;
# endif

#endif /* Use BSD or misc.  */

__END_DECLS

#endif /* dirent.h  */
Commit	Line	Data
2c008571	1	/* Copyright (C) 1991-1999, 2000, 2003 Free Software Foundation, Inc.
54d79e99	2	This file is part of the GNU C Library.
28f540f4	3
54d79e99	4	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	5	modify it under the terms of the GNU Lesser General Public
	6	License as published by the Free Software Foundation; either
	7	version 2.1 of the License, or (at your option) any later version.
28f540f4	8
54d79e99 UD	9	The GNU C Library is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2	12	Lesser General Public License for more details.
28f540f4	13
41bdb6e2 AJ	14	You should have received a copy of the GNU Lesser General Public
	15	License along with the GNU C Library; if not, write to the Free
	16	Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	17	02111-1307 USA. */
28f540f4 RM	18
	19	/*
	20	* POSIX Standard: 5.1.2 Directory Operations <dirent.h>
	21	*/
	22
	23	#ifndef _DIRENT_H
28f540f4	24	#define _DIRENT_H 1
5107cf1d	25
28f540f4 RM	26	#include <features.h>
	27
	28	__BEGIN_DECLS
	29
5107cf1d	30	#include <bits/types.h>
28f540f4	31
70b2845f UD	32	#ifdef __USE_XOPEN
	33	# ifndef __ino_t_defined
	34	# ifndef __USE_FILE_OFFSET64
	35	typedef __ino_t ino_t;
	36	# else
	37	typedef __ino64_t ino_t;
	38	# endif
	39	# define __ino_t_defined
	40	# endif
8353b5f6	41	# if defined __USE_LARGEFILE64 && !defined __ino64_t_defined
70b2845f	42	typedef __ino64_t ino64_t;
8353b5f6	43	# define __ino64_t_defined
70b2845f UD	44	# endif
	45	#endif
	46
92777700	47	/* This file defines `struct dirent'.
bfc04a9f	48
92777700 RM	49	It defines the macro `_DIRENT_HAVE_D_NAMLEN' iff there is a `d_namlen'
92777700 RM	50	member that gives the length of `d_name'.
bfc04a9f	51
92777700	52	It defines the macro `_DIRENT_HAVE_D_RECLEN' iff there is a `d_reclen'
a1470b6f RM	53	member that gives the size of the entire directory entry.
	54
	55	It defines the macro `_DIRENT_HAVE_D_OFF' iff there is a `d_off'
	56	member that gives the file offset of the next directory entry.
c0e45674 UD	57
	58	It defines the macro `_DIRENT_HAVE_D_TYPE' iff there is a `d_type'
	59	member that gives the type of the file.
a1470b6f	60	*/
bfc04a9f	61
5107cf1d	62	#include <bits/dirent.h>
28f540f4	63
c0e45674 UD	64	#if (defined __USE_BSD \|\| defined __USE_MISC) && !defined d_fileno
c0e45674 UD	65	# define d_ino d_fileno /* Backward compatibility. */
28f540f4 RM	66	#endif
28f540f4 RM	67
92777700 RM	68	/* These macros extract size information from a `struct dirent *'.
	69	They may evaluate their argument multiple times, so it must not
	70	have side effects. Each of these may involve a relatively costly
	71	call to `strlen' on some systems, so these values should be cached.
	72
	73	_D_EXACT_NAMLEN (DP) returns the length of DP->d_name, not including
	74	its terminating null character.
	75
	76	_D_ALLOC_NAMLEN (DP) returns a size at least (_D_EXACT_NAMLEN (DP) + 1);
	77	that is, the allocation size needed to hold the DP->d_name string.
	78	Use this macro when you don't need the exact length, just an upper bound.
	79	This macro is less likely to require calling `strlen' than _D_EXACT_NAMLEN.
	80	*/
	81
	82	#ifdef _DIRENT_HAVE_D_NAMLEN
c0e45674 UD	83	# define _D_EXACT_NAMLEN(d) ((d)->d_namlen)
c0e45674 UD	84	# define _D_ALLOC_NAMLEN(d) (_D_EXACT_NAMLEN (d) + 1)
92777700	85	#else
c0e45674 UD	86	# define _D_EXACT_NAMLEN(d) (strlen ((d)->d_name))
	87	# ifdef _DIRENT_HAVE_D_RECLEN
	88	# define _D_ALLOC_NAMLEN(d) (((char *) (d) + (d)->d_reclen) - &(d)->d_name[0])
	89	# else
	90	# define _D_ALLOC_NAMLEN(d) (sizeof (d)->d_name > 1 ? sizeof (d)->d_name : \
	91	_D_EXACT_NAMLEN (d) + 1)
	92	# endif
92777700 RM	93	#endif
	94
	95
28f540f4 RM	96	#ifdef __USE_BSD
	97	/* File types for `d_type'. */
	98	enum
	99	{
	100	DT_UNKNOWN = 0,
74015205	101	# define DT_UNKNOWN DT_UNKNOWN
28f540f4	102	DT_FIFO = 1,
74015205	103	# define DT_FIFO DT_FIFO
28f540f4	104	DT_CHR = 2,
74015205	105	# define DT_CHR DT_CHR
28f540f4	106	DT_DIR = 4,
74015205	107	# define DT_DIR DT_DIR
28f540f4	108	DT_BLK = 6,
74015205	109	# define DT_BLK DT_BLK
28f540f4	110	DT_REG = 8,
74015205	111	# define DT_REG DT_REG
28f540f4	112	DT_LNK = 10,
74015205	113	# define DT_LNK DT_LNK
21f6a100	114	DT_SOCK = 12,
74015205	115	# define DT_SOCK DT_SOCK
21f6a100 UD	116	DT_WHT = 14
21f6a100 UD	117	# define DT_WHT DT_WHT
28f540f4 RM	118	};
	119
	120	/* Convert between stat structure types and directory types. */
c0e45674 UD	121	# define IFTODT(mode) (((mode) & 0170000) >> 12)
c0e45674 UD	122	# define DTTOIF(dirtype) ((dirtype) << 12)
28f540f4 RM	123	#endif
	124
	125
18926cf4 RM	126	/* This is the data type of directory stream objects.
	127	The actual structure is opaque to users. */
	128	typedef struct __dirstream DIR;
28f540f4 RM	129
28f540f4 RM	130	/* Open a directory stream on NAME.
2c008571 UD	131	Return a DIR stream on the directory, or NULL if it could not be opened.
	132
	133	This function is a possible cancellation point and therefore not
	134	marked with __THROW. */
	135	extern DIR opendir (__const char __name);
28f540f4 RM	136
28f540f4 RM	137	/* Close the directory stream DIRP.
2c008571 UD	138	Return 0 if successful, -1 if not.
	139
	140	This function is a possible cancellation point and therefore not
	141	marked with __THROW. */
	142	extern int closedir (DIR *__dirp);
28f540f4	143
dfd2257a UD	144	/* Read a directory entry from DIRP. Return a pointer to a `struct
	145	dirent' describing the entry, or NULL for EOF or error. The
	146	storage returned may be overwritten by a later readdir call on the
	147	same DIR stream.
	148
	149	If the Large File Support API is selected we have to use the
2c008571 UD	150	appropriate interface.
	151
	152	This function is a possible cancellation point and therefore not
	153	marked with __THROW. */
dfd2257a	154	#ifndef __USE_FILE_OFFSET64
2c008571	155	extern struct dirent readdir (DIR __dirp);
dfd2257a	156	#else
01cad722	157	# ifdef __REDIRECT
2c008571	158	extern struct dirent __REDIRECT (readdir, (DIR __dirp), readdir64);
01cad722 UD	159	# else
	160	# define readdir readdir64
	161	# endif
dfd2257a UD	162	#endif
	163
	164	#ifdef __USE_LARGEFILE64
2c008571	165	extern struct dirent64 readdir64 (DIR __dirp);
dfd2257a	166	#endif
28f540f4	167
c0e45674	168	#if defined __USE_POSIX \|\| defined __USE_MISC
6d52618b	169	/* Reentrant version of `readdir'. Return in RESULT a pointer to the
2c008571 UD	170	next entry.
	171
	172	This function is a possible cancellation point and therefore not
	173	marked with __THROW. */
dfd2257a	174	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	175	extern int readdir_r (DIR *__restrict __dirp,
c1422e5b UD	176	struct dirent *__restrict __entry,
2c008571	177	struct dirent **__restrict __result);
dfd2257a	178	# else
01cad722	179	# ifdef __REDIRECT
c1422e5b UD	180	extern int __REDIRECT (readdir_r,
	181	(DIR *__restrict __dirp,
	182	struct dirent *__restrict __entry,
2c008571	183	struct dirent **__restrict __result),
c1422e5b	184	readdir64_r);
01cad722 UD	185	# else
	186	# define readdir_r readdir64_r
	187	# endif
dfd2257a UD	188	# endif
	189
	190	# ifdef __USE_LARGEFILE64
c1422e5b UD	191	extern int readdir64_r (DIR *__restrict __dirp,
c1422e5b UD	192	struct dirent64 *__restrict __entry,
2c008571	193	struct dirent64 **__restrict __result);
dfd2257a	194	# endif
c0e45674	195	#endif /* POSIX or misc */
d68171ed	196
28f540f4	197	/* Rewind DIRP to the beginning of the directory. */
c1422e5b	198	extern void rewinddir (DIR *__dirp) __THROW;
28f540f4	199
40a55d20 UD	200	#if defined __USE_BSD \|\| defined __USE_MISC \|\| defined __USE_XOPEN
	201	# include <bits/types.h>
	202
	203	/* Seek to position POS on DIRP. */
c1422e5b	204	extern void seekdir (DIR *__dirp, long int __pos) __THROW;
40a55d20 UD	205
40a55d20 UD	206	/* Return the current position of DIRP. */
c1422e5b	207	extern long int telldir (DIR *__dirp) __THROW;
40a55d20 UD	208	#endif
40a55d20 UD	209
c0e45674	210	#if defined __USE_BSD \|\| defined __USE_MISC
28f540f4	211
22a1292a	212	/* Return the file descriptor used by DIRP. */
c1422e5b	213	extern int dirfd (DIR *__dirp) __THROW;
22a1292a	214
c0e45674 UD	215	# if defined __OPTIMIZE__ && defined _DIR_dirfd
	216	# define dirfd(dirp) _DIR_dirfd (dirp)
	217	# endif
22a1292a	218
c0e45674	219	# ifndef MAXNAMLEN
28f540f4	220	/* Get the definitions of the POSIX.1 limits. */
5107cf1d	221	# include <bits/posix1_lim.h>
28f540f4 RM	222
28f540f4 RM	223	/* `MAXNAMLEN' is the BSD name for what POSIX calls `NAME_MAX'. */
c0e45674 UD	224	# ifdef NAME_MAX
	225	# define MAXNAMLEN NAME_MAX
	226	# else
	227	# define MAXNAMLEN 255
	228	# endif
	229	# endif
	230
c0e45674 UD	231	# define __need_size_t
c0e45674 UD	232	# include <stddef.h>
28f540f4	233
afd4eb37	234	/* Scan the directory DIR, calling SELECTOR on each directory entry.
28f540f4 RM	235	Entries for which SELECT returns nonzero are individually malloc'd,
	236	sorted using qsort with CMP, and collected in a malloc'd array in
	237	NAMELIST. Returns the number of entries selected, or -1 on error. /
89a9e37b	238	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	239	extern int scandir (__const char *__restrict __dir,
	240	struct dirent ***__restrict __namelist,
	241	int (__selector) (__const struct dirent ),
b6cfea12	242	int (__cmp) (__const void , __const void *));
89a9e37b	243	# else
01cad722 UD	244	# ifdef __REDIRECT
01cad722 UD	245	extern int __REDIRECT (scandir,
c1422e5b UD	246	(__const char *__restrict __dir,
	247	struct dirent ***__restrict __namelist,
	248	int (__selector) (__const struct dirent ),
b6cfea12	249	int (__cmp) (__const void , __const void *)),
01cad722 UD	250	scandir64);
	251	# else
	252	# define scandir scandir64
	253	# endif
89a9e37b UD	254	# endif
	255
	256	# if defined __USE_GNU && defined __USE_LARGEFILE64
	257	/* This function is like `scandir' but it uses the 64bit dirent structure.
	258	Please note that the CMP function must now work with struct dirent64 *. /
c1422e5b UD	259	extern int scandir64 (__const char *__restrict __dir,
	260	struct dirent64 ***__restrict __namelist,
	261	int (__selector) (__const struct dirent64 ),
b6cfea12	262	int (__cmp) (__const void , __const void *));
89a9e37b	263	# endif
28f540f4 RM	264
28f540f4 RM	265	/* Function to compare two `struct dirent's alphabetically. */
89a9e37b	266	# ifndef __USE_FILE_OFFSET64
fb4dfa0c AJ	267	extern int alphasort (__const void __e1, __const void __e2)
fb4dfa0c AJ	268	__THROW __attribute_pure__;
89a9e37b	269	# else
01cad722 UD	270	# ifdef __REDIRECT
01cad722 UD	271	extern int __REDIRECT (alphasort,
b6cfea12	272	(__const void __e1, __const void __e2) __THROW,
2c1394a8	273	alphasort64) __attribute_pure__;
01cad722 UD	274	# else
	275	# define alphasort alphasort64
	276	# endif
89a9e37b UD	277	# endif
	278
	279	# if defined __USE_GNU && defined __USE_LARGEFILE64
fb4dfa0c AJ	280	extern int alphasort64 (__const void __e1, __const void __e2)
fb4dfa0c AJ	281	__THROW __attribute_pure__;
89a9e37b	282	# endif
28f540f4	283
1f205a47 UD	284	# ifdef __USE_GNU
1f205a47 UD	285	/* Function to compare two `struct dirent's by name & version. */
89a9e37b	286	# ifndef __USE_FILE_OFFSET64
fb4dfa0c AJ	287	extern int versionsort (__const void __e1, __const void __e2)
fb4dfa0c AJ	288	__THROW __attribute_pure__;
89a9e37b	289	# else
01cad722 UD	290	# ifdef __REDIRECT
01cad722 UD	291	extern int __REDIRECT (versionsort,
b6cfea12	292	(__const void __e1, __const void __e2) __THROW,
2c1394a8	293	versionsort64) __attribute_pure__;
01cad722 UD	294	# else
	295	# define versionsort versionsort64
	296	# endif
89a9e37b UD	297	# endif
	298
	299	# ifdef __USE_LARGEFILE64
fb4dfa0c AJ	300	extern int versionsort64 (__const void __e1, __const void __e2)
fb4dfa0c AJ	301	__THROW __attribute_pure__;
89a9e37b	302	# endif
40a55d20	303	# endif
28f540f4 RM	304
	305	/* Read directory entries from FD into BUF, reading at most NBYTES.
	306	Reading starts at offset BASEP, and BASEP is updated with the new
	307	position after reading. Returns the number of bytes read; zero when at
	308	end of directory; or -1 for errors. */
e5cd813b	309	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	310	extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
	311	size_t __nbytes,
	312	__off_t *__restrict __basep) __THROW;
e5cd813b UD	313	# else
	314	# ifdef __REDIRECT
	315	extern __ssize_t __REDIRECT (getdirentries,
c1422e5b UD	316	(int __fd, char *__restrict __buf,
c1422e5b UD	317	size_t __nbytes,
b51094bd	318	__off64_t *__restrict __basep) __THROW,
e5cd813b UD	319	getdirentries64);
	320	# else
	321	# define getdirentries getdirentries64
	322	# endif
	323	# endif
28f540f4	324
e5cd813b	325	# ifdef __USE_LARGEFILE64
c1422e5b UD	326	extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
	327	size_t __nbytes,
	328	__off64_t *__restrict __basep) __THROW;
e5cd813b	329	# endif
28f540f4 RM	330
	331	#endif /* Use BSD or misc. */
	332
	333	__END_DECLS
	334
	335	#endif /* dirent.h */