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

/* Copyright (C) 1991-2000, 2003, 2004, 2005 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) __nonnull ((1));

#ifdef __USE_GNU
/* Same as opendir, but open the stream on the file descriptor FD.

   This function is a possible cancellation point and therefore not
   marked with __THROW.  */
extern DIR *fdopendir (int __fd);
#endif

/* 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) __nonnull ((1));

/* 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) __nonnull ((1));
#else
# ifdef __REDIRECT
extern struct dirent *__REDIRECT (readdir, (DIR *__dirp), readdir64)
     __nonnull ((1));
# else
#  define readdir readdir64
# endif
#endif

#ifdef __USE_LARGEFILE64
extern struct dirent64 *readdir64 (DIR *__dirp) __nonnull ((1));
#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)
     __nonnull ((1, 2, 3));
# else
#  ifdef __REDIRECT
extern int __REDIRECT (readdir_r,
		       (DIR *__restrict __dirp,
			struct dirent *__restrict __entry,
			struct dirent **__restrict __result),
		       readdir64_r) __nonnull ((1, 2, 3));
#  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)
     __nonnull ((1, 2, 3));
# endif
#endif	/* POSIX or misc */

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

#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 __nonnull ((1));

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

#if defined __USE_BSD || defined __USE_MISC

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

# 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 *))
     __nonnull ((1, 2));
# 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) __nonnull ((1, 2));
#  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 *))
     __nonnull ((1, 2));
# 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__ __nonnull ((1, 2));
# else
#  ifdef __REDIRECT
extern int __REDIRECT_NTH (alphasort,
			   (__const void *__e1, __const void *__e2),
			   alphasort64) __attribute_pure__ __nonnull ((1, 2));
#  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__ __nonnull ((1, 2));
# 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__ __nonnull ((1, 2));
#  else
#   ifdef __REDIRECT
extern int __REDIRECT_NTH (versionsort,
			   (__const void *__e1, __const void *__e2),
			   versionsort64)
     __attribute_pure__ __nonnull ((1, 2));
#   else
#    define versionsort versionsort64
#   endif
#  endif

#  ifdef __USE_LARGEFILE64
extern int versionsort64 (__const void *__e1, __const void *__e2)
     __THROW __attribute_pure__ __nonnull ((1, 2));
#  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 __nonnull ((2, 4));
# else
#  ifdef __REDIRECT
extern __ssize_t __REDIRECT_NTH (getdirentries,
				 (int __fd, char *__restrict __buf,
				  size_t __nbytes,
				  __off64_t *__restrict __basep),
				 getdirentries64) __nonnull ((2, 4));
#  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 __nonnull ((2, 4));
# endif

#endif /* Use BSD or misc.  */

__END_DECLS

#endif /* dirent.h  */
Commit	Line	Data
1812d50b	1	/* Copyright (C) 1991-2000, 2003, 2004, 2005 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. */
b45ff182	135	extern DIR opendir (__const char __name) __nonnull ((1));
28f540f4	136
1812d50b UD	137	#ifdef __USE_GNU
	138	/* Same as opendir, but open the stream on the file descriptor FD.
	139
	140	This function is a possible cancellation point and therefore not
	141	marked with __THROW. */
	142	extern DIR *fdopendir (int __fd);
	143	#endif
	144
28f540f4	145	/* Close the directory stream DIRP.
2c008571 UD	146	Return 0 if successful, -1 if not.
	147
	148	This function is a possible cancellation point and therefore not
	149	marked with __THROW. */
b45ff182	150	extern int closedir (DIR *__dirp) __nonnull ((1));
28f540f4	151
dfd2257a UD	152	/* Read a directory entry from DIRP. Return a pointer to a `struct
	153	dirent' describing the entry, or NULL for EOF or error. The
	154	storage returned may be overwritten by a later readdir call on the
	155	same DIR stream.
	156
	157	If the Large File Support API is selected we have to use the
2c008571 UD	158	appropriate interface.
	159
	160	This function is a possible cancellation point and therefore not
	161	marked with __THROW. */
dfd2257a	162	#ifndef __USE_FILE_OFFSET64
b45ff182	163	extern struct dirent readdir (DIR __dirp) __nonnull ((1));
dfd2257a	164	#else
01cad722	165	# ifdef __REDIRECT
b45ff182 UD	166	extern struct dirent __REDIRECT (readdir, (DIR __dirp), readdir64)
b45ff182 UD	167	__nonnull ((1));
01cad722 UD	168	# else
	169	# define readdir readdir64
	170	# endif
dfd2257a UD	171	#endif
	172
	173	#ifdef __USE_LARGEFILE64
b45ff182	174	extern struct dirent64 readdir64 (DIR __dirp) __nonnull ((1));
dfd2257a	175	#endif
28f540f4	176
c0e45674	177	#if defined __USE_POSIX \|\| defined __USE_MISC
6d52618b	178	/* Reentrant version of `readdir'. Return in RESULT a pointer to the
2c008571 UD	179	next entry.
	180
	181	This function is a possible cancellation point and therefore not
	182	marked with __THROW. */
dfd2257a	183	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	184	extern int readdir_r (DIR *__restrict __dirp,
c1422e5b UD	185	struct dirent *__restrict __entry,
b45ff182 UD	186	struct dirent **__restrict __result)
b45ff182 UD	187	__nonnull ((1, 2, 3));
dfd2257a	188	# else
01cad722	189	# ifdef __REDIRECT
c1422e5b UD	190	extern int __REDIRECT (readdir_r,
	191	(DIR *__restrict __dirp,
	192	struct dirent *__restrict __entry,
2c008571	193	struct dirent **__restrict __result),
b45ff182	194	readdir64_r) __nonnull ((1, 2, 3));
01cad722 UD	195	# else
	196	# define readdir_r readdir64_r
	197	# endif
dfd2257a UD	198	# endif
	199
	200	# ifdef __USE_LARGEFILE64
c1422e5b UD	201	extern int readdir64_r (DIR *__restrict __dirp,
c1422e5b UD	202	struct dirent64 *__restrict __entry,
b45ff182 UD	203	struct dirent64 **__restrict __result)
b45ff182 UD	204	__nonnull ((1, 2, 3));
dfd2257a	205	# endif
c0e45674	206	#endif /* POSIX or misc */
d68171ed	207
28f540f4	208	/* Rewind DIRP to the beginning of the directory. */
b45ff182	209	extern void rewinddir (DIR *__dirp) __THROW __nonnull ((1));
28f540f4	210
40a55d20 UD	211	#if defined __USE_BSD \|\| defined __USE_MISC \|\| defined __USE_XOPEN
	212	# include <bits/types.h>
	213
	214	/* Seek to position POS on DIRP. */
b45ff182	215	extern void seekdir (DIR *__dirp, long int __pos) __THROW __nonnull ((1));
40a55d20 UD	216
40a55d20 UD	217	/* Return the current position of DIRP. */
b45ff182	218	extern long int telldir (DIR *__dirp) __THROW __nonnull ((1));
40a55d20 UD	219	#endif
40a55d20 UD	220
c0e45674	221	#if defined __USE_BSD \|\| defined __USE_MISC
28f540f4	222
22a1292a	223	/* Return the file descriptor used by DIRP. */
b45ff182	224	extern int dirfd (DIR *__dirp) __THROW __nonnull ((1));
22a1292a	225
c0e45674 UD	226	# if defined __OPTIMIZE__ && defined _DIR_dirfd
	227	# define dirfd(dirp) _DIR_dirfd (dirp)
	228	# endif
22a1292a	229
c0e45674	230	# ifndef MAXNAMLEN
28f540f4	231	/* Get the definitions of the POSIX.1 limits. */
5107cf1d	232	# include <bits/posix1_lim.h>
28f540f4 RM	233
28f540f4 RM	234	/* `MAXNAMLEN' is the BSD name for what POSIX calls `NAME_MAX'. */
c0e45674 UD	235	# ifdef NAME_MAX
	236	# define MAXNAMLEN NAME_MAX
	237	# else
	238	# define MAXNAMLEN 255
	239	# endif
	240	# endif
	241
c0e45674 UD	242	# define __need_size_t
c0e45674 UD	243	# include <stddef.h>
28f540f4	244
afd4eb37	245	/* Scan the directory DIR, calling SELECTOR on each directory entry.
28f540f4 RM	246	Entries for which SELECT returns nonzero are individually malloc'd,
	247	sorted using qsort with CMP, and collected in a malloc'd array in
	248	NAMELIST. Returns the number of entries selected, or -1 on error. /
89a9e37b	249	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	250	extern int scandir (__const char *__restrict __dir,
	251	struct dirent ***__restrict __namelist,
	252	int (__selector) (__const struct dirent ),
b45ff182 UD	253	int (__cmp) (__const void , __const void *))
b45ff182 UD	254	__nonnull ((1, 2));
89a9e37b	255	# else
01cad722 UD	256	# ifdef __REDIRECT
01cad722 UD	257	extern int __REDIRECT (scandir,
c1422e5b UD	258	(__const char *__restrict __dir,
	259	struct dirent ***__restrict __namelist,
	260	int (__selector) (__const struct dirent ),
b6cfea12	261	int (__cmp) (__const void , __const void *)),
b45ff182	262	scandir64) __nonnull ((1, 2));
01cad722 UD	263	# else
	264	# define scandir scandir64
	265	# endif
89a9e37b UD	266	# endif
	267
	268	# if defined __USE_GNU && defined __USE_LARGEFILE64
	269	/* This function is like `scandir' but it uses the 64bit dirent structure.
	270	Please note that the CMP function must now work with struct dirent64 *. /
c1422e5b UD	271	extern int scandir64 (__const char *__restrict __dir,
	272	struct dirent64 ***__restrict __namelist,
	273	int (__selector) (__const struct dirent64 ),
b45ff182 UD	274	int (__cmp) (__const void , __const void *))
b45ff182 UD	275	__nonnull ((1, 2));
89a9e37b	276	# endif
28f540f4 RM	277
28f540f4 RM	278	/* Function to compare two `struct dirent's alphabetically. */
89a9e37b	279	# ifndef __USE_FILE_OFFSET64
fb4dfa0c	280	extern int alphasort (__const void __e1, __const void __e2)
b45ff182	281	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	282	# else
01cad722	283	# ifdef __REDIRECT
f377d022 UD	284	extern int __REDIRECT_NTH (alphasort,
f377d022 UD	285	(__const void __e1, __const void __e2),
b45ff182	286	alphasort64) __attribute_pure__ __nonnull ((1, 2));
01cad722 UD	287	# else
	288	# define alphasort alphasort64
	289	# endif
89a9e37b UD	290	# endif
	291
	292	# if defined __USE_GNU && defined __USE_LARGEFILE64
fb4dfa0c	293	extern int alphasort64 (__const void __e1, __const void __e2)
b45ff182	294	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	295	# endif
28f540f4	296
1f205a47 UD	297	# ifdef __USE_GNU
1f205a47 UD	298	/* Function to compare two `struct dirent's by name & version. */
89a9e37b	299	# ifndef __USE_FILE_OFFSET64
fb4dfa0c	300	extern int versionsort (__const void __e1, __const void __e2)
b45ff182	301	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	302	# else
01cad722	303	# ifdef __REDIRECT
f377d022 UD	304	extern int __REDIRECT_NTH (versionsort,
f377d022 UD	305	(__const void __e1, __const void __e2),
b45ff182 UD	306	versionsort64)
b45ff182 UD	307	__attribute_pure__ __nonnull ((1, 2));
01cad722 UD	308	# else
	309	# define versionsort versionsort64
	310	# endif
89a9e37b UD	311	# endif
	312
	313	# ifdef __USE_LARGEFILE64
fb4dfa0c	314	extern int versionsort64 (__const void __e1, __const void __e2)
b45ff182	315	__THROW __attribute_pure__ __nonnull ((1, 2));
89a9e37b	316	# endif
40a55d20	317	# endif
28f540f4 RM	318
	319	/* Read directory entries from FD into BUF, reading at most NBYTES.
	320	Reading starts at offset BASEP, and BASEP is updated with the new
	321	position after reading. Returns the number of bytes read; zero when at
	322	end of directory; or -1 for errors. */
e5cd813b	323	# ifndef __USE_FILE_OFFSET64
c1422e5b UD	324	extern __ssize_t getdirentries (int __fd, char *__restrict __buf,
c1422e5b UD	325	size_t __nbytes,
b45ff182 UD	326	__off_t *__restrict __basep)
b45ff182 UD	327	__THROW __nonnull ((2, 4));
e5cd813b UD	328	# else
e5cd813b UD	329	# ifdef __REDIRECT
f377d022 UD	330	extern __ssize_t __REDIRECT_NTH (getdirentries,
	331	(int __fd, char *__restrict __buf,
	332	size_t __nbytes,
	333	__off64_t *__restrict __basep),
b45ff182	334	getdirentries64) __nonnull ((2, 4));
e5cd813b UD	335	# else
	336	# define getdirentries getdirentries64
	337	# endif
	338	# endif
28f540f4	339
e5cd813b	340	# ifdef __USE_LARGEFILE64
c1422e5b UD	341	extern __ssize_t getdirentries64 (int __fd, char *__restrict __buf,
c1422e5b UD	342	size_t __nbytes,
b45ff182 UD	343	__off64_t *__restrict __basep)
b45ff182 UD	344	__THROW __nonnull ((2, 4));
e5cd813b	345	# endif
28f540f4 RM	346
	347	#endif /* Use BSD or misc. */
	348
	349	__END_DECLS
	350
	351	#endif /* dirent.h */