Parsing a string with a grammar taking forever

[humanitiesclinic]

I finally have a grammar with no errors. However, when parsing a file, it takes very very long. Is there a way to know how long it is expected to take, and is there any way to make it faster? I tried enabling PEG but it seems to take forever as well.

The string to parse:

typedef signed char __int8_t;

typedef unsigned char __uint8_t;
typedef short __int16_t;
typedef unsigned short __uint16_t;
typedef int __int32_t;
typedef unsigned int __uint32_t;
typedef long long __int64_t;
typedef unsigned long long __uint64_t;

typedef long __darwin_intptr_t;
typedef unsigned int __darwin_natural_t;
typedef int __darwin_ct_rune_t;

typedef union {
 char __mbstate8[128];
 long long _mbstateL;
} __mbstate_t;

typedef __mbstate_t __darwin_mbstate_t;

typedef long int __darwin_ptrdiff_t;

typedef long unsigned int __darwin_size_t;

typedef __builtin_va_list __darwin_va_list;

typedef int __darwin_wchar_t;

typedef __darwin_wchar_t __darwin_rune_t;

typedef int __darwin_wint_t;

typedef unsigned long __darwin_clock_t;
typedef __uint32_t __darwin_socklen_t;
typedef long __darwin_ssize_t;
typedef long __darwin_time_t;
typedef __int64_t __darwin_blkcnt_t;
typedef __int32_t __darwin_blksize_t;
typedef __int32_t __darwin_dev_t;
typedef unsigned int __darwin_fsblkcnt_t;
typedef unsigned int __darwin_fsfilcnt_t;
typedef __uint32_t __darwin_gid_t;
typedef __uint32_t __darwin_id_t;
typedef __uint64_t __darwin_ino64_t;

typedef __darwin_ino64_t __darwin_ino_t;

typedef __darwin_natural_t __darwin_mach_port_name_t;
typedef __darwin_mach_port_name_t __darwin_mach_port_t;
typedef __uint16_t __darwin_mode_t;
typedef __int64_t __darwin_off_t;
typedef __int32_t __darwin_pid_t;
typedef __uint32_t __darwin_sigset_t;
typedef __int32_t __darwin_suseconds_t;
typedef __uint32_t __darwin_uid_t;
typedef __uint32_t __darwin_useconds_t;
typedef unsigned char __darwin_uuid_t[16];
typedef char __darwin_uuid_string_t[37];

struct __darwin_pthread_handler_rec {
 void (*__routine)(void *);
 void *__arg;
 struct __darwin_pthread_handler_rec *__next;
};

struct _opaque_pthread_attr_t {
 long __sig;
 char __opaque[56];
};

struct _opaque_pthread_cond_t {
 long __sig;
 char __opaque[40];
};

struct _opaque_pthread_condattr_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_mutex_t {
 long __sig;
 char __opaque[56];
};

struct _opaque_pthread_mutexattr_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_once_t {
 long __sig;
 char __opaque[8];
};

struct _opaque_pthread_rwlock_t {
 long __sig;
 char __opaque[192];
};

struct _opaque_pthread_rwlockattr_t {
 long __sig;
 char __opaque[16];
};

struct _opaque_pthread_t {
 long __sig;
 struct __darwin_pthread_handler_rec *__cleanup_stack;
 char __opaque[8176];
};

typedef struct _opaque_pthread_attr_t __darwin_pthread_attr_t;
typedef struct _opaque_pthread_cond_t __darwin_pthread_cond_t;
typedef struct _opaque_pthread_condattr_t __darwin_pthread_condattr_t;
typedef unsigned long __darwin_pthread_key_t;
typedef struct _opaque_pthread_mutex_t __darwin_pthread_mutex_t;
typedef struct _opaque_pthread_mutexattr_t __darwin_pthread_mutexattr_t;
typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
typedef struct _opaque_pthread_rwlock_t __darwin_pthread_rwlock_t;
typedef struct _opaque_pthread_rwlockattr_t __darwin_pthread_rwlockattr_t;
typedef struct _opaque_pthread_t *__darwin_pthread_t;
typedef int __darwin_nl_item;
typedef int __darwin_wctrans_t;

typedef __uint32_t __darwin_wctype_t;

typedef __darwin_size_t size_t;
typedef __darwin_mbstate_t mbstate_t;
typedef __darwin_ct_rune_t ct_rune_t;
typedef __darwin_rune_t rune_t;
typedef __darwin_wchar_t wchar_t;
typedef __builtin_va_list va_list;
typedef __builtin_va_list __gnuc_va_list;
typedef __darwin_va_list va_list;

int renameat(int, const char *, int, const char *) __attribute__((availability(macosx,introduced=10.10)));

typedef __darwin_off_t fpos_t;
struct __sbuf {
 unsigned char *_base;
 int _size;
};

struct __sFILEX;
typedef struct __sFILE {
 unsigned char *_p;
 int _r;
 int _w;
 short _flags;
 short _file;
 struct __sbuf _bf;
 int _lbfsize;

 void *_cookie;
 int (*_close)(void *);
 int (*_read) (void *, char *, int);
 fpos_t (*_seek) (void *, fpos_t, int);
 int (*_write)(void *, const char *, int);

 struct __sbuf _ub;
 struct __sFILEX *_extra;
 int _ur;

 unsigned char _ubuf[3];
 unsigned char _nbuf[1];

 struct __sbuf _lb;

 int _blksize;
 fpos_t _offset;
} FILE;

extern FILE *__stdinp;
extern FILE *__stdoutp;
extern FILE *__stderrp;
void clearerr(FILE *);
int fclose(FILE *);
int feof(FILE *);
int ferror(FILE *);
int fflush(FILE *);
int fgetc(FILE *);
int fgetpos(FILE * restrict, fpos_t *);
char *fgets(char * restrict, int, FILE *);

FILE *fopen(const char * restrict, const char * restrict) __asm("_" "fopen" );

int fprintf(FILE * restrict, const char * restrict, ...) __attribute__((__format__ (__printf__, 2, 3)));
int fputc(int, FILE *);
int fputs(const char * restrict, FILE * restrict) __asm("_" "fputs" );
size_t fread(void * restrict, size_t, size_t, FILE * restrict);
FILE *freopen(const char * restrict, const char * restrict,
                 FILE * restrict) __asm("_" "freopen" );
int fscanf(FILE * restrict, const char * restrict, ...) __attribute__((__format__ (__scanf__, 2, 3)));
int fseek(FILE *, long, int);
int fsetpos(FILE *, const fpos_t *);
long ftell(FILE *);
size_t fwrite(const void * restrict, size_t, size_t, FILE * restrict) __asm("_" "fwrite" );
int getc(FILE *);
int getchar(void);
char *gets(char *);
void perror(const char *);
int printf(const char * restrict, ...) __attribute__((__format__ (__printf__, 1, 2)));
int putc(int, FILE *);
int putchar(int);
int puts(const char *);
int remove(const char *);
int rename (const char *, const char *);
void rewind(FILE *);
int scanf(const char * restrict, ...) __attribute__((__format__ (__scanf__, 1, 2)));
void setbuf(FILE * restrict, char * restrict);
int setvbuf(FILE * restrict, char * restrict, int, size_t);
int sprintf(char * restrict, const char * restrict, ...) __attribute__((__format__ (__printf__, 2, 3)));
int sscanf(const char * restrict, const char * restrict, ...) __attribute__((__format__ (__scanf__, 2, 3)));
FILE *tmpfile(void);

__attribute__((deprecated("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tmpnam(3), it is highly recommended that you use mkstemp(3) instead.")))

char *tmpnam(char *);
int ungetc(int, FILE *);
int vfprintf(FILE * restrict, const char * restrict, va_list) __attribute__((__format__ (__printf__, 2, 0)));
int vprintf(const char * restrict, va_list) __attribute__((__format__ (__printf__, 1, 0)));
int vsprintf(char * restrict, const char * restrict, va_list) __attribute__((__format__ (__printf__, 2, 0)));
char *ctermid(char *);

FILE *fdopen(int, const char *) __asm("_" "fdopen" );

int fileno(FILE *);
int pclose(FILE *);

FILE *popen(const char *, const char *) __asm("_" "popen" );
int __srget(FILE *);
int __svfscanf(FILE *, const char *, va_list) __attribute__((__format__ (__scanf__, 2, 0)));
int __swbuf(int, FILE *);
inline __attribute__ ((__always_inline__)) int __sputc(int _c, FILE *_p) {
 if (--_p->_w >= 0 || (_p->_w >= _p->_lbfsize && (char)_c != '\n'))
  return (*_p->_p++ = _c);
 else
  return (__swbuf(_c, _p));
}
void flockfile(FILE *);
int ftrylockfile(FILE *);
void funlockfile(FILE *);
int getc_unlocked(FILE *);
int getchar_unlocked(void);
int putc_unlocked(int, FILE *);
int putchar_unlocked(int);

int getw(FILE *);
int putw(int, FILE *);

__attribute__((deprecated("This function is provided for compatibility reasons only.  Due to security concerns inherent in the design of tempnam(3), it is highly recommended that you use mkstemp(3) instead.")))

char *tempnam(const char *, const char *) __asm("_" "tempnam" );
typedef __darwin_off_t off_t;

int fseeko(FILE *, off_t, int);
off_t ftello(FILE *);

int snprintf(char * restrict, size_t, const char * restrict, ...) __attribute__((__format__ (__printf__, 3, 4)));
int vfscanf(FILE * restrict, const char * restrict, va_list) __attribute__((__format__ (__scanf__, 2, 0)));
int vscanf(const char * restrict, va_list) __attribute__((__format__ (__scanf__, 1, 0)));
int vsnprintf(char * restrict, size_t, const char * restrict, va_list) __attribute__((__format__ (__printf__, 3, 0)));
int vsscanf(const char * restrict, const char * restrict, va_list) __attribute__((__format__ (__scanf__, 2, 0)));
typedef __darwin_ssize_t ssize_t;

int dprintf(int, const char * restrict, ...) __attribute__((__format__ (__printf__, 2, 3))) __attribute__((availability(macosx,introduced=10.7)));
int vdprintf(int, const char * restrict, va_list) __attribute__((__format__ (__printf__, 2, 0))) __attribute__((availability(macosx,introduced=10.7)));
ssize_t getdelim(char ** restrict, size_t * restrict, int, FILE * restrict) __attribute__((availability(macosx,introduced=10.7)));
ssize_t getline(char ** restrict, size_t * restrict, FILE * restrict) __attribute__((availability(macosx,introduced=10.7)));
extern const int sys_nerr;
extern const char *const sys_errlist[];

int asprintf(char ** restrict, const char * restrict, ...) __attribute__((__format__ (__printf__, 2, 3)));
char *ctermid_r(char *);
char *fgetln(FILE *, size_t *);
const char *fmtcheck(const char *, const char *);
int fpurge(FILE *);
void setbuffer(FILE *, char *, int);
int setlinebuf(FILE *);
int vasprintf(char ** restrict, const char * restrict, va_list) __attribute__((__format__ (__printf__, 2, 0)));
FILE *zopen(const char *, const char *, int);

FILE *funopen(const void *,
                 int (*)(void *, char *, int),
                 int (*)(void *, const char *, int),
                 fpos_t (*)(void *, fpos_t, int),
                 int (*)(void *));
extern int __sprintf_chk (char * restrict, int, size_t,
     const char * restrict, ...);
extern int __snprintf_chk (char * restrict, size_t, int, size_t,
      const char * restrict, ...);

extern int __vsprintf_chk (char * restrict, int, size_t,
      const char * restrict, va_list);

extern int __vsnprintf_chk (char * restrict, size_t, int, size_t,
       const char * restrict, va_list);
typedef __darwin_clock_t clock_t;

typedef __darwin_time_t time_t;
struct timespec
{
 __darwin_time_t tv_sec;
 long tv_nsec;
};

struct tm {
 int tm_sec;
 int tm_min;
 int tm_hour;
 int tm_mday;
 int tm_mon;
 int tm_year;
 int tm_wday;
 int tm_yday;
 int tm_isdst;
 long tm_gmtoff;
 char *tm_zone;
};
extern char *tzname[];

extern int getdate_err;

extern long timezone __asm("_" "timezone" );

extern int daylight;

char *asctime(const struct tm *);
clock_t clock(void) __asm("_" "clock" );
char *ctime(const time_t *);
double difftime(time_t, time_t);
struct tm *getdate(const char *);
struct tm *gmtime(const time_t *);
struct tm *localtime(const time_t *);
time_t mktime(struct tm *) __asm("_" "mktime" );
size_t strftime(char * restrict, size_t, const char * restrict, const struct tm * restrict) __asm("_" "strftime" );
char *strptime(const char * restrict, const char * restrict, struct tm * restrict) __asm("_" "strptime" );
time_t time(time_t *);

void tzset(void);

char *asctime_r(const struct tm * restrict, char * restrict);
char *ctime_r(const time_t *, char *);
struct tm *gmtime_r(const time_t * restrict, struct tm * restrict);
struct tm *localtime_r(const time_t * restrict, struct tm * restrict);

time_t posix2time(time_t);

void tzsetwall(void);
time_t time2posix(time_t);
time_t timelocal(struct tm * const);
time_t timegm(struct tm * const);

int nanosleep(const struct timespec *, struct timespec *) __asm("_" "nanosleep" );
typedef __darwin_wint_t wint_t;

typedef __darwin_wctype_t wctype_t;
typedef struct {
 __darwin_rune_t __min;
 __darwin_rune_t __max;
 __darwin_rune_t __map;
 __uint32_t *__types;
} _RuneEntry;

typedef struct {
 int __nranges;
 _RuneEntry *__ranges;
} _RuneRange;

typedef struct {
 char __name[14];
 __uint32_t __mask;
} _RuneCharClass;

typedef struct {
 char __magic[8];
 char __encoding[32];

 __darwin_rune_t (*__sgetrune)(const char *, __darwin_size_t, char const **);
 int (*__sputrune)(__darwin_rune_t, char *, __darwin_size_t, char **);
 __darwin_rune_t __invalid_rune;

 __uint32_t __runetype[(1 <<8 )];
 __darwin_rune_t __maplower[(1 <<8 )];
 __darwin_rune_t __mapupper[(1 <<8 )];

 _RuneRange __runetype_ext;
 _RuneRange __maplower_ext;
 _RuneRange __mapupper_ext;

 void *__variable;
 int __variable_len;

 int __ncharclasses;
 _RuneCharClass *__charclasses;
} _RuneLocale;

extern _RuneLocale _DefaultRuneLocale;
extern _RuneLocale *_CurrentRuneLocale;
unsigned long ___runetype(__darwin_ct_rune_t);
__darwin_ct_rune_t ___tolower(__darwin_ct_rune_t);
__darwin_ct_rune_t ___toupper(__darwin_ct_rune_t);

inline int
isascii(int _c)
{
 return ((_c & ~0x7F) == 0);
}
int __maskrune(__darwin_ct_rune_t, unsigned long);

inline int
__istype(__darwin_ct_rune_t _c, unsigned long _f)
{

 return (isascii(_c) ? !!(_DefaultRuneLocale.__runetype[_c] & _f)
  : !!__maskrune(_c, _f));

}

inline __darwin_ct_rune_t
__isctype(__darwin_ct_rune_t _c, unsigned long _f)
{

 return (_c < 0 || _c >= (1 <<8 )) ? 0 :
  !!(_DefaultRuneLocale.__runetype[_c] & _f);

}
__darwin_ct_rune_t __toupper(__darwin_ct_rune_t);
__darwin_ct_rune_t __tolower(__darwin_ct_rune_t);

inline int
__wcwidth(__darwin_ct_rune_t _c)
{
 unsigned int _x;

 if (_c == 0)
  return (0);
 _x = (unsigned int)__maskrune(_c, 0xe0000000L|0x00040000L);
 if ((_x & 0xe0000000L) != 0)
  return ((_x & 0xe0000000L) >> 30);
 return ((_x & 0x00040000L) != 0 ? 1 : -1);
}

inline int
isalnum(int _c)
{
 return (__istype(_c, 0x00000100L|0x00000400L));
}

inline int
isalpha(int _c)
{
 return (__istype(_c, 0x00000100L));
}

inline int
isblank(int _c)
{
 return (__istype(_c, 0x00020000L));
}

inline int
iscntrl(int _c)
{
 return (__istype(_c, 0x00000200L));
}

inline int
isdigit(int _c)
{
 return (__isctype(_c, 0x00000400L));
}

inline int
isgraph(int _c)
{
 return (__istype(_c, 0x00000800L));
}

inline int
islower(int _c)
{
 return (__istype(_c, 0x00001000L));
}

inline int
isprint(int _c)
{
 return (__istype(_c, 0x00040000L));
}

inline int
ispunct(int _c)
{
 return (__istype(_c, 0x00002000L));
}

inline int
isspace(int _c)
{
 return (__istype(_c, 0x00004000L));
}

inline int
isupper(int _c)
{
 return (__istype(_c, 0x00008000L));
}

inline int
isxdigit(int _c)
{
 return (__isctype(_c, 0x00010000L));
}

inline int
toascii(int _c)
{
 return (_c & 0x7F);
}

inline int
tolower(int _c)
{
        return (__tolower(_c));
}

inline int
toupper(int _c)
{
        return (__toupper(_c));
}

inline int
digittoint(int _c)
{
 return (__maskrune(_c, 0x0F));
}

inline int
ishexnumber(int _c)
{
 return (__istype(_c, 0x00010000L));
}

inline int
isideogram(int _c)
{
 return (__istype(_c, 0x00080000L));
}

inline int
isnumber(int _c)
{
 return (__istype(_c, 0x00000400L));
}

inline int
isphonogram(int _c)
{
 return (__istype(_c, 0x00200000L));
}

inline int
isrune(int _c)
{
 return (__istype(_c, 0xFFFFFFF0L));
}

inline int
isspecial(int _c)
{
 return (__istype(_c, 0x00100000L));
}

inline int
iswalnum(wint_t _wc)
{
 return (__istype(_wc, 0x00000100L|0x00000400L));
}

inline int
iswalpha(wint_t _wc)
{
 return (__istype(_wc, 0x00000100L));
}

inline int
iswcntrl(wint_t _wc)
{
 return (__istype(_wc, 0x00000200L));
}

inline int
iswctype(wint_t _wc, wctype_t _charclass)
{
 return (__istype(_wc, _charclass));
}

inline int
iswdigit(wint_t _wc)
{
 return (__isctype(_wc, 0x00000400L));
}

inline int
iswgraph(wint_t _wc)
{
 return (__istype(_wc, 0x00000800L));
}

inline int
iswlower(wint_t _wc)
{
 return (__istype(_wc, 0x00001000L));
}

inline int
iswprint(wint_t _wc)
{
 return (__istype(_wc, 0x00040000L));
}

inline int
iswpunct(wint_t _wc)
{
 return (__istype(_wc, 0x00002000L));
}

inline int
iswspace(wint_t _wc)
{
 return (__istype(_wc, 0x00004000L));
}

inline int
iswupper(wint_t _wc)
{
 return (__istype(_wc, 0x00008000L));
}

inline int
iswxdigit(wint_t _wc)
{
 return (__isctype(_wc, 0x00010000L));
}

inline wint_t
towlower(wint_t _wc)
{
        return (__tolower(_wc));
}

inline wint_t
towupper(wint_t _wc)
{
        return (__toupper(_wc));
}
wctype_t
 wctype(const char *);

wint_t btowc(int);
wint_t fgetwc(FILE *);
wchar_t *fgetws(wchar_t * restrict, int, FILE * restrict);
wint_t fputwc(wchar_t, FILE *);
int fputws(const wchar_t * restrict, FILE * restrict);
int fwide(FILE *, int);
int fwprintf(FILE * restrict, const wchar_t * restrict, ...);
int fwscanf(FILE * restrict, const wchar_t * restrict, ...);
wint_t getwc(FILE *);
wint_t getwchar(void);
size_t mbrlen(const char * restrict, size_t, mbstate_t * restrict);
size_t mbrtowc(wchar_t * restrict, const char * restrict, size_t,
     mbstate_t * restrict);
int mbsinit(const mbstate_t *);
size_t mbsrtowcs(wchar_t * restrict, const char ** restrict, size_t,
     mbstate_t * restrict);
wint_t putwc(wchar_t, FILE *);
wint_t putwchar(wchar_t);
int swprintf(wchar_t * restrict, size_t, const wchar_t * restrict, ...);
int swscanf(const wchar_t * restrict, const wchar_t * restrict, ...);
wint_t ungetwc(wint_t, FILE *);
int vfwprintf(FILE * restrict, const wchar_t * restrict,
     __darwin_va_list);
int vswprintf(wchar_t * restrict, size_t, const wchar_t * restrict,
     __darwin_va_list);
int vwprintf(const wchar_t * restrict, __darwin_va_list);
size_t wcrtomb(char * restrict, wchar_t, mbstate_t * restrict);
wchar_t *wcscat(wchar_t * restrict, const wchar_t * restrict);
wchar_t *wcschr(const wchar_t *, wchar_t);
int wcscmp(const wchar_t *, const wchar_t *);
int wcscoll(const wchar_t *, const wchar_t *);
wchar_t *wcscpy(wchar_t * restrict, const wchar_t * restrict);
size_t wcscspn(const wchar_t *, const wchar_t *);
size_t wcsftime(wchar_t * restrict, size_t, const wchar_t * restrict,
     const struct tm * restrict) __asm("_" "wcsftime" );
size_t wcslen(const wchar_t *);
wchar_t *wcsncat(wchar_t * restrict, const wchar_t * restrict, size_t);
int wcsncmp(const wchar_t *, const wchar_t *, size_t);
wchar_t *wcsncpy(wchar_t * restrict , const wchar_t * restrict, size_t);
wchar_t *wcspbrk(const wchar_t *, const wchar_t *);
wchar_t *wcsrchr(const wchar_t *, wchar_t);
size_t wcsrtombs(char * restrict, const wchar_t ** restrict, size_t,
     mbstate_t * restrict);
size_t wcsspn(const wchar_t *, const wchar_t *);
wchar_t *wcsstr(const wchar_t * restrict, const wchar_t * restrict);
size_t wcsxfrm(wchar_t * restrict, const wchar_t * restrict, size_t);
int wctob(wint_t);
double wcstod(const wchar_t * restrict, wchar_t ** restrict);
wchar_t *wcstok(wchar_t * restrict, const wchar_t * restrict,
     wchar_t ** restrict);
long wcstol(const wchar_t * restrict, wchar_t ** restrict, int);
unsigned long
  wcstoul(const wchar_t * restrict, wchar_t ** restrict, int);
wchar_t *wmemchr(const wchar_t *, wchar_t, size_t);
int wmemcmp(const wchar_t *, const wchar_t *, size_t);
wchar_t *wmemcpy(wchar_t * restrict, const wchar_t * restrict, size_t);
wchar_t *wmemmove(wchar_t *, const wchar_t *, size_t);
wchar_t *wmemset(wchar_t *, wchar_t, size_t);
int wprintf(const wchar_t * restrict, ...);
int wscanf(const wchar_t * restrict, ...);
int wcswidth(const wchar_t *, size_t);
int wcwidth(wchar_t);
int vfwscanf(FILE * restrict, const wchar_t * restrict,
     __darwin_va_list);
int vswscanf(const wchar_t * restrict, const wchar_t * restrict,
     __darwin_va_list);
int vwscanf(const wchar_t * restrict, __darwin_va_list);
float wcstof(const wchar_t * restrict, wchar_t ** restrict);
long double
 wcstold(const wchar_t * restrict, wchar_t ** restrict);

long long
 wcstoll(const wchar_t * restrict, wchar_t ** restrict, int);
unsigned long long
 wcstoull(const wchar_t * restrict, wchar_t ** restrict, int);
size_t mbsnrtowcs(wchar_t * restrict, const char ** restrict, size_t,
            size_t, mbstate_t * restrict);
wchar_t *wcpcpy(wchar_t * restrict, const wchar_t * restrict) __attribute__((availability(macosx,introduced=10.7)));
wchar_t *wcpncpy(wchar_t * restrict, const wchar_t * restrict, size_t) __attribute__((availability(macosx,introduced=10.7)));
wchar_t *wcsdup(const wchar_t *) __attribute__((availability(macosx,introduced=10.7)));
int wcscasecmp(const wchar_t *, const wchar_t *) __attribute__((availability(macosx,introduced=10.7)));
int wcsncasecmp(const wchar_t *, const wchar_t *, size_t n) __attribute__((availability(macosx,introduced=10.7)));
size_t wcsnlen(const wchar_t *, size_t) __attribute__((availability(macosx,introduced=10.7)));
size_t wcsnrtombs(char * restrict, const wchar_t ** restrict, size_t,
            size_t, mbstate_t * restrict);
wchar_t *fgetwln(FILE * restrict, size_t *) __attribute__((availability(macosx,introduced=10.7)));
size_t wcslcat(wchar_t *, const wchar_t *, size_t);
size_t wcslcpy(wchar_t *, const wchar_t *, size_t);
typedef __darwin_wctrans_t wctrans_t;
inline int
iswblank(wint_t _wc)
{
 return (__istype(_wc, 0x00020000L));
}

inline int
iswascii(wint_t _wc)
{
 return ((_wc & ~0x7F) == 0);
}

inline int
iswhexnumber(wint_t _wc)
{
 return (__istype(_wc, 0x00010000L));
}

inline int
iswideogram(wint_t _wc)
{
 return (__istype(_wc, 0x00080000L));
}

inline int
iswnumber(wint_t _wc)
{
 return (__istype(_wc, 0x00000400L));
}

inline int
iswphonogram(wint_t _wc)
{
 return (__istype(_wc, 0x00200000L));
}

inline int
iswrune(wint_t _wc)
{
 return (__istype(_wc, 0xFFFFFFF0L));
}

inline int
iswspecial(wint_t _wc)
{
 return (__istype(_wc, 0x00100000L));
}
wint_t nextwctype(wint_t, wctype_t);

wint_t towctrans(wint_t, wctrans_t);
wctrans_t
 wctrans(const char *);

typedef signed char int8_t;
typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;

typedef unsigned char u_int8_t;
typedef unsigned short u_int16_t;
typedef unsigned int u_int32_t;
typedef unsigned long long u_int64_t;

typedef int64_t register_t;

typedef __darwin_intptr_t intptr_t;
typedef unsigned long uintptr_t;

typedef u_int64_t user_addr_t;
typedef u_int64_t user_size_t;
typedef int64_t user_ssize_t;
typedef int64_t user_long_t;
typedef u_int64_t user_ulong_t;
typedef int64_t user_time_t;
typedef int64_t user_off_t;

typedef u_int64_t syscall_arg_t;

static inline
__uint16_t
_OSSwapInt16(
    __uint16_t _data
)
{
    return ((__uint16_t)((_data << 8) | (_data >> 8)));
}

static inline
__uint32_t
_OSSwapInt32(
    __uint32_t _data
)
{

    return __builtin_bswap32(_data);

}

static inline
__uint64_t
_OSSwapInt64(
    __uint64_t _data
)
{
    return __builtin_bswap64(_data);
}

typedef unsigned char u_char;
typedef unsigned short u_short;
typedef unsigned int u_int;

typedef unsigned long u_long;

typedef unsigned short ushort;
typedef unsigned int uint;

typedef u_int64_t u_quad_t;
typedef int64_t quad_t;
typedef quad_t * qaddr_t;

typedef char * caddr_t;
typedef int32_t daddr_t;

typedef __darwin_dev_t dev_t;

typedef u_int32_t fixpt_t;

typedef __darwin_blkcnt_t blkcnt_t;
typedef __darwin_blksize_t blksize_t;
typedef __darwin_gid_t gid_t;
typedef __uint32_t in_addr_t;
typedef __uint16_t in_port_t;
typedef __darwin_ino_t ino_t;

typedef __darwin_ino64_t ino64_t;

typedef __int32_t key_t;
typedef __darwin_mode_t mode_t;
typedef __uint16_t nlink_t;
typedef __darwin_id_t id_t;
typedef __darwin_pid_t pid_t;

typedef int32_t segsz_t;
typedef int32_t swblk_t;

typedef __darwin_uid_t uid_t;
typedef __darwin_useconds_t useconds_t;
typedef __darwin_suseconds_t suseconds_t;

typedef __darwin_size_t rsize_t;
typedef int errno_t;

typedef struct fd_set {
 __int32_t fds_bits[((((1024) % ((sizeof(__int32_t) * 8))) == 0) ? ((1024) / ((sizeof(__int32_t) * 8))) : (((1024) / ((sizeof(__int32_t) * 8))) + 1))];
} fd_set;

static __inline int
__darwin_fd_isset(int _n, const struct fd_set *_p)
{
 return (_p->fds_bits[(unsigned long)_n/(sizeof(__int32_t) * 8)] & ((__int32_t)(1<<((unsigned long)_n % (sizeof(__int32_t) * 8)))));
}

typedef __int32_t fd_mask;

typedef __darwin_pthread_attr_t pthread_attr_t;
typedef __darwin_pthread_cond_t pthread_cond_t;
typedef __darwin_pthread_condattr_t pthread_condattr_t;
typedef __darwin_pthread_mutex_t pthread_mutex_t;
typedef __darwin_pthread_mutexattr_t pthread_mutexattr_t;
typedef __darwin_pthread_once_t pthread_once_t;
typedef __darwin_pthread_rwlock_t pthread_rwlock_t;
typedef __darwin_pthread_rwlockattr_t pthread_rwlockattr_t;
typedef __darwin_pthread_t pthread_t;

typedef __darwin_pthread_key_t pthread_key_t;

typedef __darwin_fsblkcnt_t fsblkcnt_t;
typedef __darwin_fsfilcnt_t fsfilcnt_t;

typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;

typedef int8_t int_least8_t;
typedef int16_t int_least16_t;
typedef int32_t int_least32_t;
typedef int64_t int_least64_t;
typedef uint8_t uint_least8_t;
typedef uint16_t uint_least16_t;
typedef uint32_t uint_least32_t;
typedef uint64_t uint_least64_t;

typedef int8_t int_fast8_t;
typedef int16_t int_fast16_t;
typedef int32_t int_fast32_t;
typedef int64_t int_fast64_t;
typedef uint8_t uint_fast8_t;
typedef uint16_t uint_fast16_t;
typedef uint32_t uint_fast32_t;
typedef uint64_t uint_fast64_t;
typedef long int intmax_t;
typedef long unsigned int uintmax_t;

__attribute__((availability(macosx,introduced=10.4)))
extern intmax_t
imaxabs(intmax_t j);

typedef struct {
 intmax_t quot;
 intmax_t rem;
} imaxdiv_t;

__attribute__((availability(macosx,introduced=10.4)))
extern imaxdiv_t
imaxdiv(intmax_t __numer, intmax_t __denom);

__attribute__((availability(macosx,introduced=10.4)))
extern intmax_t
strtoimax(const char * restrict __nptr,
   char ** restrict __endptr,
   int __base);

__attribute__((availability(macosx,introduced=10.4)))
extern uintmax_t
strtoumax(const char * restrict __nptr,
   char ** restrict __endptr,
   int __base);

__attribute__((availability(macosx,introduced=10.4)))
extern intmax_t
wcstoimax(const wchar_t * restrict __nptr,
   wchar_t ** restrict __endptr,
   int __base);

__attribute__((availability(macosx,introduced=10.4)))
extern uintmax_t
wcstoumax(const wchar_t * restrict __nptr,
   wchar_t ** restrict __endptr,
   int __base);

struct flock {
 off_t l_start;
 off_t l_len;
 pid_t l_pid;
 short l_type;
 short l_whence;
};
struct flocktimeout {
 struct flock fl;
 struct timespec timeout;
};
struct radvisory {
       off_t ra_offset;
       int ra_count;
};

typedef struct fcodeblobs {
 void *f_cd_hash;
 size_t f_hash_size;
 void *f_cd_buffer;
 size_t f_cd_size;
 unsigned int *f_out_size;
 int f_arch;
 int __padding;
} fcodeblobs_t;
typedef struct fsignatures {
 off_t fs_file_start;
 void *fs_blob_start;
 size_t fs_blob_size;
} fsignatures_t;
typedef struct fstore {
 unsigned int fst_flags;
 int fst_posmode;
 off_t fst_offset;
 off_t fst_length;
 off_t fst_bytesalloc;
} fstore_t;

typedef struct fbootstraptransfer {
  off_t fbt_offset;
  size_t fbt_length;
  void *fbt_buffer;
} fbootstraptransfer_t;
#pragma pack(4)

struct log2phys {
 unsigned int l2p_flags;
 off_t l2p_contigbytes;

 off_t l2p_devoffset;

};

#pragma pack()
struct _filesec;
typedef struct _filesec *filesec_t;

typedef enum {
 FILESEC_OWNER = 1,
 FILESEC_GROUP = 2,
 FILESEC_UUID = 3,
 FILESEC_MODE = 4,
 FILESEC_ACL = 5,
 FILESEC_GRPUUID = 6,

 FILESEC_ACL_RAW = 100,
 FILESEC_ACL_ALLOCSIZE = 101
} filesec_property_t;

int open(const char *, int, ...) __asm("_" "open" );

int openat(int, const char *, int, ...) __asm("_" "openat" ) __attribute__((availability(macosx,introduced=10.10)));

int creat(const char *, mode_t) __asm("_" "creat" );
int fcntl(int, int, ...) __asm("_" "fcntl" );

int openx_np(const char *, int, filesec_t);

int open_dprotected_np ( const char *, int, int, int, ...);
int flock(int, int);
filesec_t filesec_init(void);
filesec_t filesec_dup(filesec_t);
void filesec_free(filesec_t);
int filesec_get_property(filesec_t, filesec_property_t, void *);
int filesec_query_property(filesec_t, filesec_property_t, int *);
int filesec_set_property(filesec_t, filesec_property_t, const void *);
int filesec_unset_property(filesec_t, filesec_property_t) __attribute__((availability(macosx,introduced=10.6)));
struct accessx_descriptor {
 unsigned int ad_name_offset;
 int ad_flags;
 int ad_pad[2];
};
int getattrlistbulk(int, void *, void *, size_t, uint64_t) __attribute__((availability(macosx,introduced=10.10)));
int faccessat(int, const char *, int, int) __attribute__((availability(macosx,introduced=10.10)));
int fchownat(int, const char *, uid_t, gid_t, int) __attribute__((availability(macosx,introduced=10.10)));
int linkat(int, const char *, int, const char *, int) __attribute__((availability(macosx,introduced=10.10)));
ssize_t readlinkat(int, const char *, char *, size_t) __attribute__((availability(macosx,introduced=10.10)));
int symlinkat(const char *, int, const char *) __attribute__((availability(macosx,introduced=10.10)));
int unlinkat(int, const char *, int) __attribute__((availability(macosx,introduced=10.10)));
int getattrlistat(int, const char *, void *, void *, size_t, unsigned long) __attribute__((availability(macosx,introduced=10.10)));

struct ucred;
typedef struct ucred *kauth_cred_t;
struct posix_cred;
typedef struct posix_cred *posix_cred_t;
shell.c:33:10: fatal error: 'posixstat.h' file not found
#include "posixstat.h"
         ^

void *memchr(const void *, int, size_t);
int memcmp(const void *, const void *, size_t);
void *memcpy(void *, const void *, size_t);
void *memmove(void *, const void *, size_t);
void *memset(void *, int, size_t);
char *strcat(char *, const char *);
char *strchr(const char *, int);
int strcmp(const char *, const char *);
int strcoll(const char *, const char *);
char *strcpy(char *, const char *);
size_t strcspn(const char *, const char *);
char *strerror(int) __asm("_" "strerror" );
size_t strlen(const char *);
char *strncat(char *, const char *, size_t);
int strncmp(const char *, const char *, size_t);
char *strncpy(char *, const char *, size_t);
char *strpbrk(const char *, const char *);
char *strrchr(const char *, int);
size_t strspn(const char *, const char *);
char *strstr(const char *, const char *);
char *strtok(char *, const char *);
size_t strxfrm(char *, const char *, size_t);
char *strtok_r(char *, const char *, char **);
int strerror_r(int, char *, size_t);
char *strdup(const char *);
void *memccpy(void *, const void *, int, size_t);
char *stpcpy(char *, const char *);
char *stpncpy(char *, const char *, size_t) __attribute__((availability(macosx,introduced=10.7)));
char *strndup(const char *, size_t) __attribute__((availability(macosx,introduced=10.7)));
size_t strnlen(const char *, size_t) __attribute__((availability(macosx,introduced=10.7)));
char *strsignal(int sig);
errno_t memset_s(void *, rsize_t, int, rsize_t) __attribute__((availability(macosx,introduced=10.9)));
void *memmem(const void *, size_t, const void *, size_t) __attribute__((availability(macosx,introduced=10.7)));
void memset_pattern4(void *, const void *, size_t) __attribute__((availability(macosx,introduced=10.5)));
void memset_pattern8(void *, const void *, size_t) __attribute__((availability(macosx,introduced=10.5)));
void memset_pattern16(void *, const void *, size_t) __attribute__((availability(macosx,introduced=10.5)));

char *strcasestr(const char *, const char *);
char *strnstr(const char *, const char *, size_t);
size_t strlcat(char *, const char *, size_t);
size_t strlcpy(char *, const char *, size_t);
void strmode(int, char *);
char *strsep(char **, const char *);

void swab(const void * restrict, void * restrict, ssize_t);

int bcmp(const void *, const void *, size_t) ;
void bcopy(const void *, void *, size_t) ;
void bzero(void *, size_t) ;
char *index(const char *, int) ;
char *rindex(const char *, int) ;

int ffs(int);
int strcasecmp(const char *, const char *);
int strncasecmp(const char *, const char *, size_t);

int ffsl(long) __attribute__((availability(macosx,introduced=10.5)));
int ffsll(long long) __attribute__((availability(macosx,introduced=10.9)));
int fls(int) __attribute__((availability(macosx,introduced=10.5)));
int flsl(long) __attribute__((availability(macosx,introduced=10.5)));
int flsll(long long) __attribute__((availability(macosx,introduced=10.9)));

typedef enum {
 P_ALL,
 P_PID,
 P_PGID
} idtype_t;
typedef int sig_atomic_t;
struct __darwin_i386_thread_state
{
    unsigned int __eax;
    unsigned int __ebx;
    unsigned int __ecx;
    unsigned int __edx;
    unsigned int __edi;
    unsigned int __esi;
    unsigned int __ebp;
    unsigned int __esp;
    unsigned int __ss;
    unsigned int __eflags;
    unsigned int __eip;
    unsigned int __cs;
    unsigned int __ds;
    unsigned int __es;
    unsigned int __fs;
    unsigned int __gs;
};
struct __darwin_fp_control
{
    unsigned short __invalid :1,
        __denorm :1,
    __zdiv :1,
    __ovrfl :1,
    __undfl :1,
    __precis :1,
      :2,
    __pc :2,

    __rc :2,

             :1,
      :3;
};
typedef struct __darwin_fp_control __darwin_fp_control_t;
struct __darwin_fp_status
{
    unsigned short __invalid :1,
        __denorm :1,
    __zdiv :1,
    __ovrfl :1,
    __undfl :1,
    __precis :1,
    __stkflt :1,
    __errsumm :1,
    __c0 :1,
    __c1 :1,
    __c2 :1,
    __tos :3,
    __c3 :1,
    __busy :1;
};
typedef struct __darwin_fp_status __darwin_fp_status_t;
struct __darwin_mmst_reg
{
 char __mmst_reg[10];
 char __mmst_rsrv[6];
};
struct __darwin_xmm_reg
{
 char __xmm_reg[16];
};
struct __darwin_i386_float_state
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;
 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;
 __uint16_t __fpu_rsrv2;
 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;
 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 char __fpu_rsrv4[14*16];
 int __fpu_reserved1;
};

struct __darwin_i386_avx_state
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;
 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;
 __uint16_t __fpu_rsrv2;
 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;
 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 char __fpu_rsrv4[14*16];
 int __fpu_reserved1;
 char __avx_reserved1[64];
 struct __darwin_xmm_reg __fpu_ymmh0;
 struct __darwin_xmm_reg __fpu_ymmh1;
 struct __darwin_xmm_reg __fpu_ymmh2;
 struct __darwin_xmm_reg __fpu_ymmh3;
 struct __darwin_xmm_reg __fpu_ymmh4;
 struct __darwin_xmm_reg __fpu_ymmh5;
 struct __darwin_xmm_reg __fpu_ymmh6;
 struct __darwin_xmm_reg __fpu_ymmh7;
};
struct __darwin_i386_exception_state
{
 __uint16_t __trapno;
 __uint16_t __cpu;
 __uint32_t __err;
 __uint32_t __faultvaddr;
};
struct __darwin_x86_debug_state32
{
 unsigned int __dr0;
 unsigned int __dr1;
 unsigned int __dr2;
 unsigned int __dr3;
 unsigned int __dr4;
 unsigned int __dr5;
 unsigned int __dr6;
 unsigned int __dr7;
};
struct __darwin_x86_thread_state64
{
 __uint64_t __rax;
 __uint64_t __rbx;
 __uint64_t __rcx;
 __uint64_t __rdx;
 __uint64_t __rdi;
 __uint64_t __rsi;
 __uint64_t __rbp;
 __uint64_t __rsp;
 __uint64_t __r8;
 __uint64_t __r9;
 __uint64_t __r10;
 __uint64_t __r11;
 __uint64_t __r12;
 __uint64_t __r13;
 __uint64_t __r14;
 __uint64_t __r15;
 __uint64_t __rip;
 __uint64_t __rflags;
 __uint64_t __cs;
 __uint64_t __fs;
 __uint64_t __gs;
};
struct __darwin_x86_float_state64
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;

 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;

 __uint16_t __fpu_rsrv2;

 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;

 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 struct __darwin_xmm_reg __fpu_xmm8;
 struct __darwin_xmm_reg __fpu_xmm9;
 struct __darwin_xmm_reg __fpu_xmm10;
 struct __darwin_xmm_reg __fpu_xmm11;
 struct __darwin_xmm_reg __fpu_xmm12;
 struct __darwin_xmm_reg __fpu_xmm13;
 struct __darwin_xmm_reg __fpu_xmm14;
 struct __darwin_xmm_reg __fpu_xmm15;
 char __fpu_rsrv4[6*16];
 int __fpu_reserved1;
};

struct __darwin_x86_avx_state64
{
 int __fpu_reserved[2];
 struct __darwin_fp_control __fpu_fcw;
 struct __darwin_fp_status __fpu_fsw;
 __uint8_t __fpu_ftw;
 __uint8_t __fpu_rsrv1;
 __uint16_t __fpu_fop;

 __uint32_t __fpu_ip;
 __uint16_t __fpu_cs;

 __uint16_t __fpu_rsrv2;

 __uint32_t __fpu_dp;
 __uint16_t __fpu_ds;

 __uint16_t __fpu_rsrv3;
 __uint32_t __fpu_mxcsr;
 __uint32_t __fpu_mxcsrmask;
 struct __darwin_mmst_reg __fpu_stmm0;
 struct __darwin_mmst_reg __fpu_stmm1;
 struct __darwin_mmst_reg __fpu_stmm2;
 struct __darwin_mmst_reg __fpu_stmm3;
 struct __darwin_mmst_reg __fpu_stmm4;
 struct __darwin_mmst_reg __fpu_stmm5;
 struct __darwin_mmst_reg __fpu_stmm6;
 struct __darwin_mmst_reg __fpu_stmm7;
 struct __darwin_xmm_reg __fpu_xmm0;
 struct __darwin_xmm_reg __fpu_xmm1;
 struct __darwin_xmm_reg __fpu_xmm2;
 struct __darwin_xmm_reg __fpu_xmm3;
 struct __darwin_xmm_reg __fpu_xmm4;
 struct __darwin_xmm_reg __fpu_xmm5;
 struct __darwin_xmm_reg __fpu_xmm6;
 struct __darwin_xmm_reg __fpu_xmm7;
 struct __darwin_xmm_reg __fpu_xmm8;
 struct __darwin_xmm_reg __fpu_xmm9;
 struct __darwin_xmm_reg __fpu_xmm10;
 struct __darwin_xmm_reg __fpu_xmm11;
 struct __darwin_xmm_reg __fpu_xmm12;
 struct __darwin_xmm_reg __fpu_xmm13;
 struct __darwin_xmm_reg __fpu_xmm14;
 struct __darwin_xmm_reg __fpu_xmm15;
 char __fpu_rsrv4[6*16];
 int __fpu_reserved1;
 char __avx_reserved1[64];
 struct __darwin_xmm_reg __fpu_ymmh0;
 struct __darwin_xmm_reg __fpu_ymmh1;
 struct __darwin_xmm_reg __fpu_ymmh2;
 struct __darwin_xmm_reg __fpu_ymmh3;
 struct __darwin_xmm_reg __fpu_ymmh4;
 struct __darwin_xmm_reg __fpu_ymmh5;
 struct __darwin_xmm_reg __fpu_ymmh6;
 struct __darwin_xmm_reg __fpu_ymmh7;
 struct __darwin_xmm_reg __fpu_ymmh8;
 struct __darwin_xmm_reg __fpu_ymmh9;
 struct __darwin_xmm_reg __fpu_ymmh10;
 struct __darwin_xmm_reg __fpu_ymmh11;
 struct __darwin_xmm_reg __fpu_ymmh12;
 struct __darwin_xmm_reg __fpu_ymmh13;
 struct __darwin_xmm_reg __fpu_ymmh14;
 struct __darwin_xmm_reg __fpu_ymmh15;
};
struct __darwin_x86_exception_state64
{
    __uint16_t __trapno;
    __uint16_t __cpu;
    __uint32_t __err;
    __uint64_t __faultvaddr;
};
struct __darwin_x86_debug_state64
{
 __uint64_t __dr0;
 __uint64_t __dr1;
 __uint64_t __dr2;
 __uint64_t __dr3;
 __uint64_t __dr4;
 __uint64_t __dr5;
 __uint64_t __dr6;
 __uint64_t __dr7;
};

struct __darwin_mcontext32
{
 struct __darwin_i386_exception_state __es;
 struct __darwin_i386_thread_state __ss;
 struct __darwin_i386_float_state __fs;
};

struct __darwin_mcontext_avx32
{
 struct __darwin_i386_exception_state __es;
 struct __darwin_i386_thread_state __ss;
 struct __darwin_i386_avx_state __fs;
};
struct __darwin_mcontext64
{
 struct __darwin_x86_exception_state64 __es;
 struct __darwin_x86_thread_state64 __ss;
 struct __darwin_x86_float_state64 __fs;
};

struct __darwin_mcontext_avx64
{
 struct __darwin_x86_exception_state64 __es;
 struct __darwin_x86_thread_state64 __ss;
 struct __darwin_x86_avx_state64 __fs;
};
typedef struct __darwin_mcontext64 *mcontext_t;

struct __darwin_sigaltstack
{
 void *ss_sp;
 __darwin_size_t ss_size;
 int ss_flags;
};
typedef struct __darwin_sigaltstack stack_t;
struct __darwin_ucontext
{
 int uc_onstack;
 __darwin_sigset_t uc_sigmask;
 struct __darwin_sigaltstack uc_stack;
 struct __darwin_ucontext *uc_link;
 __darwin_size_t uc_mcsize;
 struct __darwin_mcontext64 *uc_mcontext;

};

typedef struct __darwin_ucontext ucontext_t;

typedef __darwin_sigset_t sigset_t;

union sigval {

 int sival_int;
 void *sival_ptr;
};

struct sigevent {
 int sigev_notify;
 int sigev_signo;
 union sigval sigev_value;
 void (*sigev_notify_function)(union sigval);
 pthread_attr_t *sigev_notify_attributes;
};

typedef struct __siginfo {
 int si_signo;
 int si_errno;
 int si_code;
 pid_t si_pid;
 uid_t si_uid;
 int si_status;
 void *si_addr;
 union sigval si_value;
 long si_band;
 unsigned long __pad[7];
} siginfo_t;
union __sigaction_u {
 void (*__sa_handler)(int);
 void (*__sa_sigaction)(int, struct __siginfo *,
         void *);
};

struct __sigaction {
 union __sigaction_u __sigaction_u;
 void (*sa_tramp)(void *, int, int, siginfo_t *, void *);
 sigset_t sa_mask;
 int sa_flags;
};

struct sigaction {
 union __sigaction_u __sigaction_u;
 sigset_t sa_mask;
 int sa_flags;
};
typedef void (*sig_t)(int);
struct sigvec {
 void (*sv_handler)(int);
 int sv_mask;
 int sv_flags;
};
struct sigstack {
 char *ss_sp;
 int ss_onstack;
};
void (*signal(int, void (*)(int)))(int);
struct timeval
{
 __darwin_time_t tv_sec;
 __darwin_suseconds_t tv_usec;
};

typedef __uint64_t rlim_t;
struct rusage {
 struct timeval ru_utime;
 struct timeval ru_stime;
 long ru_maxrss;

 long ru_ixrss;
 long ru_idrss;
 long ru_isrss;
 long ru_minflt;
 long ru_majflt;
 long ru_nswap;
 long ru_inblock;
 long ru_oublock;
 long ru_msgsnd;
 long ru_msgrcv;
 long ru_nsignals;
 long ru_nvcsw;
 long ru_nivcsw;

};
typedef void *rusage_info_t;

struct rusage_info_v0 {
 uint8_t ri_uuid[16];
 uint64_t ri_user_time;
 uint64_t ri_system_time;
 uint64_t ri_pkg_idle_wkups;
 uint64_t ri_interrupt_wkups;
 uint64_t ri_pageins;
 uint64_t ri_wired_size;
 uint64_t ri_resident_size;
 uint64_t ri_phys_footprint;
 uint64_t ri_proc_start_abstime;
 uint64_t ri_proc_exit_abstime;
};

struct rusage_info_v1 {
 uint8_t ri_uuid[16];
 uint64_t ri_user_time;
 uint64_t ri_system_time;
 uint64_t ri_pkg_idle_wkups;
 uint64_t ri_interrupt_wkups;
 uint64_t ri_pageins;
 uint64_t ri_wired_size;
 uint64_t ri_resident_size;
 uint64_t ri_phys_footprint;
 uint64_t ri_proc_start_abstime;
 uint64_t ri_proc_exit_abstime;
 uint64_t ri_child_user_time;
 uint64_t ri_child_system_time;
 uint64_t ri_child_pkg_idle_wkups;
 uint64_t ri_child_interrupt_wkups;
 uint64_t ri_child_pageins;
 uint64_t ri_child_elapsed_abstime;
};

struct rusage_info_v2 {
 uint8_t ri_uuid[16];
 uint64_t ri_user_time;
 uint64_t ri_system_time;
 uint64_t ri_pkg_idle_wkups;
 uint64_t ri_interrupt_wkups;
 uint64_t ri_pageins;
 uint64_t ri_wired_size;
 uint64_t ri_resident_size;
 uint64_t ri_phys_footprint;
 uint64_t ri_proc_start_abstime;
 uint64_t ri_proc_exit_abstime;
 uint64_t ri_child_user_time;
 uint64_t ri_child_system_time;
 uint64_t ri_child_pkg_idle_wkups;
 uint64_t ri_child_interrupt_wkups;
 uint64_t ri_child_pageins;
 uint64_t ri_child_elapsed_abstime;
 uint64_t ri_diskio_bytesread;
 uint64_t ri_diskio_byteswritten;
};

struct rusage_info_v3 {
 uint8_t ri_uuid[16];
 uint64_t ri_user_time;
 uint64_t ri_system_time;
 uint64_t ri_pkg_idle_wkups;
 uint64_t ri_interrupt_wkups;
 uint64_t ri_pageins;
 uint64_t ri_wired_size;
 uint64_t ri_resident_size;
 uint64_t ri_phys_footprint;
 uint64_t ri_proc_start_abstime;
 uint64_t ri_proc_exit_abstime;
 uint64_t ri_child_user_time;
 uint64_t ri_child_system_time;
 uint64_t ri_child_pkg_idle_wkups;
 uint64_t ri_child_interrupt_wkups;
 uint64_t ri_child_pageins;
 uint64_t ri_child_elapsed_abstime;
 uint64_t ri_diskio_bytesread;
 uint64_t ri_diskio_byteswritten;
 uint64_t ri_cpu_time_qos_default;
 uint64_t ri_cpu_time_qos_maintenance;
 uint64_t ri_cpu_time_qos_background;
 uint64_t ri_cpu_time_qos_utility;
 uint64_t ri_cpu_time_qos_legacy;
 uint64_t ri_cpu_time_qos_user_initiated;
 uint64_t ri_cpu_time_qos_user_interactive;
 uint64_t ri_billed_system_time;
 uint64_t ri_serviced_system_time;
};

typedef struct rusage_info_v3 rusage_info_current;
struct rlimit {
 rlim_t rlim_cur;
 rlim_t rlim_max;
};
struct proc_rlimit_control_wakeupmon {
 uint32_t wm_flags;
 int32_t wm_rate;
};
int getpriority(int, id_t);

int getiopolicy_np(int, int) __attribute__((availability(macosx,introduced=10.5)));

int getrlimit(int, struct rlimit *) __asm("_" "getrlimit" );
int getrusage(int, struct rusage *);
int setpriority(int, id_t, int);

int setiopolicy_np(int, int, int) __attribute__((availability(macosx,introduced=10.5)));

int setrlimit(int, const struct rlimit *) __asm("_" "setrlimit" );
union wait {
 int w_status;

 struct {

  unsigned int w_Termsig:7,
    w_Coredump:1,
    w_Retcode:8,
    w_Filler:16;

 } w_T;

 struct {

  unsigned int w_Stopval:8,
    w_Stopsig:8,
    w_Filler:16;

 } w_S;
};
pid_t wait(int *) __asm("_" "wait" );
pid_t waitpid(pid_t, int *, int) __asm("_" "waitpid" );

int waitid(idtype_t, id_t, siginfo_t *, int) __asm("_" "waitid" );

pid_t wait3(int *, int, struct rusage *);
pid_t wait4(pid_t, int *, int, struct rusage *);

void *alloca(size_t);

typedef struct {
 int quot;
 int rem;
} div_t;

typedef struct {
 long quot;
 long rem;
} ldiv_t;

typedef struct {
 long long quot;
 long long rem;
} lldiv_t;
extern int __mb_cur_max;
void abort(void) __attribute__((noreturn));
int abs(int) __attribute__((const));
int atexit(void (*)(void));
double atof(const char *);
int atoi(const char *);
long atol(const char *);

long long
  atoll(const char *);

void *bsearch(const void *, const void *, size_t,
     size_t, int (*)(const void *, const void *));
void *calloc(size_t, size_t);
div_t div(int, int) __attribute__((const));
void exit(int) __attribute__((noreturn));
void free(void *);
char *getenv(const char *);
long labs(long) __attribute__((const));
ldiv_t ldiv(long, long) __attribute__((const));

long long
  llabs(long long);
lldiv_t lldiv(long long, long long);

void *malloc(size_t);
int mblen(const char *, size_t);
size_t mbstowcs(wchar_t * restrict , const char * restrict, size_t);
int mbtowc(wchar_t * restrict, const char * restrict, size_t);
int posix_memalign(void **, size_t, size_t) __attribute__((availability(macosx,introduced=10.6)));
void qsort(void *, size_t, size_t,
     int (*)(const void *, const void *));
int rand(void);
void *realloc(void *, size_t);
void srand(unsigned);
double strtod(const char *, char **) __asm("_" "strtod" );
float strtof(const char *, char **) __asm("_" "strtof" );
long strtol(const char *, char **, int);
long double
  strtold(const char *, char **);

long long
  strtoll(const char *, char **, int);

unsigned long
  strtoul(const char *, char **, int);

unsigned long long
  strtoull(const char *, char **, int);

int system(const char *) __asm("_" "system" ) __attribute__((availability(macosx,introduced=10.0))) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
size_t wcstombs(char * restrict, const wchar_t * restrict, size_t);
int wctomb(char *, wchar_t);

void _Exit(int) __attribute__((noreturn));
long a64l(const char *);
double drand48(void);
char *ecvt(double, int, int *restrict, int *restrict);
double erand48(unsigned short[3]);
char *fcvt(double, int, int *restrict, int *restrict);
char *gcvt(double, int, char *);
int getsubopt(char **, char * const *, char **);
int grantpt(int);

char *initstate(unsigned, char *, size_t);

long jrand48(unsigned short[3]);
char *l64a(long);
void lcong48(unsigned short[7]);
long lrand48(void);
char *mktemp(char *);
int mkstemp(char *);
long mrand48(void);
long nrand48(unsigned short[3]);
int posix_openpt(int);
char *ptsname(int);
int putenv(char *) __asm("_" "putenv" );
long random(void);
int rand_r(unsigned *);

char *realpath(const char * restrict, char * restrict) __asm("_" "realpath" "$DARWIN_EXTSN");

unsigned short
 *seed48(unsigned short[3]);
int setenv(const char *, const char *, int) __asm("_" "setenv" );

void setkey(const char *) __asm("_" "setkey" );

char *setstate(const char *);
void srand48(long);

void srandom(unsigned);

int unlockpt(int);

int unsetenv(const char *) __asm("_" "unsetenv" );
u_int32_t arc4random(void);
void arc4random_addrandom(unsigned char * , int );
void arc4random_buf(void * , size_t ) __attribute__((availability(macosx,introduced=10.7)));
void arc4random_stir(void);
u_int32_t
  arc4random_uniform(u_int32_t ) __attribute__((availability(macosx,introduced=10.7)));

int atexit_b(void (^)(void)) __attribute__((availability(macosx,introduced=10.6)));
void *bsearch_b(const void *, const void *, size_t,
     size_t, int (^)(const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));

char *cgetcap(char *, const char *, int);
int cgetclose(void);
int cgetent(char **, char **, const char *);
int cgetfirst(char **, char **);
int cgetmatch(const char *, const char *);
int cgetnext(char **, char **);
int cgetnum(char *, const char *, long *);
int cgetset(const char *);
int cgetstr(char *, const char *, char **);
int cgetustr(char *, const char *, char **);

int daemon(int, int) __asm("_" "daemon" "$1050") __attribute__((availability(macosx,introduced=10.0,deprecated=10.5,message="Use posix_spawn APIs instead."))) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
char *devname(dev_t, mode_t);
char *devname_r(dev_t, mode_t, char *buf, int len);
char *getbsize(int *, long *);
int getloadavg(double [], int);
const char
 *getprogname(void);

int heapsort(void *, size_t, size_t,
     int (*)(const void *, const void *));

int heapsort_b(void *, size_t, size_t,
     int (^)(const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));

int mergesort(void *, size_t, size_t,
     int (*)(const void *, const void *));

int mergesort_b(void *, size_t, size_t,
     int (^)(const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));

void psort(void *, size_t, size_t,
     int (*)(const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));

void psort_b(void *, size_t, size_t,
     int (^)(const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));

void psort_r(void *, size_t, size_t, void *,
     int (*)(void *, const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));

void qsort_b(void *, size_t, size_t,
     int (^)(const void *, const void *)) __attribute__((availability(macosx,introduced=10.6)));

void qsort_r(void *, size_t, size_t, void *,
     int (*)(void *, const void *, const void *));
int radixsort(const unsigned char **, int, const unsigned char *,
     unsigned);
void setprogname(const char *);
int sradixsort(const unsigned char **, int, const unsigned char *,
     unsigned);
void sranddev(void);
void srandomdev(void);
void *reallocf(void *, size_t);

long long
  strtoq(const char *, char **, int);
unsigned long long
  strtouq(const char *, char **, int);

extern char *suboptarg;
void *valloc(size_t);

extern const char *const sys_signame[32];
extern const char *const sys_siglist[32];

int raise(int);

void (*bsd_signal(int, void (*)(int)))(int);
int kill(pid_t, int) __asm("_" "kill" );
int killpg(pid_t, int) __asm("_" "killpg" );
int pthread_kill(pthread_t, int);
int pthread_sigmask(int, const sigset_t *, sigset_t *) __asm("_" "pthread_sigmask" );
int sigaction(int, const struct sigaction * restrict,
     struct sigaction * restrict);
int sigaddset(sigset_t *, int);
int sigaltstack(const stack_t * restrict, stack_t * restrict) __asm("_" "sigaltstack" ) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int sigdelset(sigset_t *, int);
int sigemptyset(sigset_t *);
int sigfillset(sigset_t *);
int sighold(int);
int sigignore(int);
int siginterrupt(int, int);
int sigismember(const sigset_t *, int);
int sigpause(int) __asm("_" "sigpause" );
int sigpending(sigset_t *);
int sigprocmask(int, const sigset_t * restrict, sigset_t * restrict);
int sigrelse(int);
void (*sigset(int, void (*)(int)))(int);
int sigsuspend(const sigset_t *) __asm("_" "sigsuspend" );
int sigwait(const sigset_t * restrict, int * restrict) __asm("_" "sigwait" );

void psignal(unsigned int, const char *);
int sigblock(int);
int sigsetmask(int);
int sigvec(int, struct sigvec *, struct sigvec *);

inline __attribute__ ((__always_inline__)) int
__sigbits(int __signo)
{
    return __signo > 32 ? 0 : (1 << (__signo - 1));
}
extern int * __error(void);

struct passwd {
 char *pw_name;
 char *pw_passwd;
 uid_t pw_uid;
 gid_t pw_gid;
 __darwin_time_t pw_change;
 char *pw_class;
 char *pw_gecos;
 char *pw_dir;
 char *pw_shell;
 __darwin_time_t pw_expire;
};

struct passwd *getpwuid(uid_t);
struct passwd *getpwnam(const char *);
int getpwuid_r(uid_t, struct passwd *, char *, size_t, struct passwd **);
int getpwnam_r(const char *, struct passwd *, char *, size_t, struct passwd **);
struct passwd *getpwent(void);
void setpwent(void);
void endpwent(void);

typedef __darwin_uuid_t uuid_t;

typedef __darwin_uuid_string_t uuid_string_t;
void uuid_clear(uuid_t uu);

int uuid_compare(const uuid_t uu1, const uuid_t uu2);

void uuid_copy(uuid_t dst, const uuid_t src);

void uuid_generate(uuid_t out);
void uuid_generate_random(uuid_t out);
void uuid_generate_time(uuid_t out);

int uuid_is_null(const uuid_t uu);

int uuid_parse(const uuid_string_t in, uuid_t uu);

void uuid_unparse(const uuid_t uu, uuid_string_t out);
void uuid_unparse_lower(const uuid_t uu, uuid_string_t out);
void uuid_unparse_upper(const uuid_t uu, uuid_string_t out);

int setpassent(int);
char *user_from_uid(uid_t, int);
struct passwd *getpwuuid(uuid_t);
int getpwuuid_r(uuid_t, struct passwd *, char *, size_t, struct passwd **);

void _exit(int) __attribute__((noreturn));
int access(const char *, int);
unsigned int
  alarm(unsigned int);
int chdir(const char *);
int chown(const char *, uid_t, gid_t);

int close(int) __asm("_" "close" );

int dup(int);
int dup2(int, int);
int execl(const char *, const char *, ...) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int execle(const char *, const char *, ...) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int execlp(const char *, const char *, ...) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int execv(const char *, char * const *) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int execve(const char *, char * const *, char * const *) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int execvp(const char *, char * const *) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
pid_t fork(void) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
long fpathconf(int, int);
char *getcwd(char *, size_t);
gid_t getegid(void);
uid_t geteuid(void);
gid_t getgid(void);

int getgroups(int, gid_t []);

char *getlogin(void);
pid_t getpgrp(void);
pid_t getpid(void);
pid_t getppid(void);
uid_t getuid(void);
int isatty(int);
int link(const char *, const char *);
off_t lseek(int, off_t, int);
long pathconf(const char *, int);

int pause(void) __asm("_" "pause" );

int pipe(int [2]);

ssize_t read(int, void *, size_t) __asm("_" "read" );

int rmdir(const char *);
int setgid(gid_t);
int setpgid(pid_t, pid_t);
pid_t setsid(void);
int setuid(uid_t);

unsigned int
  sleep(unsigned int) __asm("_" "sleep" );

long sysconf(int);
pid_t tcgetpgrp(int);
int tcsetpgrp(int, pid_t);
char *ttyname(int);

int ttyname_r(int, char *, size_t) __asm("_" "ttyname_r" );

int unlink(const char *);

ssize_t write(int, const void *, size_t) __asm("_" "write" );
size_t confstr(int, char *, size_t) __asm("_" "confstr" );

int getopt(int, char * const [], const char *) __asm("_" "getopt" );

extern char *optarg;
extern int optind, opterr, optopt;
__attribute__((deprecated)) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)))

void *brk(const void *);
int chroot(const char *) ;

char *crypt(const char *, const char *);

void encrypt(char *, int) __asm("_" "encrypt" );

int fchdir(int);
long gethostid(void);
pid_t getpgid(pid_t);
pid_t getsid(pid_t);

int getdtablesize(void) ;
int getpagesize(void) __attribute__((const)) ;
char *getpass(const char *) ;

char *getwd(char *) ;

int lchown(const char *, uid_t, gid_t) __asm("_" "lchown" );

int lockf(int, int, off_t) __asm("_" "lockf" );

int nice(int) __asm("_" "nice" );

ssize_t pread(int, void *, size_t, off_t) __asm("_" "pread" );

ssize_t pwrite(int, const void *, size_t, off_t) __asm("_" "pwrite" );

__attribute__((deprecated)) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)))

void *sbrk(int);

pid_t setpgrp(void) __asm("_" "setpgrp" );

int setregid(gid_t, gid_t) __asm("_" "setregid" );

int setreuid(uid_t, uid_t) __asm("_" "setreuid" );

void swab(const void * restrict, void * restrict, ssize_t);
void sync(void);
int truncate(const char *, off_t);
useconds_t ualarm(useconds_t, useconds_t);
int usleep(useconds_t) __asm("_" "usleep" );
pid_t vfork(void) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));

int fsync(int) __asm("_" "fsync" );

int ftruncate(int, off_t);
int getlogin_r(char *, size_t);
int fchown(int, uid_t, gid_t);
int gethostname(char *, size_t);
ssize_t readlink(const char * restrict, char * restrict, size_t);
int setegid(gid_t);
int seteuid(uid_t);
int symlink(const char *, const char *);
int pselect(int, fd_set * restrict, fd_set * restrict,
  fd_set * restrict, const struct timespec * restrict,
  const sigset_t * restrict)

  __asm("_" "pselect" "$1050")

  ;

int select(int, fd_set * restrict, fd_set * restrict,
  fd_set * restrict, struct timeval * restrict)

  __asm("_" "select" "$1050")

  ;

void _Exit(int) __attribute__((noreturn));
int accessx_np(const struct accessx_descriptor *, size_t, int *, uid_t);
int acct(const char *);
int add_profil(char *, size_t, unsigned long, unsigned int) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
void endusershell(void);
int execvP(const char *, const char *, char * const *) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
char *fflagstostr(unsigned long);
int getdomainname(char *, int);
int getgrouplist(const char *, int, int *, int *);

int gethostuuid(uuid_t, const struct timespec *) __attribute__((availability(macosx,introduced=10.5)));

mode_t getmode(const void *, mode_t);
int getpeereid(int, uid_t *, gid_t *);
int getsgroups_np(int *, uuid_t);
char *getusershell(void);
int getwgroups_np(int *, uuid_t);
int initgroups(const char *, int);
int iruserok(unsigned long, int, const char *, const char *);
int iruserok_sa(const void *, int, int, const char *, const char *);
int issetugid(void);
char *mkdtemp(char *);
int mknod(const char *, mode_t, dev_t);
int mkpath_np(const char *path, mode_t omode) __attribute__((availability(macosx,introduced=10.8)));
int mkstemp(char *);
int mkstemps(char *, int);
char *mktemp(char *);
int nfssvc(int, void *);
int profil(char *, size_t, unsigned long, unsigned int);
int pthread_setugid_np(uid_t, gid_t);
int pthread_getugid_np( uid_t *, gid_t *);
int rcmd(char **, int, const char *, const char *, const char *, int *);
int rcmd_af(char **, int, const char *, const char *, const char *, int *,
  int);
int reboot(int);
int revoke(const char *);
int rresvport(int *);
int rresvport_af(int *, int);
int ruserok(const char *, int, const char *, const char *);
int setdomainname(const char *, int);
int setgroups(int, const gid_t *);
void sethostid(long);
int sethostname(const char *, int);

void setkey(const char *) __asm("_" "setkey" );

int setlogin(const char *);
void *setmode(const char *) __asm("_" "setmode" );
int setrgid(gid_t);
int setruid(uid_t);
int setsgroups_np(int, const uuid_t);
void setusershell(void);
int setwgroups_np(int, const uuid_t);
int strtofflags(char **, unsigned long *, unsigned long *);
int swapon(const char *);
int syscall(int, ...) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int ttyslot(void);
int undelete(const char *);
int unwhiteout(const char *);
void *valloc(size_t);

extern char *suboptarg;
int getsubopt(char **, char * const *, char **);

int fgetattrlist(int,void*,void*,size_t,unsigned int) __attribute__((availability(macosx,introduced=10.6)));
int fsetattrlist(int,void*,void*,size_t,unsigned int) __attribute__((availability(macosx,introduced=10.6)));
int getattrlist(const char*,void*,void*,size_t,unsigned int) __asm("_" "getattrlist" );
int setattrlist(const char*,void*,void*,size_t,unsigned int) __asm("_" "setattrlist" );
int exchangedata(const char*,const char*,unsigned int) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int getdirentriesattr(int,void*,void*,size_t,unsigned int*,unsigned int*,unsigned int*,unsigned int) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
struct fssearchblock;
struct searchstate;

int searchfs(const char *, struct fssearchblock *, unsigned long *, unsigned int, unsigned int, struct searchstate *) __attribute__((availability(watchos,unavailable))) __attribute__((availability(tvos,unavailable)));
int fsctl(const char *,unsigned long,void*,unsigned int);
int ffsctl(int,unsigned long,void*,unsigned int) __attribute__((availability(macosx,introduced=10.6)));

int fsync_volume_np(int, int) __attribute__((availability(macosx,introduced=10.8)));
int sync_volume_np(const char *, int) __attribute__((availability(macosx,introduced=10.8)));

extern int optreset;

struct lconv {
 char *decimal_point;
 char *thousands_sep;
 char *grouping;
 char *int_curr_symbol;
 char *currency_symbol;
 char *mon_decimal_point;
 char *mon_thousands_sep;
 char *mon_grouping;
 char *positive_sign;
 char *negative_sign;
 char int_frac_digits;
 char frac_digits;
 char p_cs_precedes;
 char p_sep_by_space;
 char n_cs_precedes;
 char n_sep_by_space;
 char p_sign_posn;
 char n_sign_posn;
 char int_p_cs_precedes;
 char int_n_cs_precedes;
 char int_p_sep_by_space;
 char int_n_sep_by_space;
 char int_p_sign_posn;
 char int_n_sign_posn;
};

struct lconv *localeconv(void);
char *setlocale(int, const char *);

extern procenv_t top_level;
extern procenv_t subshell_top_level;
extern procenv_t return_catch;

enum r_instruction {
  r_output_direction, r_input_direction, r_inputa_direction,
  r_appending_to, r_reading_until, r_reading_string,
  r_duplicating_input, r_duplicating_output, r_deblank_reading_until,
  r_close_this, r_err_and_out, r_input_output, r_output_force,
  r_duplicating_input_word, r_duplicating_output_word,
  r_move_input, r_move_output, r_move_input_word, r_move_output_word
};
enum command_type { cm_for, cm_case, cm_while, cm_if, cm_simple, cm_select,
      cm_connection, cm_function_def, cm_until, cm_group,
      cm_arith, cm_cond, cm_arith_for, cm_subshell };
typedef struct word_desc {
  char *word;
  int flags;
} WORD_DESC;

typedef struct word_list {
  struct word_list *next;
  WORD_DESC *word;
} WORD_LIST;
typedef union {
  int dest;
  WORD_DESC *filename;
} REDIRECTEE;

typedef struct redirect {
  struct redirect *next;
  int redirector;
  int flags;
  enum r_instruction instruction;
  REDIRECTEE redirectee;
  char *here_doc_eof;
} REDIRECT;

typedef struct element {
  WORD_DESC *word;
  REDIRECT *redirect;
} ELEMENT;
typedef struct command {
  enum command_type type;
  int flags;
  int line;
  REDIRECT *redirects;
  union {
    struct for_com *For;
    struct case_com *Case;
    struct while_com *While;
    struct if_com *If;
    struct connection *Connection;
    struct simple_com *Simple;
    struct function_def *Function_def;
    struct group_com *Group;

    struct select_com *Select;

    struct arith_com *Arith;

    struct cond_com *Cond;

    struct arith_for_com *ArithFor;

    struct subshell_com *Subshell;
  } value;
} COMMAND;

typedef struct connection {
  int ignore;
  COMMAND *first;
  COMMAND *second;
  int connector;
} CONNECTION;

typedef struct pattern_list {
  struct pattern_list *next;
  WORD_LIST *patterns;
  COMMAND *action;
  int flags;
} PATTERN_LIST;

typedef struct case_com {
  int flags;
  int line;
  WORD_DESC *word;
  PATTERN_LIST *clauses;
} CASE_COM;

typedef struct for_com {
  int flags;
  int line;
  WORD_DESC *name;
  WORD_LIST *map_list;
  COMMAND *action;

} FOR_COM;

typedef struct arith_for_com {
  int flags;
  int line;
  WORD_LIST *init;
  WORD_LIST *test;
  WORD_LIST *step;
  COMMAND *action;
} ARITH_FOR_COM;

typedef struct select_com {
  int flags;
  int line;
  WORD_DESC *name;
  WORD_LIST *map_list;
  COMMAND *action;

} SELECT_COM;

typedef struct if_com {
  int flags;
  COMMAND *test;
  COMMAND *true_case;
  COMMAND *false_case;
} IF_COM;

typedef struct while_com {
  int flags;
  COMMAND *test;
  COMMAND *action;
} WHILE_COM;

typedef struct arith_com {
  int flags;
  int line;
  WORD_LIST *exp;
} ARITH_COM;
typedef struct cond_com {
  int flags;
  int line;
  int type;
  WORD_DESC *op;
  struct cond_com *left, *right;
} COND_COM;

typedef struct simple_com {
  int flags;
  int line;
  WORD_LIST *words;

  REDIRECT *redirects;
} SIMPLE_COM;

typedef struct function_def {
  int flags;
  int line;
  WORD_DESC *name;
  COMMAND *command;
  char *source_file;
} FUNCTION_DEF;

typedef struct group_com {
  int ignore;
  COMMAND *command;
} GROUP_COM;

typedef struct subshell_com {
  int flags;
  COMMAND *command;
} SUBSHELL_COM;

extern COMMAND *global_command;
extern FUNCTION_DEF *copy_function_def_contents (FUNCTION_DEF *, FUNCTION_DEF *);
extern FUNCTION_DEF *copy_function_def (FUNCTION_DEF *);

extern WORD_DESC *copy_word (WORD_DESC *);
extern WORD_LIST *copy_word_list (WORD_LIST *);
extern REDIRECT *copy_redirect (REDIRECT *);
extern REDIRECT *copy_redirects (REDIRECT *);
extern COMMAND *copy_command (COMMAND *);
extern int sh_syntaxtab[];
extern int sh_syntabsiz;
struct timeval64
{
 __int64_t tv_sec;
 __int64_t tv_usec;
};
struct itimerval {
 struct timeval it_interval;
 struct timeval it_value;
};
struct timezone {
 int tz_minuteswest;
 int tz_dsttime;
};
struct clockinfo {
 int hz;
 int tick;
 int tickadj;
 int stathz;
 int profhz;
};
int adjtime(const struct timeval *, struct timeval *);
int futimes(int, const struct timeval *);
int lutimes(const char *, const struct timeval *) __attribute__((availability(macosx,introduced=10.5)));
int settimeofday(const struct timeval *, const struct timezone *);

int getitimer(int, struct itimerval *);
int gettimeofday(struct timeval * restrict, void * restrict);

int setitimer(int, const struct itimerval * restrict,
  struct itimerval * restrict);
int utimes(const char *, const struct timeval *);
extern void * xmalloc (size_t);
extern void * xrealloc (void *, size_t);
extern void xfree (void *);
typedef struct g_list {
  struct g_list *next;
} GENERIC_LIST;

typedef struct {
  char *word;
  int token;
} STRING_INT_ALIST;
typedef int Function ();
typedef void VFunction ();
typedef char *CPFunction ();
typedef char **CPPFunction ();
typedef int sh_intfunc_t (int);
typedef int sh_ivoidfunc_t (void);
typedef int sh_icpfunc_t (char *);
typedef int sh_icppfunc_t (char **);
typedef int sh_iptrfunc_t (void *);

typedef void sh_voidfunc_t (void);
typedef void sh_vintfunc_t (int);
typedef void sh_vcpfunc_t (char *);
typedef void sh_vcppfunc_t (char **);
typedef void sh_vptrfunc_t (void *);

typedef int sh_wdesc_func_t (WORD_DESC *);
typedef int sh_wlist_func_t (WORD_LIST *);

typedef int sh_glist_func_t (GENERIC_LIST *);

typedef char *sh_string_func_t (char *);

typedef int sh_msg_func_t (const char *, ...);
typedef void sh_vmsg_func_t (const char *, ...);

typedef void sh_sv_func_t (char *);
typedef void sh_free_func_t (void *);
typedef void sh_resetsig_func_t (int);

typedef int sh_ignore_func_t (const char *);

typedef int sh_assign_func_t (const char *);
typedef int sh_wassign_func_t (WORD_DESC *);

typedef int sh_builtin_func_t (WORD_LIST *);
typedef int QSFUNC (const void *, const void *);
extern void posix_initialize (int);

extern rlim_t string_to_rlimtype (char *);
extern void print_rlimtype (rlim_t, int);

extern int all_digits (char *);
extern int legal_number (char *, intmax_t *);
extern int legal_identifier (char *);
extern int check_identifier (WORD_DESC *, int);
extern int legal_alias_name (char *, int);
extern int assignment (const char *, int);

extern int sh_unset_nodelay_mode (int);
extern int sh_validfd (int);
extern void check_dev_tty (void);
extern int move_to_high_fd (int, int, int);
extern int check_binary_file (char *, int);

extern int file_isdir (char *);
extern int file_iswdir (char *);
extern int absolute_pathname (const char *);
extern int absolute_program (const char *);

extern char *make_absolute (char *, char *);
extern char *base_pathname (char *);
extern char *full_pathname (char *);
extern char *polite_directory_format (char *);

extern char *extract_colon_unit (char *, int *);

extern void tilde_initialize (void);
extern char *bash_tilde_find_word (const char *, int, int *);
extern char *bash_tilde_expand (const char *, int);

extern int group_member (gid_t);
extern char **get_group_list (int *);
extern int *get_group_array (int *);
extern char *get_name_for_error (void);

extern void file_error (const char *);

extern void programming_error (const char *, ...) __attribute__((__format__ (printf, 1, 2)));

extern void report_error (const char *, ...) __attribute__((__format__ (printf, 1, 2)));

extern void parser_error (int, const char *, ...) __attribute__((__format__ (printf, 2, 3)));

extern void fatal_error (const char *, ...) __attribute__((__format__ (printf, 1, 2)));

extern void sys_error (const char *, ...) __attribute__((__format__ (printf, 1, 2)));

extern void internal_error (const char *, ...) __attribute__((__format__ (printf, 1, 2)));

extern void internal_warning (const char *, ...) __attribute__((__format__ (printf, 1, 2)));

extern void itrace (const char *, ...) __attribute__ ((__format__ (printf, 1, 2)));

extern void command_error (const char *, int, int, int);

extern char *command_errstr (int);

extern void err_badarraysub (const char *);
extern void err_unboundvar (const char *);
extern void err_readonly (const char *);
typedef intmax_t arrayind_t;

enum atype {array_indexed, array_assoc};

typedef struct array {
 enum atype type;
 arrayind_t max_index, num_elements;
 struct array_element *head;
} ARRAY;

typedef struct array_element {
 arrayind_t ind;
 char *value;
 struct array_element *next, *prev;
} ARRAY_ELEMENT;

typedef int sh_ae_map_func_t (ARRAY_ELEMENT *, void *);

extern ARRAY *array_create (void);
extern void array_flush (ARRAY *);
extern void array_dispose (ARRAY *);
extern ARRAY *array_copy (ARRAY *);
extern ARRAY *array_slice (ARRAY *, ARRAY_ELEMENT *, ARRAY_ELEMENT *);
extern void array_walk (ARRAY *, sh_ae_map_func_t *, void *);

extern ARRAY_ELEMENT *array_shift (ARRAY *, int, int);
extern int array_rshift (ARRAY *, int, char *);
extern ARRAY_ELEMENT *array_unshift_element (ARRAY *);
extern int array_shift_element (ARRAY *, char *);
extern ARRAY *array_quote (ARRAY *);
extern ARRAY *array_quote_escapes (ARRAY *);

extern char *array_subrange (ARRAY *, arrayind_t, arrayind_t, int, int);
extern char *array_patsub (ARRAY *, char *, char *, int);

extern ARRAY_ELEMENT *array_create_element (arrayind_t, char *);
extern ARRAY_ELEMENT *array_copy_element (ARRAY_ELEMENT *);
extern void array_dispose_element (ARRAY_ELEMENT *);

extern int array_insert (ARRAY *, arrayind_t, char *);
extern ARRAY_ELEMENT *array_remove (ARRAY *, arrayind_t);
extern char *array_reference (ARRAY *, arrayind_t);

extern WORD_LIST *array_to_word_list (ARRAY *);
extern ARRAY *array_from_word_list (WORD_LIST *);
extern WORD_LIST *array_keys_to_word_list (ARRAY *);

extern ARRAY *array_assign_list (ARRAY *, WORD_LIST *);

extern char **array_to_argv (ARRAY *);

extern char *array_to_assign (ARRAY *, int);
extern char *array_to_string (ARRAY *, char *, int);
extern ARRAY *array_from_string (char *, char *);

typedef struct bucket_contents {
  struct bucket_contents *next;
  char *key;
  void * data;
  unsigned int khash;
  int times_found;
} BUCKET_CONTENTS;

typedef struct hash_table {
  BUCKET_CONTENTS **bucket_array;
  int nbuckets;
  int nentries;
} HASH_TABLE;

typedef int hash_wfunc (BUCKET_CONTENTS *);

extern HASH_TABLE *hash_create (int);
extern HASH_TABLE *hash_copy (HASH_TABLE *, sh_string_func_t *);
extern void hash_flush (HASH_TABLE *, sh_free_func_t *);
extern void hash_dispose (HASH_TABLE *);
extern void hash_walk (HASH_TABLE *, hash_wfunc *);

extern int hash_bucket (const char *, HASH_TABLE *);
extern int hash_size (HASH_TABLE *);

extern BUCKET_CONTENTS *hash_search (const char *, HASH_TABLE *, int);
extern BUCKET_CONTENTS *hash_insert (char *, HASH_TABLE *, int);
extern BUCKET_CONTENTS *hash_remove (const char *, HASH_TABLE *, int);

extern unsigned int hash_string (const char *);

typedef struct var_context {
  char *name;
  int scope;
  int flags;
  struct var_context *up;
  struct var_context *down;
  HASH_TABLE *table;
} VAR_CONTEXT;
typedef struct variable *sh_var_value_func_t (struct variable *);
typedef struct variable *sh_var_assign_func_t (struct variable *, char *, arrayind_t);

union _value {
  char *s;
  intmax_t i;
  COMMAND *f;
  ARRAY *a;
  HASH_TABLE *h;
  double d;

  long double ld;

  struct variable *v;
  void *opaque;
};

typedef struct variable {
  char *name;
  char *value;
  char *exportstr;
  sh_var_value_func_t *dynamic_value;

  sh_var_assign_func_t *assign_func;

  int attributes;
  int context;
} SHELL_VAR;

typedef struct _vlist {
  SHELL_VAR **list;
  int list_size;
  int list_len;
} VARLIST;
typedef int sh_var_map_func_t (SHELL_VAR *);

extern VAR_CONTEXT *global_variables;
extern VAR_CONTEXT *shell_variables;

extern HASH_TABLE *shell_functions;
extern HASH_TABLE *temporary_env;

extern int variable_context;
extern char *dollar_vars[];
extern char **export_env;

extern void initialize_shell_variables (char **, int);
extern SHELL_VAR *set_if_not (char *, char *);

extern void sh_set_lines_and_columns (int, int);
extern void set_pwd (void);
extern void set_ppid (void);
extern void make_funcname_visible (int);

extern SHELL_VAR *var_lookup (const char *, VAR_CONTEXT *);

extern SHELL_VAR *find_function (const char *);
extern FUNCTION_DEF *find_function_def (const char *);
extern SHELL_VAR *find_variable (const char *);
extern SHELL_VAR *find_variable_internal (const char *, int);
extern SHELL_VAR *find_tempenv_variable (const char *);
extern SHELL_VAR *copy_variable (SHELL_VAR *);
extern SHELL_VAR *make_local_variable (const char *);
extern SHELL_VAR *bind_variable (const char *, char *, int);
extern SHELL_VAR *bind_function (const char *, COMMAND *);

extern void bind_function_def (const char *, FUNCTION_DEF *);

extern SHELL_VAR **map_over (sh_var_map_func_t *, VAR_CONTEXT *);
SHELL_VAR **map_over_funcs (sh_var_map_func_t *);

extern SHELL_VAR **all_shell_variables (void);
extern SHELL_VAR **all_shell_functions (void);
extern SHELL_VAR **all_visible_variables (void);
extern SHELL_VAR **all_visible_functions (void);
extern SHELL_VAR **all_exported_variables (void);
extern SHELL_VAR **local_exported_variables (void);
extern SHELL_VAR **all_local_variables (void);

extern SHELL_VAR **all_array_variables (void);

extern char **all_variables_matching_prefix (const char *);

extern char **make_var_array (HASH_TABLE *);
extern char **add_or_supercede_exported_var (char *, int);

extern char *get_variable_value (SHELL_VAR *);
extern char *get_string_value (const char *);
extern char *sh_get_env_value (const char *);
extern char *make_variable_value (SHELL_VAR *, char *, int);

extern SHELL_VAR *bind_variable_value (SHELL_VAR *, char *, int);
extern SHELL_VAR *bind_int_variable (char *, char *);
extern SHELL_VAR *bind_var_to_int (char *, intmax_t);

extern int assign_in_env (WORD_DESC *);

extern int unbind_variable (const char *);
extern int unbind_func (const char *);
extern int unbind_function_def (const char *);
extern int makunbound (const char *, VAR_CONTEXT *);
extern int kill_local_variable (const char *);
extern void delete_all_variables (HASH_TABLE *);
extern void delete_all_contexts (VAR_CONTEXT *);

extern VAR_CONTEXT *new_var_context (char *, int);
extern void dispose_var_context (VAR_CONTEXT *);
extern VAR_CONTEXT *push_var_context (char *, int, HASH_TABLE *);
extern void pop_var_context (void);
extern VAR_CONTEXT *push_scope (int, HASH_TABLE *);
extern void pop_scope (int);

extern void push_context (char *, int, HASH_TABLE *);
extern void pop_context (void);
extern void push_dollar_vars (void);
extern void pop_dollar_vars (void);
extern void dispose_saved_dollar_vars (void);

extern void push_args (WORD_LIST *);
extern void pop_args (void);

extern void adjust_shell_level (int);
extern void non_unsettable (char *);
extern void dispose_variable (SHELL_VAR *);
extern void dispose_used_env_vars (void);
extern void dispose_function_env (void);
extern void dispose_builtin_env (void);
extern void merge_temporary_env (void);
extern void merge_builtin_env (void);
extern void kill_all_local_variables (void);

extern void set_var_read_only (char *);
extern void set_func_read_only (const char *);
extern void set_var_auto_export (char *);
extern void set_func_auto_export (const char *);

extern void sort_variables (SHELL_VAR **);

extern void maybe_make_export_env (void);
extern void update_export_env_inplace (char *, int, char *);
extern void put_command_name_into_env (char *);
extern void put_gnu_argv_flags_into_env (intmax_t, char *);

extern void print_var_list (SHELL_VAR **);
extern void print_func_list (SHELL_VAR **);
extern void print_assignment (SHELL_VAR *);
extern void print_var_value (SHELL_VAR *, int);
extern void print_var_function (SHELL_VAR *);

extern SHELL_VAR *make_new_array_variable (char *);
extern SHELL_VAR *make_local_array_variable (char *);

extern void set_pipestatus_array (int *, int);

extern void set_pipestatus_from_exit (int);

extern void stupidly_hack_special_variables (char *);

extern int get_random_number (void);

extern void sv_ifs (char *);
extern void sv_path (char *);
extern void sv_mail (char *);
extern void sv_globignore (char *);
extern void sv_ignoreeof (char *);
extern void sv_strict_posix (char *);
extern void sv_optind (char *);
extern void sv_opterr (char *);
extern void sv_locale (char *);

extern void sv_comp_wordbreaks (char *);
extern void sv_terminal (char *);
extern void sv_hostfile (char *);
extern void sv_winsize (char *);

extern void sv_histsize (char *);
extern void sv_histignore (char *);
extern void sv_history_control (char *);

extern void sv_histchars (char *);

extern void sv_histtimefmt (char *);

extern void sv_tz (char *);
extern SHELL_VAR *convert_var_to_array (SHELL_VAR *);

extern SHELL_VAR *bind_array_variable (char *, arrayind_t, char *, int);
extern SHELL_VAR *assign_array_element (char *, char *, int);

extern SHELL_VAR *find_or_make_array_variable (char *, int);

extern SHELL_VAR *assign_array_from_string (char *, char *, int);
extern SHELL_VAR *assign_array_var_from_word_list (SHELL_VAR *, WORD_LIST *, int);

extern WORD_LIST *expand_compound_array_assignment (char *, int);
extern void assign_compound_array_list (SHELL_VAR *, WORD_LIST *, int);
extern SHELL_VAR *assign_array_var_from_string (SHELL_VAR *, char *, int);

extern int unbind_array_element (SHELL_VAR *, char *);
extern int skipsubscript (const char *, int);
extern void print_array_assignment (SHELL_VAR *, int);

extern arrayind_t array_expand_index (char *, int);
extern int valid_array_reference (char *);
extern char *array_value (char *, int, int *);
extern char *get_array_value (char *, int, int *);

extern char *array_keys (char *, int);

extern char *array_variable_name (char *, char **, int *);
extern SHELL_VAR *array_variable_part (char *, char **, int *);
extern volatile int interrupt_state;
extern volatile int terminating_signal;

extern void begin_unwind_frame (char *);
extern void discard_unwind_frame (char *);
extern void run_unwind_frame (char *);
extern void add_unwind_protect ();
extern void remove_unwind_protect (void);
extern void run_unwind_protects (void);
extern void clear_unwind_protect_list (int);
extern void uwp_init (void);

extern void unwind_protect_mem (char *, int);
extern void dispose_command (COMMAND *);
extern void dispose_word_desc (WORD_DESC *);
extern void dispose_word (WORD_DESC *);
extern void dispose_words (WORD_LIST *);
extern void dispose_word_array (char **);
extern void dispose_redirects (REDIRECT *);

extern void dispose_cond_node (COND_COM *);

extern void dispose_function_def_contents (FUNCTION_DEF *);
extern void dispose_function_def (FUNCTION_DEF *);
extern void cmd_init (void);

extern WORD_DESC *alloc_word_desc (void);
extern WORD_DESC *make_bare_word (const char *);
extern WORD_DESC *make_word_flags (WORD_DESC *, const char *);
extern WORD_DESC *make_word (const char *);
extern WORD_DESC *make_word_from_token (int);

extern WORD_LIST *make_word_list (WORD_DESC *, WORD_LIST *);

extern COMMAND *make_command (enum command_type, SIMPLE_COM *);
extern COMMAND *command_connect (COMMAND *, COMMAND *, int);
extern COMMAND *make_for_command (WORD_DESC *, WORD_LIST *, COMMAND *, int);
extern COMMAND *make_group_command (COMMAND *);
extern COMMAND *make_case_command (WORD_DESC *, PATTERN_LIST *, int);
extern PATTERN_LIST *make_pattern_list (WORD_LIST *, COMMAND *);
extern COMMAND *make_if_command (COMMAND *, COMMAND *, COMMAND *);
extern COMMAND *make_while_command (COMMAND *, COMMAND *);
extern COMMAND *make_until_command (COMMAND *, COMMAND *);
extern COMMAND *make_bare_simple_command (void);
extern COMMAND *make_simple_command (ELEMENT, COMMAND *);
extern void make_here_document (REDIRECT *);
extern REDIRECT *make_redirection (int, enum r_instruction, REDIRECTEE);
extern COMMAND *make_function_def (WORD_DESC *, COMMAND *, int, int);
extern COMMAND *clean_simple_command (COMMAND *);

extern COMMAND *make_arith_command (WORD_LIST *);

extern COMMAND *make_select_command (WORD_DESC *, WORD_LIST *, COMMAND *, int);

extern COND_COM *make_cond_node (int, WORD_DESC *, COND_COM *, COND_COM *);
extern COMMAND *make_cond_command (COND_COM *);

extern COMMAND *make_arith_for_command (WORD_LIST *, COMMAND *, int);

extern COMMAND *make_subshell_command (COMMAND *);

extern COMMAND *connect_async_list (COMMAND *, COMMAND *, int);

extern char * de_backslash (char *);

extern void unquote_bang (char *);

extern char *extract_command_subst (char *, int *);

extern char *extract_arithmetic_subst (char *, int *);

extern char *extract_process_subst (char *, char *, int *);

extern char *assignment_name (char *);

extern char *string_list_internal (WORD_LIST *, char *);

extern char *string_list (WORD_LIST *);

extern char *string_list_dollar_star (WORD_LIST *);

extern char *string_list_dollar_at (WORD_LIST *, int);

extern void word_list_remove_quoted_nulls (WORD_LIST *);

extern WORD_LIST *list_string (char *, char *, int);

extern char *get_word_from_string (char **, char *, char **);
extern char *strip_trailing_ifs_whitespace (char *, char *, int);

extern int do_assignment (char *);
extern int do_assignment_no_expand (char *);
extern int do_word_assignment (WORD_DESC *);

extern char *sub_append_string (char *, char *, int *, int *);

extern char *sub_append_number (intmax_t, char *, int *, int *);

extern WORD_LIST *list_rest_of_args (void);

extern char *string_rest_of_args (int);

extern int number_of_args (void);

extern WORD_LIST *expand_string_unsplit (char *, int);

extern WORD_LIST *expand_string_assignment (char *, int);

extern WORD_LIST *expand_prompt_string (char *, int, int);

extern WORD_LIST *expand_string (char *, int);

extern char *expand_string_to_string (char *, int);
extern char *expand_string_unsplit_to_string (char *, int);
extern char *expand_assignment_string_to_string (char *, int);

extern char *expand_arith_string (char *, int);

extern char *dequote_string (char *);

extern WORD_LIST *dequote_list (WORD_LIST *);

extern WORD_LIST *expand_word (WORD_DESC *, int);

extern WORD_LIST *expand_word_unsplit (WORD_DESC *, int);
extern WORD_LIST *expand_word_leave_quoted (WORD_DESC *, int);

extern char *get_dollar_var_value (intmax_t);

extern char *quote_string (char *);

extern char *quote_escapes (char *);

extern char *string_quote_removal (char *, int);

extern WORD_DESC *word_quote_removal (WORD_DESC *, int);

extern WORD_LIST *word_list_quote_removal (WORD_LIST *, int);

extern void setifs (SHELL_VAR *);

extern char *getifs (void);

extern WORD_LIST *word_split (WORD_DESC *, char *);

extern WORD_LIST *expand_words (WORD_LIST *);

extern WORD_LIST *expand_words_no_vars (WORD_LIST *);

extern WORD_LIST *expand_words_shellexp (WORD_LIST *);

extern char *command_substitute (char *, int);
extern char *pat_subst (char *, char *, char *, int);

extern int fifos_pending (void);
extern void unlink_fifo_list (void);

extern WORD_LIST *list_string_with_quotes (char *);

extern char *extract_array_assignment_list (char *, int *);

extern char *remove_backslashes (char *);
extern char *cond_expand_word (WORD_DESC *, int);

extern int char_is_quoted (char *, int);
extern int unclosed_pair (char *, int, char *);
extern int skip_to_delim (char *, int, char *);
extern WORD_LIST *split_at_delims (char *, int, char *, int, int *, int *);

extern SHELL_VAR *ifs_var;
extern char *ifs_value;
extern unsigned char ifs_cmap[];

extern unsigned char ifs_firstc[];
extern size_t ifs_firstc_len;
typedef void SigHandler (int);
extern SigHandler *set_signal_handler (int, SigHandler *);
extern volatile int sigwinch_received;

extern int interrupt_immediately;
extern int terminate_immediately;

extern void termsig_sighandler (int);
extern void termsig_handler (int);
extern void sigint_sighandler (int);
extern void initialize_signals (int);
extern void initialize_terminating_signals (void);
extern void reset_terminating_signals (void);
extern void top_level_cleanup (void);
extern void throw_to_top_level (void);
extern void jump_to_top_level (int) __attribute__((__noreturn__));

extern void sigwinch_sighandler (int);
extern void set_sigwinch_handler (void);
extern void unset_sigwinch_handler (void);

extern SigHandler *set_sigint_handler (void);
extern SigHandler *trap_to_sighandler (int);
extern void trap_handler (int);
extern intmax_t evalexp (char *, int *);

extern char *make_command_string (COMMAND *);
extern char *named_function_string (char *, COMMAND *, int);

extern void print_command (COMMAND *);
extern void print_simple_command (SIMPLE_COM *);
extern void print_word_list (WORD_LIST *, char *);

extern void print_for_command_head (FOR_COM *);

extern void print_select_command_head (SELECT_COM *);

extern void print_case_command_head (CASE_COM *);

extern void print_arith_command (WORD_LIST *);

extern void print_cond_command (COND_COM *);

extern char *indirection_level_string (void);
extern void xtrace_print_assignment (char *, char *, int, int);
extern void xtrace_print_word_list (WORD_LIST *, int);
extern void xtrace_print_for_command_head (FOR_COM *);

extern void xtrace_print_select_command_head (SELECT_COM *);

extern void xtrace_print_case_command_head (CASE_COM *);

extern void xtrace_print_arith_cmd (WORD_LIST *);

extern void xtrace_print_cond_term (int, int, WORD_DESC *, char *, char *);

extern void exit_shell (int) __attribute__((__noreturn__));
extern void sh_exit (int) __attribute__((__noreturn__));
extern void disable_priv_mode (void);
extern void unbind_args (void);

extern int shell_is_restricted (char *);
extern int maybe_make_restricted (char *);

extern void unset_bash_input (int);
extern void get_current_user_info (void);

extern int reader_loop (void);
extern int parse_command (void);
extern int read_command (void);

extern char **brace_expand (char *);

extern int yyparse (void);
extern int return_EOF (void);
extern void reset_parser (void);
extern WORD_LIST *parse_string_to_word_list (char *, int, const char *);

extern void free_pushed_string_input (void);

extern char *decode_prompt_string (char *);

extern int get_current_prompt_level (void);
extern void set_current_prompt_level (int);

extern char *history_delimiting_chars (void);

extern void set_default_locale (void);
extern void set_default_locale_vars (void);
extern int set_locale_var (char *, char *);
extern int set_lang (char *, char *);
extern void set_default_lang (void);
extern char *get_locale_var (char *);
extern char *localetrans (char *, int, int *);
extern char *mk_msgstr (char *, int *);
extern char *localeexpand (char *, int, int, int, int *);

extern void list_walk (GENERIC_LIST *, sh_glist_func_t *);
extern void wlist_walk (WORD_LIST *, sh_icpfunc_t *);
extern GENERIC_LIST *list_reverse ();
extern int list_length ();
extern GENERIC_LIST *list_append ();
extern GENERIC_LIST *list_remove ();

extern int find_string_in_alist (char *, STRING_INT_ALIST *, int);
extern char *find_token_in_alist (int, STRING_INT_ALIST *, int);
extern int find_index_in_alist (char *, STRING_INT_ALIST *, int);

extern char *substring (char *, int, int);
extern char *strsub (char *, char *, char *, int);
extern char *strcreplace (char *, int, char *, int);
extern void strip_leading (char *);
extern void strip_trailing (char *, int, int);
extern void xbcopy (char *, char *, int);

extern char *shell_version_string (void);
extern void show_shell_version (int);

extern long get_clk_tck (void);

extern void clock_t_to_secs ();
extern void print_clock_t ();

extern char *fmtulong (unsigned long int, int, char *, size_t, int);

extern char *fmtullong (unsigned long long int, int, char *, size_t, int);

extern char *fmtumax (uintmax_t, int, char *, size_t, int);

extern char *inttostr (intmax_t, char *, size_t);
extern char *itos (intmax_t);
extern char *uinttostr (uintmax_t, char *, size_t);
extern char *uitos (uintmax_t);

extern char *sh_makepath (const char *, const char *, int);

extern int isnetconn (int);

extern int netopen (char *);
extern int getmaxgroups (void);
extern long getmaxchild (void);

extern char *sh_canonpath (char *, int);

extern char *sh_physpath (char *, int);
extern char *sh_realpath (const char *, char *);

extern int sh_setlinebuf (FILE *);

extern int sh_eaccess (char *, int);

extern int sh_regmatch (const char *, const char *, int);

extern char *sh_single_quote (char *);
extern char *sh_double_quote (char *);
extern char *sh_mkdoublequoted (const char *, int, int);
extern char *sh_un_double_quote (char *);
extern char *sh_backslash_quote (char *);
extern char *sh_backslash_quote_for_double_quotes (char *);
extern int sh_contains_shell_metas (char *);

extern int spname (char *, char *);
extern char *strindex (const char *, const char *);

typedef struct _list_of_strings {
  char **list;
  int list_size;
  int list_len;
} STRINGLIST;

typedef int sh_strlist_map_func_t (char *);

extern STRINGLIST *strlist_create (int);
extern STRINGLIST *strlist_resize (STRINGLIST *, int);
extern void strlist_flush (STRINGLIST *);
extern void strlist_dispose (STRINGLIST *);
extern int strlist_remove (STRINGLIST *, char *);
extern STRINGLIST *strlist_copy (STRINGLIST *);
extern STRINGLIST *strlist_merge (STRINGLIST *, STRINGLIST *);
extern STRINGLIST *strlist_append (STRINGLIST *, STRINGLIST *);
extern STRINGLIST *strlist_prefix_suffix (STRINGLIST *, char *, char *);
extern void strlist_print (STRINGLIST *, char *);
extern void strlist_walk (STRINGLIST *, sh_strlist_map_func_t *);
extern void strlist_sort (STRINGLIST *);

extern char **strvec_create (int);
extern char **strvec_resize (char **, int);
extern void strvec_flush (char **);
extern void strvec_dispose (char **);
extern int strvec_remove (char **, char *);
extern int strvec_len (char **);
extern int strvec_search (char **, char *);
extern char **strvec_copy (char **);
extern int strvec_strcmp (char **, char **);
extern void strvec_sort (char **);

extern char **strvec_from_word_list (WORD_LIST *, int, int, int *);
extern WORD_LIST *strvec_to_word_list (char **, int, int);
extern char *ansicstr (char *, int, int, int *, int *);
extern char *ansic_quote (char *, int, int *);
extern int ansic_shouldquote (const char *);
extern char *ansiexpand (char *, int, int, int *);

extern void timeval_to_secs ();
extern void print_timeval ();

extern char *sh_mktmpname (char *, int);
extern int sh_mktmpfd (char *, int, char **);

extern void get_new_window_size (int, int *, int *);

extern char *xstrchr (const char *, int);

extern int zcatfd (int, int, char *);

extern ssize_t zread (int, char *, size_t);
extern ssize_t zreadintr (int, char *, size_t);
extern ssize_t zreadc (int, char *);
extern void zreset (void);
extern void zsyncfd (int);

extern int zwrite (int, char *, size_t);

extern int EOF_Reached;
extern char **shell_environment;
extern WORD_LIST *rest_of_args;

extern int debugging_mode;
extern int executing, login_shell;
extern int interactive, interactive_shell;
extern int startup_state;
extern int shell_compatibility_level;

struct fd_bitmap {
  int size;
  char *bitmap;
};

struct user_info {
  uid_t uid, euid;
  gid_t gid, egid;
  char *user_name;
  char *shell;
  char *home_dir;
};

extern struct user_info current_user;
typedef struct _sh_parser_state_t {

  int parser_state;
  int *token_state;

  int input_line_terminator;
  int eof_encountered;

  int current_command_line_count;

  int remember_on_history;
  int history_expansion_inhibited;

  int last_command_exit_value;

  ARRAY *pipestatus;

  sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;

  int expand_aliases;
  int echo_input_at_read;

} sh_parser_state_t;

extern char *parser_remaining_input (void);

extern sh_parser_state_t *save_parser_state (sh_parser_state_t *);
extern void restore_parser_state (sh_parser_state_t *);
struct flags_alist {
  char name;
  int *value;
};

extern struct flags_alist shell_flags[];
extern char optflags[];

extern int
  mark_modified_vars, exit_immediately_on_error, disallow_filename_globbing,
  place_keywords_in_env, read_but_dont_execute,
  just_one_command, unbound_vars_is_error, echo_input_at_read,
  echo_command_at_execute, no_invisible_vars, noclobber,
  hashing_enabled, forced_interactive, privileged_mode,
  asynchronous_notification, interactive_comments, no_symbolic_links,
  function_trace_mode, error_trace_mode, pipefail_opt;

extern int brace_expansion;

extern int history_expansion;

extern int restricted;
extern int restricted_shell;

extern int *find_flag (int);
extern int change_flag (int, int);
extern char *which_set_flags (void);
extern void reset_shell_flags (void);

extern void initialize_flags (void);
extern char *trap_list[];

extern void initialize_traps (void);

extern void run_pending_traps (void);

extern void maybe_set_sigchld_trap (char *);
extern void set_sigchld_trap (char *);

extern void set_debug_trap (char *);
extern void set_error_trap (char *);
extern void set_return_trap (char *);

extern void set_sigint_trap (char *);
extern void set_signal (int, char *);

extern void restore_default_signal (int);
extern void ignore_signal (int);
extern int run_exit_trap (void);
extern void run_trap_cleanup (int);
extern int run_debug_trap (void);
extern void run_error_trap (void);
extern void run_return_trap (void);

extern void free_trap_strings (void);
extern void reset_signal_handlers (void);
extern void restore_original_signals (void);

extern char *signal_name (int);

extern int decode_signal (char *, int);
extern void run_interrupt_trap (void);
extern int maybe_call_trap_handler (int);
extern int signal_is_trapped (int);
extern int signal_is_ignored (int);
extern int signal_is_special (int);
extern void set_signal_ignored (int);
extern int signal_in_progress (int);
extern int time_to_check_mail (void);
extern void reset_mail_timer (void);
extern void reset_mail_files (void);
extern void free_mail_files (void);
extern char *make_default_mailpath (void);
extern void remember_mail_dates (void);
extern void check_mail (void);
typedef struct alias {
  char *name;
  char *value;
  char flags;
} alias_t;

extern HASH_TABLE *aliases;

extern void initialize_aliases (void);

extern alias_t *find_alias (char *);

extern char *get_alias_value (char *);

extern void add_alias (char *, char *);

extern int remove_alias (char *);

extern void delete_all_aliases (void);

extern alias_t **all_aliases (void);

extern char *alias_expand_word (char *);

extern char *alias_expand (char *);
struct builtin {
  char *name;
  sh_builtin_func_t *function;
  int flags;
  char * const *long_doc;
  const char *short_doc;
  char *handle;
};

extern int num_shell_builtins;
extern struct builtin static_shell_builtins[];
extern struct builtin *shell_builtins;
extern struct builtin *current_builtin;
extern void builtin_error (const char *, ...) __attribute__((__format__ (printf, 1, 2)));
extern void builtin_usage (void);
extern void no_args (WORD_LIST *);
extern int no_options (WORD_LIST *);

extern void sh_needarg (char *);
extern void sh_neednumarg (char *);
extern void sh_notfound (char *);
extern void sh_invalidopt (char *);
extern void sh_invalidoptname (char *);
extern void sh_invalidid (char *);
extern void sh_invalidnum (char *);
extern void sh_invalidsig (char *);
extern void sh_erange (char *, char *);
extern void sh_badpid (char *);
extern void sh_badjob (char *);
extern void sh_readonly (const char *);
extern void sh_nojobs (char *);
extern void sh_restricted (char *);
extern void sh_notbuiltin (char *);
extern void sh_wrerror (void);

extern char **make_builtin_argv (WORD_LIST *, int *);
extern void remember_args (WORD_LIST *, int);

extern int dollar_vars_changed (void);
extern void set_dollar_vars_unchanged (void);
extern void set_dollar_vars_changed (void);

extern intmax_t get_numeric_arg (WORD_LIST *, int);
extern int get_exitstat (WORD_LIST *);
extern int read_octal (char *);

extern char *the_current_working_directory;
extern char *get_working_directory (char *);
extern void set_working_directory (char *);

extern int get_job_by_name (const char *, int);
extern int get_job_spec (WORD_LIST *);

extern int display_signal_list (WORD_LIST *, int);

extern struct builtin *builtin_address_internal (char *, int);
extern sh_builtin_func_t *find_shell_builtin (char *);
extern sh_builtin_func_t *builtin_address (char *);
extern sh_builtin_func_t *find_special_builtin (char *);
extern void initialize_shell_builtins (void);

extern void bash_logout (void);

extern void getopts_reset (int);

extern int minus_o_option_value (char *);
extern void list_minus_o_opts (int, int);
extern char **get_minus_o_opts (void);
extern int set_minus_o_option (int, char *);

extern void set_shellopts (void);
extern void parse_shellopts (char *);
extern void initialize_shell_options (int);

extern void reset_shell_options (void);

extern void reset_shopt_options (void);
extern char **get_shopt_options (void);

extern int shopt_setopt (char *, int);
extern int shopt_listopt (char *, int);

extern int set_login_shell (int);

extern int describe_command (char *, int);

extern int set_or_show_attributes (WORD_LIST *, int, int);
extern int show_var_attributes (SHELL_VAR *, int, int);
extern int show_name_attributes (char *, int);
extern void set_var_attribute (char *, int, int);

extern char *get_dirstack_from_string (char *);
extern char *get_dirstack_element (intmax_t, int);
extern void set_dirstack_element (intmax_t, int, char *);
extern WORD_LIST *get_directory_stack (int);

extern int parse_and_execute (char *, const char *, int);
extern void parse_and_execute_cleanup (void);

extern int maybe_execute_file (const char *, int);
extern int source_file (const char *, int);
extern int fc_execute_file (const char *);

typedef struct process {
  struct process *next;
  pid_t pid;
  WAIT status;
  int running;
  char *command;
} PROCESS;
typedef enum { JRUNNING, JSTOPPED, JDEAD, JMIXED } JOB_STATE;
typedef struct job {
  char *wd;
  PROCESS *pipe;
  pid_t pgrp;
  JOB_STATE state;
  int flags;

  COMMAND *deferred;
  sh_vptrfunc_t *j_cleanup;
  void * cleanarg;

} JOB;

struct jobstats {

  long c_childmax;

  int c_living;
  int c_reaped;
  int c_injobs;

  int c_totforked;
  int c_totreaped;

  int j_jobslots;
  int j_lastj;
  int j_firstj;
  int j_njobs;
  int j_ndead;

  int j_current;
  int j_previous;

  JOB *j_lastmade;
  JOB *j_lastasync;
};

struct pidstat {
 struct pidstat *next;
 pid_t pid;
 int status;
};

struct bgpids {
  struct pidstat *list;
  struct pidstat *end;
  int npid;
};
extern struct jobstats js;

extern pid_t original_pgrp, shell_pgrp, pipeline_pgrp;
extern pid_t last_made_pid, last_asynchronous_pid;
extern int asynchronous_notification;

extern JOB **jobs;

extern void making_children (void);
extern void stop_making_children (void);
extern void cleanup_the_pipeline (void);
extern void save_pipeline (int);
extern void restore_pipeline (int);
extern void start_pipeline (void);
extern int stop_pipeline (int, COMMAND *);

extern void delete_job (int, int);
extern void nohup_job (int);
extern void delete_all_jobs (int);
extern void nohup_all_jobs (int);

extern int count_all_jobs (void);

extern void terminate_current_pipeline (void);
extern void terminate_stopped_jobs (void);
extern void hangup_all_jobs (void);
extern void kill_current_pipeline (void);

extern int get_job_by_pid (pid_t, int);
extern void describe_pid (pid_t);

extern void list_one_job (JOB *, int, int, int);
extern void list_all_jobs (int);
extern void list_stopped_jobs (int);
extern void list_running_jobs (int);

extern pid_t make_child (char *, int);

extern int get_tty_state (void);
extern int set_tty_state (void);

extern int wait_for_single_pid (pid_t);
extern void wait_for_background_pids (void);
extern int wait_for (pid_t);
extern int wait_for_job (int);

extern void notify_and_cleanup (void);
extern void reap_dead_jobs (void);
extern int start_job (int, int);
extern int kill_pid (pid_t, int, int);
extern int initialize_job_control (int);
extern void initialize_job_signals (void);
extern int give_terminal_to (pid_t, int);

extern void unfreeze_jobs_list (void);
extern int set_job_control (int);
extern void without_job_control (void);
extern void end_job_control (void);
extern void restart_job_control (void);
extern void set_sigchld_handler (void);
extern void ignore_tty_job_signals (void);
extern void default_tty_job_signals (void);

extern void init_job_stats (void);

extern int job_control;

typedef int sh_cget_func_t (void);
typedef int sh_cunget_func_t (int);

enum stream_type {st_none, st_stdin, st_stream, st_string, st_bstream};
typedef struct BSTREAM
{
  int b_fd;
  char *b_buffer;
  size_t b_size;
  size_t b_used;
  int b_flag;
  size_t b_inputp;
} BUFFERED_STREAM;

extern int default_buffered_input;

typedef union {
  FILE *file;
  char *string;

  int buffered_fd;

} INPUT_STREAM;

typedef struct {
  enum stream_type type;
  char *name;
  INPUT_STREAM location;
  sh_cget_func_t *getter;
  sh_cunget_func_t *ungetter;
} BASH_INPUT;

extern BASH_INPUT bash_input;

extern void initialize_bash_input (void);
extern void init_yy_io (sh_cget_func_t *, sh_cunget_func_t *, enum stream_type, const char *, INPUT_STREAM);
extern char *yy_input_name (void);
extern void with_input_from_stdin (void);
extern void with_input_from_string (char *, const char *);
extern void with_input_from_stream (FILE *, const char *);
extern void push_stream (int);
extern void pop_stream (void);
extern int stream_on_stack (enum stream_type);
extern char *read_secondary_line (int);
extern int find_reserved_word (char *);
extern void gather_here_documents (void);
extern void execute_variable_command (char *, char *);

extern int *save_token_state (void);
extern void restore_token_state (int *);

extern int getc_with_restart (FILE *);
extern int ungetc_with_restart (int, FILE *);

extern int fd_is_bash_input (int);
extern int set_bash_input_fd (int);
extern int save_bash_input (int, int);
extern int check_bash_input (int);
extern int duplicate_buffered_stream (int, int);
extern BUFFERED_STREAM *fd_to_buffered_stream (int);
extern BUFFERED_STREAM *set_buffered_stream (int, BUFFERED_STREAM *);
extern BUFFERED_STREAM *open_buffered_stream (char *);
extern void free_buffered_stream (BUFFERED_STREAM *);
extern int close_buffered_stream (BUFFERED_STREAM *);
extern int close_buffered_fd (int);
extern int sync_buffered_stream (int);
extern int buffered_getchar (void);
extern int buffered_ungetchar (int);
extern void with_input_from_buffered_stream (int, char *);
extern struct fd_bitmap *new_fd_bitmap (int);
extern void dispose_fd_bitmap (struct fd_bitmap *);
extern void close_fd_bitmap (struct fd_bitmap *);
extern int executing_line_number (void);
extern int execute_command (COMMAND *);
extern int execute_command_internal (COMMAND *, int, int, int, struct fd_bitmap *);
extern int shell_execve (char *, char **, char **);
extern void setup_async_signals (void);
extern void dispose_exec_redirects (void);

extern int execute_shell_function (SHELL_VAR *, WORD_LIST *);

extern void close_all_files (void);
extern int file_status (const char *);
extern int executable_file (const char *);
extern int is_directory (const char *);
extern int executable_or_directory (const char *);
extern char *find_user_command (const char *);
extern char *find_path_file (const char *);
extern char *search_for_command (const char *);
extern char *user_command_matches (const char *, int, int);

extern int remember_on_history;
extern int enable_history_list;
extern int literal_history;
extern int force_append_history;
extern int history_lines_this_session;
extern int history_lines_in_file;
extern int history_expansion;
extern int history_control;
extern int command_oriented_history;
extern int current_command_first_line_saved;
extern int hist_last_line_added;
extern int hist_last_line_pushed;

extern int history_expansion_inhibited;

extern void bash_initialize_history (void);
extern void bash_history_reinit (int);
extern void bash_history_disable (void);
extern void bash_history_enable (void);
extern void load_history (void);
extern void save_history (void);
extern int maybe_append_history (char *);
extern int maybe_save_shell_history (void);
extern char *pre_process_line (char *, int, int);
extern void maybe_add_history (char *);
extern void bash_add_history (char *);
extern int check_add_history (char *, int);
extern int history_number (void);

extern void setup_history_ignore (char *);

extern char *last_history_line (void);
typedef int Function(const char *, int);
typedef void VFunction(void);
typedef void VCPFunction(char *);
typedef char *CPFunction(const char *, int);
typedef char **CPPFunction(const char *, int, int);
typedef char *rl_compentry_func_t(const char *, int);
typedef int rl_command_func_t(int, int);

typedef struct {
 int length;
} HISTORY_STATE;

typedef void *histdata_t;

typedef struct _hist_entry {
 const char *line;
 histdata_t data;
} HIST_ENTRY;

typedef struct _keymap_entry {
 char type;

 Function *function;
} KEYMAP_ENTRY;

typedef KEYMAP_ENTRY KEYMAP_ENTRY_ARRAY[256];
typedef KEYMAP_ENTRY *Keymap;

struct winsize {
 unsigned short ws_row;
 unsigned short ws_col;
 unsigned short ws_xpixel;
 unsigned short ws_ypixel;
};

struct ttysize {
 unsigned short ts_lines;
 unsigned short ts_cols;
 unsigned short ts_xxx;
 unsigned short ts_yyy;
};

int ioctl(int, unsigned long, ...);

extern const char *rl_library_version;
extern int rl_readline_version;
extern char *rl_readline_name;
extern FILE *rl_instream;
extern FILE *rl_outstream;
extern char *rl_line_buffer;
extern int rl_point, rl_end;
extern int history_base, history_length;
extern int max_input_history;
extern char *rl_basic_word_break_characters;
extern char *rl_completer_word_break_characters;
extern char *rl_completer_quote_characters;
extern Function *rl_completion_entry_function;
extern char *(*rl_completion_word_break_hook)(void);
extern CPPFunction *rl_attempted_completion_function;
extern int rl_attempted_completion_over;
extern int rl_completion_type;
extern int rl_completion_query_items;
extern char *rl_special_prefixes;
extern int rl_completion_append_character;
extern int rl_inhibit_completion;
extern Function *rl_pre_input_hook;
extern Function *rl_startup_hook;
extern char *rl_terminal_name;
extern int rl_already_prompted;
extern char *rl_prompt;

extern KEYMAP_ENTRY_ARRAY emacs_standard_keymap,
   emacs_meta_keymap,
   emacs_ctlx_keymap;
extern int rl_filename_completion_desired;
extern int rl_ignore_completion_duplicates;
extern int (*rl_getc_function)(FILE *);
extern VFunction *rl_redisplay_function;
extern VFunction *rl_completion_display_matches_hook;
extern VFunction *rl_prep_term_function;
extern VFunction *rl_deprep_term_function;
extern int readline_echoing_p;
extern int _rl_print_completions_horizontally;

char *readline(const char *);
int rl_initialize(void);

void using_history(void);
int add_history(const char *);
void clear_history(void);
void stifle_history(int);
int unstifle_history(void);
int history_is_stifled(void);
int where_history(void);
HIST_ENTRY *current_history(void);
HIST_ENTRY *history_get(int);
HIST_ENTRY *remove_history(int);
HIST_ENTRY *replace_history_entry(int, const char *, histdata_t);
int history_total_bytes(void);
int history_set_pos(int);
HIST_ENTRY *previous_history(void);
HIST_ENTRY *next_history(void);
int history_search(const char *, int);
int history_search_prefix(const char *, int);
int history_search_pos(const char *, int, int);
int read_history(const char *);
int write_history(const char *);
int history_truncate_file (const char *, int);
int history_expand(char *, char **);
char **history_tokenize(const char *);
const char *get_history_event(const char *, int *, int);
char *history_arg_extract(int, int, const char *);

char *tilde_expand(char *);
char *filename_completion_function(const char *, int);
char *username_completion_function(const char *, int);
int rl_complete(int, int);
int rl_read_key(void);
char **completion_matches(const char *, CPFunction *);
void rl_display_match_list(char **, int, int);

int rl_insert(int, int);
int rl_insert_text(const char *);
void rl_reset_terminal(const char *);
int rl_bind_key(int, rl_command_func_t *);
int rl_newline(int, int);
void rl_callback_read_char(void);
void rl_callback_handler_install(const char *, VCPFunction *);
void rl_callback_handler_remove(void);
void rl_redisplay(void);
int rl_get_previous_history(int, int);
void rl_prep_terminal(int);
void rl_deprep_terminal(void);
int rl_read_init_file(const char *);
int rl_parse_and_bind(const char *);
int rl_variable_bind(const char *, const char *);
void rl_stuff_char(int);
int rl_add_defun(const char *, Function *, int);
HISTORY_STATE *history_get_history_state(void);
void rl_get_screen_size(int *, int *);
void rl_set_screen_size(int, int);
char *rl_filename_completion_function (const char *, int);
int _rl_abort_internal(void);
int _rl_qsort_string_compare(char **, char **);
char **rl_completion_matches(const char *, rl_compentry_func_t *);
void rl_forced_update_display(void);
int rl_set_prompt(const char *);
int rl_on_new_line(void);

int rl_kill_text(int, int);
Keymap rl_get_keymap(void);
void rl_set_keymap(Keymap);
Keymap rl_make_bare_keymap(void);
int rl_generic_bind(int, const char *, const char *, Keymap);
int rl_bind_key_in_map(int, rl_command_func_t *, Keymap);
void rl_cleanup_after_signal(void);
void rl_free_line_state(void);
extern char *dist_version, *release_status;
extern int patch_level, build_version;
extern int shell_level;
extern int subshell_environment;
extern int last_command_exit_value;
extern int line_number;
extern int expand_aliases;
extern int array_needs_making;
extern int gnu_error_format;
extern char *primary_prompt, *secondary_prompt;
extern char *this_command_name;

int shell_initialized = 0;

COMMAND *global_command = (COMMAND *)((void *)0);

struct user_info current_user =
{
  (uid_t)-1, (uid_t)-1, (gid_t)-1, (gid_t)-1,
  (char *)((void *)0), (char *)((void *)0), (char *)((void *)0)
};

char *current_host_name = (char *)((void *)0);
int login_shell = 0;

int interactive = 0;

int interactive_shell = 0;

int hup_on_exit = 0;
int startup_state = 0;

int debugging_login_shell = 0;

char **shell_environment;

int executing = 0;

int current_command_number = 1;

int indirection_level = 0;

char *shell_name = (char *)((void *)0);

time_t shell_start_time;

int running_under_emacs;

static char *bashrc_file = "~/.bashrc";

static int act_like_sh;

static int su_shell;

static int sourced_env;

static int running_setuid;

static int debugging;
static int no_rc;
static int no_profile;
static int do_version;
static int make_login_shell;
static int want_initial_help;

int debugging_mode = 0;
int no_line_editing = 0;
int dump_translatable_strings;
int dump_po_strings;
int wordexp_only = 0;
int protected_mode = 0;

int posixly_correct = 0;

struct {
  char *name;
  int type;
  int *int_value;
  char **char_value;
} long_args[] = {
  { "debug", 1, &debugging, (char **)0x0 },

  { "debugger", 1, &debugging_mode, (char **)0x0 },

  { "dump-po-strings", 1, &dump_po_strings, (char **)0x0 },
  { "dump-strings", 1, &dump_translatable_strings, (char **)0x0 },
  { "help", 1, &want_initial_help, (char **)0x0 },
  { "init-file", 2, (int *)0x0, &bashrc_file },
  { "login", 1, &make_login_shell, (char **)0x0 },
  { "noediting", 1, &no_line_editing, (char **)0x0 },
  { "noprofile", 1, &no_profile, (char **)0x0 },
  { "norc", 1, &no_rc, (char **)0x0 },
  { "posix", 1, &posixly_correct, (char **)0x0 },
  { "protected", 1, &protected_mode, (char **)0x0 },
  { "rcfile", 2, (int *)0x0, &bashrc_file },

  { "restricted", 1, &restricted, (char **)0x0 },

  { "verbose", 1, &echo_input_at_read, (char **)0x0 },
  { "version", 1, &do_version, (char **)0x0 },
  { "wordexp", 1, &wordexp_only, (char **)0x0 },
  { (char *)0x0, 1, (int *)0x0, (char **)0x0 }
};

procenv_t subshell_top_level;
int subshell_argc;
char **subshell_argv;
char **subshell_envp;

int default_buffered_input = -1;

int read_from_stdin;
int want_pending_command;

char *command_execution_string;

int malloc_trace_at_exit = 0;

static int shell_reinitialized = 0;

static FILE *default_input;

static STRING_INT_ALIST *shopt_alist;
static int shopt_ind = 0, shopt_len = 0;

static int parse_long_options (char **, int, int);
static int parse_shell_options (char **, int, int);
static int bind_args (char **, int, int, int);

static void start_debugger (void);

static void add_shopt_to_alist (char *, int);
static void run_shopt_alist (void);

static void execute_env_file (char *);
static void run_startup_files (void);
static int open_shell_script (char *);
static void set_bash_input (void);
static int run_one_command (char *);
static int run_wordexp (char *);

static int uidget (void);

static void init_interactive (void);
static void init_noninteractive (void);

static void set_shell_name (char *);
static void shell_initialize (void);
static void shell_reinitialize (void);

static void show_shell_usage (FILE *, int);
int
main (argc, argv, env)
     int argc;
     char **argv, **env;

{
  register int i;
  int code, old_errexit_flag;

  int saverst;

  volatile int locally_skip_execution;
  volatile int arg_index, top_level_arg_index;

  ((void) &(argc));
  ((void) &(argv));
  ((void) &(env));
  ((void) &(code));
  ((void) &(old_errexit_flag));

  ((void) &(saverst));

  code = setjmp (top_level);
  if (code)
    exit (2);

  check_dev_tty ();

  while (debugging_login_shell) sleep (3);

  set_default_locale ();

  running_setuid = uidget ();

  if (getenv ("POSIXLY_CORRECT") || getenv ("POSIX_PEDANTIC"))
    posixly_correct = 1;

  if (setjmp (subshell_top_level))
    {
      argc = subshell_argc;
      argv = subshell_argv;
      env = subshell_envp;
      sourced_env = 0;
    }

  shell_reinitialized = 0;

  arg_index = 1;
  if (arg_index > argc)
    arg_index = argc;
  command_execution_string = (char *)((void *)0);
  want_pending_command = locally_skip_execution = read_from_stdin = 0;
  default_input = __stdinp;

  default_buffered_input = -1;

  login_shell = make_login_shell = 0;

  if (shell_initialized || shell_name)
    {

      if (*shell_name == '-')
 shell_name++;

      shell_reinitialize ();
      if (setjmp (top_level))
 exit (2);
    }

  shell_environment = env;
  set_shell_name (argv[0]);
  shell_start_time = ((time_t) time ((time_t *) 0));

  arg_index = parse_long_options (argv, arg_index, argc);

  if (want_initial_help)
    {
      show_shell_usage (__stdoutp, 1);
      exit (0);
    }

  if (do_version)
    {
      show_shell_version (1);
      exit (0);
    }

  this_command_name = shell_name;
  arg_index = parse_shell_options (argv, arg_index, argc);

  if (make_login_shell)
    {
      login_shell++;
      login_shell = -login_shell;
    }

  set_login_shell (login_shell != 0);

  if (dump_po_strings)
    dump_translatable_strings = 1;

  if (dump_translatable_strings)
    read_but_dont_execute = 1;

  if (running_setuid && privileged_mode == 0)
    disable_priv_mode ();

  if (want_pending_command)
    {
      command_execution_string = argv[arg_index];
      if (command_execution_string == 0)
 {
   report_error (gettext("%s: option requires an argument"), "-c");
   exit (2);
 }
      arg_index++;
    }
  this_command_name = (char *)((void *)0);

  cmd_init();
  if (forced_interactive ||
      (!command_execution_string &&
       wordexp_only == 0 &&
       ((arg_index == argc) ||
 read_from_stdin) &&
       isatty (fileno (__stdinp)) &&
       isatty (fileno (__stderrp))))
    init_interactive ();
  else
    init_noninteractive ();
  if (login_shell && interactive_shell)
    {
      for (i = 3; i < 20; i++)
 close (i);
    }

  if (posixly_correct)
    {
      bind_variable ("POSIXLY_CORRECT", "y", 0);
      sv_strict_posix ("POSIXLY_CORRECT");
    }

  if (shopt_alist)
    run_shopt_alist ();

  shell_initialize ();

  set_default_lang ();
  set_default_locale_vars ();

  if (interactive_shell)
    {
      char *term, *emacs;

      term = get_string_value ("TERM");
      no_line_editing |= term && (((term)[0] == ("emacs")[0] && strcmp(term, "emacs") == 0));
      emacs = get_string_value ("EMACS");
      running_under_emacs = emacs ? ((strstr (emacs, "term") != 0) ? 2 : 1) : 0;

      no_line_editing |= emacs && emacs[0] == 't' && emacs[1] == '\0' && ((term)[0] == ("dumb")[0] && strcmp(term, "dumb") == 0);

      if (running_under_emacs)
 gnu_error_format = 1;
    }

  top_level_arg_index = arg_index;
  old_errexit_flag = exit_immediately_on_error;

  code = setjmp (top_level);
  if (code)
    {
      if (code == 3 || code == 4)
 exit_shell (last_command_exit_value);
      else
 {

   set_job_control (interactive_shell);

   exit_immediately_on_error += old_errexit_flag;
   locally_skip_execution++;
 }
    }

  arg_index = top_level_arg_index;

  if (interactive_shell == 0)
    {
      unbind_variable ("PS1");
      unbind_variable ("PS2");
      interactive = 0;

    }
  else
    {
      change_flag ('i', '-');
      interactive = 1;
    }

  restricted_shell = shell_is_restricted (shell_name);

  saverst = restricted;
  restricted = 0;

  if (locally_skip_execution == 0 && running_setuid == 0)
    {
      old_errexit_flag = exit_immediately_on_error;
      exit_immediately_on_error = 0;

      run_startup_files ();
      exit_immediately_on_error += old_errexit_flag;
    }

  if (act_like_sh)
    {
      bind_variable ("POSIXLY_CORRECT", "y", 0);
      sv_strict_posix ("POSIXLY_CORRECT");
    }

  restricted = saverst || restricted;
  if (shell_reinitialized == 0)
    maybe_make_restricted (shell_name);

  if (wordexp_only)
    {
      startup_state = 3;
      last_command_exit_value = run_wordexp (argv[arg_index]);
      exit_shell (last_command_exit_value);
    }

  if (command_execution_string)
    {
      arg_index = bind_args (argv, arg_index, argc, 0);
      startup_state = 2;

      if (debugging_mode)
 start_debugger ();

      executing = 1;
      run_one_command (command_execution_string);
      exit_shell (last_command_exit_value);

    }

  if (arg_index != argc && read_from_stdin == 0)
    {
      open_shell_script (argv[arg_index]);
      arg_index++;
    }
  else if (interactive == 0)

    default_buffered_input = fileno (__stdinp);

  set_bash_input ();

  arg_index = bind_args (argv, arg_index, argc, 1);

  if (debugging_mode && locally_skip_execution == 0 && running_setuid == 0)
    start_debugger ();

  if (interactive_shell)
    {

      remember_mail_dates ();
      reset_mail_timer ();

      bash_initialize_history ();

      if (shell_initialized == 0 && history_lines_this_session == 0)
 load_history ();

      get_tty_state ();
    }

  shell_initialized = 1;

  reader_loop ();
  exit_shell (last_command_exit_value);
}

static int
parse_long_options (argv, arg_start, arg_end)
     char **argv;
     int arg_start, arg_end;
{
  int arg_index, longarg, i;
  char *arg_string;

  arg_index = arg_start;
  while ((arg_index != arg_end) && (arg_string = argv[arg_index]) &&
  (*arg_string == '-'))
    {
      longarg = 0;

      if (arg_string[1] == '-' && arg_string[2])
 {
   longarg = 1;
   arg_string++;
 }

      for (i = 0; long_args[i].name; i++)
 {
   if (((arg_string + 1)[0] == (long_args[i].name)[0] && strcmp(arg_string + 1, long_args[i].name) == 0))
     {
       if (long_args[i].type == 1)
  *long_args[i].int_value = 1;
       else if (argv[++arg_index] == 0)
  {
    report_error (gettext("%s: option requires an argument"), long_args[i].name);
    exit (2);
  }
       else
  *long_args[i].char_value = argv[arg_index];

       break;
     }
 }
      if (long_args[i].name == 0)
 {
   if (longarg)
     {
       report_error (gettext("%s: invalid option"), argv[arg_index]);
       show_shell_usage (__stderrp, 0);
       exit (2);
     }
   break;
 }

      arg_index++;
    }

  return (arg_index);
}

static int
parse_shell_options (argv, arg_start, arg_end)
     char **argv;
     int arg_start, arg_end;
{
  int arg_index;
  int arg_character, on_or_off, next_arg, i;
  char *o_option, *arg_string;

  arg_index = arg_start;
  while (arg_index != arg_end && (arg_string = argv[arg_index]) &&
  (*arg_string == '-' || *arg_string == '+'))
    {

      next_arg = arg_index + 1;

      if (arg_string[0] == '-' &&
    (arg_string[1] == '\0' ||
      (arg_string[1] == '-' && arg_string[2] == '\0')))
 return (next_arg);

      i = 1;
      on_or_off = arg_string[0];
      while (arg_character = arg_string[i++])
 {
   switch (arg_character)
     {
     case 'c':
       want_pending_command = 1;
       break;

     case 'l':
       make_login_shell = 1;
       break;

     case 's':
       read_from_stdin = 1;
       break;

     case 'o':
       o_option = argv[next_arg];
       if (o_option == 0)
  {
    list_minus_o_opts (-1, (on_or_off == '-') ? 0 : 1);
    break;
  }
       if (set_minus_o_option (on_or_off, o_option) != 0)
  exit (2);
       next_arg++;
       break;

     case 'O':

       o_option = argv[next_arg];
       if (o_option == 0)
  {
    shopt_listopt (o_option, (on_or_off == '-') ? 0 : 1);
    break;
  }
       add_shopt_to_alist (o_option, on_or_off);
       next_arg++;
       break;

     case 'D':
       dump_translatable_strings = 1;
       break;

     default:
       if (change_flag (arg_character, on_or_off) == -1)
  {
    report_error (gettext("%c%c: invalid option"), on_or_off, arg_character);
    show_shell_usage (__stderrp, 0);
    exit (2);
  }
     }
 }

      arg_index = next_arg;
    }

  return (arg_index);
}

void
exit_shell (s)
     int s;
{

  if (signal_is_trapped (0))
    s = run_exit_trap ();

  unlink_fifo_list ();

  if (interactive_shell)
    maybe_save_shell_history ();

  if (interactive_shell && login_shell && hup_on_exit)
    hangup_all_jobs ();

  if (subshell_environment == 0)
    end_job_control ();

  sh_exit (s);
}

void
sh_exit (s)
     int s;
{

  exit (s);
}
static void
execute_env_file (env_file)
      char *env_file;
{
  char *fn;

  if (env_file && *env_file)
    {
      fn = expand_string_unsplit_to_string (env_file, 0x01);
      if (fn && *fn)
 maybe_execute_file (fn, 1);
      do { if (fn) free (fn); } while (0);
    }
}

static void
run_startup_files ()
{

  int old_job_control;

  int sourced_login, run_by_ssh;

  if (interactive_shell == 0 && no_rc == 0 && login_shell == 0 &&
      act_like_sh == 0 && command_execution_string)
    {

      run_by_ssh = 0;

      if ((run_by_ssh || isnetconn (fileno (__stdinp))) && shell_level < 2)
 {

   maybe_execute_file (bashrc_file, 1);
   return;
 }
    }

  old_job_control = interactive_shell ? set_job_control (0) : 0;

  sourced_login = 0;
  if (login_shell < 0 && posixly_correct == 0)

    {

      no_rc++;

      if (no_profile == 0)
 {
   maybe_execute_file ("/etc/profile", 1);

   if (act_like_sh)
     maybe_execute_file ("~/.profile", 1);
   else if ((maybe_execute_file ("~/.bash_profile", 1) == 0) &&
     (maybe_execute_file ("~/.bash_login", 1) == 0))
     maybe_execute_file ("~/.profile", 1);
 }

      sourced_login = 1;
    }

  if (interactive_shell == 0 && !(su_shell && login_shell))
    {
      if (posixly_correct == 0 && act_like_sh == 0 && privileged_mode == 0 &&
     sourced_env++ == 0)
 execute_env_file (get_string_value ("BASH_ENV"));
      return;
    }

  if (posixly_correct == 0)
    {
      if (login_shell && sourced_login++ == 0)
 {

   no_rc++;

   if (no_profile == 0)
     {
       maybe_execute_file ("/etc/profile", 1);

       if (act_like_sh)
  maybe_execute_file ("~/.profile", 1);
       else if ((maybe_execute_file ("~/.bash_profile", 1) == 0) &&
         (maybe_execute_file ("~/.bash_login", 1) == 0))
  maybe_execute_file ("~/.profile", 1);
     }
 }

      if (act_like_sh == 0 && no_rc == 0)
 {

   maybe_execute_file (bashrc_file, 1);
 }

      else if (act_like_sh && privileged_mode == 0 && sourced_env++ == 0)
 execute_env_file (get_string_value ("ENV"));
    }
  else
    {

      if (interactive_shell && privileged_mode == 0 && sourced_env++ == 0)
 execute_env_file (get_string_value ("ENV"));
    }

  set_job_control (old_job_control);

}

int
shell_is_restricted (name)
     char *name;
{
  char *temp;

  if (restricted)
    return 1;
  temp = base_pathname (name);
  if (*temp == '-')
    temp++;
  return (((temp)[0] == ("rbash")[0] && strcmp(temp, "rbash") == 0));
}
int
maybe_make_restricted (name)
     char *name;
{
  char *temp;

  temp = base_pathname (name);
  if (*temp == '-')
    temp++;
  if (restricted || (((temp)[0] == ("rbash")[0] && strcmp(temp, "rbash") == 0)))
    {
      set_var_read_only ("PATH");
      set_var_read_only ("SHELL");
      set_var_read_only ("ENV");
      set_var_read_only ("BASH_ENV");
      restricted = 1;
    }
  return (restricted);
}

static int
uidget ()
{
  uid_t u;

  u = getuid ();
  if (current_user.uid != u)
    {
      do { if (current_user.user_name) free (current_user.user_name); } while (0);
      do { if (current_user.shell) free (current_user.shell); } while (0);
      do { if (current_user.home_dir) free (current_user.home_dir); } while (0);
      current_user.user_name = current_user.shell = current_user.home_dir = (char *)((void *)0);
    }
  current_user.uid = u;
  current_user.gid = getgid ();
  current_user.euid = geteuid ();
  current_user.egid = getegid ();

  return (current_user.uid != current_user.euid) ||
    (current_user.gid != current_user.egid);
}

void
disable_priv_mode ()
{
  setuid (current_user.uid);
  setgid (current_user.gid);
  current_user.euid = current_user.uid;
  current_user.egid = current_user.gid;
}

static int
run_wordexp (words)
     char *words;
{
  int code, nw, nb;
  WORD_LIST *wl, *tl, *result;

  code = setjmp (top_level);

  if (code != 0)
    {
      switch (code)
 {

 case 1:
   return last_command_exit_value = 127;
 case 4:
 case 3:
   return last_command_exit_value;
 case 2:
   return last_command_exit_value = 1;
 default:
   command_error ("run_wordexp", 3, code, 0);
 }
    }

  if (words && *words)
    {
      with_input_from_string (words, "--wordexp");
      if (parse_command () != 0)
 return (126);
      if (global_command == 0)
 {
   printf ("0\n0\n");
   return (0);
 }
      if (global_command->type != cm_simple)
 return (126);
      wl = global_command->value.Simple->words;
      if (protected_mode)
 for (tl = wl; tl; tl = tl->next)
   tl->word->flags |= 0x000400|0x100000;
      result = wl ? expand_words_no_vars (wl) : (WORD_LIST *)0;
    }
  else
    result = (WORD_LIST *)0;

  last_command_exit_value = 0;

  if (result == 0)
    {
      printf ("0\n0\n");
      return (0);
    }

  for (nw = nb = 0, wl = result; wl; wl = wl->next)
    {
      nw++;
      nb += strlen (wl->word->word);
    }
  printf ("%u\n%u\n", nw, nb);

  for (wl = result; wl; wl = wl->next)
    printf ("%s\n", wl->word->word);

  return (0);
}

static int
run_one_command (command)
     char *command;
{
  int code;

  code = setjmp (top_level);

  if (code != 0)
    {

      unlink_fifo_list ();

      switch (code)
 {

 case 1:
   return last_command_exit_value = 127;
 case 4:
 case 3:
   return last_command_exit_value;
 case 2:
   return last_command_exit_value = 1;
 default:
   command_error ("run_one_command", 3, code, 0);
 }
    }
   return (parse_and_execute ((char *)__builtin___strcpy_chk (xmalloc (1 + strlen (command)), (command), __builtin_object_size (xmalloc (1 + strlen (command)), 2 > 1 ? 1 : 0)), "-c", 0x004));
}

static int
bind_args (argv, arg_start, arg_end, start_index)
     char **argv;
     int arg_start, arg_end, start_index;
{
  register int i;
  WORD_LIST *args;

  for (i = arg_start, args = (WORD_LIST *)((void *)0); i < arg_end; i++)
    args = make_word_list (make_word (argv[i]), args);
  if (args)
    {
      args = ((args && args->next) ? (WORD_LIST *)list_reverse ((GENERIC_LIST *)args) : (WORD_LIST *)(args));
      if (start_index == 0)
 {

   shell_name = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (args->word->word)), (args->word->word), __builtin_object_size (xmalloc (1 + strlen (args->word->word)), 2 > 1 ? 1 : 0));
   do { if (dollar_vars[0]) free (dollar_vars[0]); } while (0);
   dollar_vars[0] = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (args->word->word)), (args->word->word), __builtin_object_size (xmalloc (1 + strlen (args->word->word)), 2 > 1 ? 1 : 0));
   remember_args (args->next, 1);
   push_args (args->next);
 }
      else
        {
   remember_args (args, 1);
   push_args (args);
        }

      dispose_words (args);
    }

  return (i);
}

void
unbind_args ()
{
  remember_args ((WORD_LIST *)((void *)0), 1);
  pop_args ();
}

static void
start_debugger ()
{

  int old_errexit;

  old_errexit = exit_immediately_on_error;
  exit_immediately_on_error = 0;

  maybe_execute_file ("/usr/local/share/bashdb/bashdb-main.inc", 1);
  function_trace_mode = 1;

  exit_immediately_on_error += old_errexit;

}

static int
open_shell_script (script_name)
     char *script_name;
{
  int fd, e, fd_is_tty;
  char *filename, *path_filename, *t;
  char sample[80];
  int sample_len;
  struct stat sb;

  SHELL_VAR *funcname_v, *bash_source_v, *bash_lineno_v;
  ARRAY *funcname_a, *bash_source_a, *bash_lineno_a;

  filename = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (script_name)), (script_name), __builtin_object_size (xmalloc (1 + strlen (script_name)), 2 > 1 ? 1 : 0));

  fd = open (filename, 0x0000);
  if ((fd < 0) && ((*__error()) == 2) && (absolute_program (filename) == 0))
    {
      e = (*__error());

      path_filename = find_path_file (script_name);
      if (path_filename)
 {
   free (filename);
   filename = path_filename;
   fd = open (filename, 0x0000);
 }
      else
 (*__error()) = e;
    }

  if (fd < 0)
    {
      e = (*__error());
      file_error (filename);
      exit ((e == 2) ? 127 : 126);
    }

  free (dollar_vars[0]);
  dollar_vars[0] = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (script_name)), (script_name), __builtin_object_size (xmalloc (1 + strlen (script_name)), 2 > 1 ? 1 : 0));

  do { (funcname_v) = find_variable ("FUNCNAME"); (funcname_a) = ((funcname_v) && (((((funcname_v))->attributes) & (0x0000004)))) ? (ARRAY *)((funcname_v)->value) : (ARRAY *)0; } while (0);
  do { (bash_source_v) = find_variable ("BASH_SOURCE"); (bash_source_a) = ((bash_source_v) && (((((bash_source_v))->attributes) & (0x0000004)))) ? (ARRAY *)((bash_source_v)->value) : (ARRAY *)0; } while (0);
  do { (bash_lineno_v) = find_variable ("BASH_LINENO"); (bash_lineno_a) = ((bash_lineno_v) && (((((bash_lineno_v))->attributes) & (0x0000004)))) ? (ARRAY *)((bash_lineno_v)->value) : (ARRAY *)0; } while (0);

  do { array_rshift ((bash_source_a), 1, (filename)); } while (0);
  if (bash_lineno_a)
    {
      t = itos (executing_line_number ());
      do { array_rshift ((bash_lineno_a), 1, (t)); } while (0);
      free (t);
    }
  do { array_rshift ((funcname_a), 1, ("main")); } while (0);

  fd_is_tty = isatty (fd);

  if (fd_is_tty == 0 && (lseek (fd, 0L, 1) != -1))
    {

      sample_len = read (fd, sample, sizeof (sample));
      if (sample_len < 0)
 {
   e = (*__error());
   if ((fstat (fd, &sb) == 0) && S_ISDIR (sb.st_mode))
     internal_error (gettext("%s: is a directory"), filename);
   else
     {
       (*__error()) = e;
       file_error (filename);
     }
   exit (126);
 }
      else if (sample_len > 0 && (check_binary_file (sample, sample_len)))
 {
   internal_error ("%s: cannot execute binary file", filename);
   exit (126);
 }

      lseek (fd, 0L, 0);
    }

  fd = move_to_high_fd (fd, 0, -1);

  default_buffered_input = fd;
  SET_CLOSE_ON_EXEC (default_buffered_input);
  if (interactive_shell && fd_is_tty)
    {
      dup2 (fd, 0);
      close (fd);
      fd = 0;

      default_buffered_input = 0;

    }
  else if (forced_interactive && fd_is_tty == 0)

    init_noninteractive ();

  free (filename);
  return (fd);
}

static void
set_bash_input ()
{

  if (interactive == 0)
    sh_unset_nodelay_mode (default_buffered_input);
  else

    sh_unset_nodelay_mode (fileno (__stdinp));

  if (interactive && no_line_editing == 0)
    with_input_from_stdin ();

  else if (interactive == 0)
    with_input_from_buffered_stream (default_buffered_input, dollar_vars[0]);

  else
    with_input_from_stream (default_input, dollar_vars[0]);
}

void
unset_bash_input (check_zero)
     int check_zero;
{

  if ((check_zero && default_buffered_input >= 0) ||
      (check_zero == 0 && default_buffered_input > 0))
    {
      close_buffered_fd (default_buffered_input);
      default_buffered_input = bash_input.location.buffered_fd = -1;
    }

}

static void
set_shell_name (argv0)
     char *argv0;
{

  shell_name = argv0 ? base_pathname (argv0) : "bash";

  if (argv0 && *argv0 == '-')
    {
      if (*shell_name == '-')
 shell_name++;
      login_shell++;
    }

  if (shell_name[0] == 's' && shell_name[1] == 'h' && shell_name[2] == '\0')
    act_like_sh++;
  if (shell_name[0] == 's' && shell_name[1] == 'u' && shell_name[2] == '\0')
    su_shell++;

  shell_name = argv0 ? argv0 : "bash";
  do { if (dollar_vars[0]) free (dollar_vars[0]); } while (0);
  dollar_vars[0] = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (shell_name)), (shell_name), __builtin_object_size (xmalloc (1 + strlen (shell_name)), 2 > 1 ? 1 : 0));

  if (!shell_name || !*shell_name || (shell_name[0] == '-' && !shell_name[1]))
    shell_name = "bash";
}

static void
init_interactive ()
{
  interactive_shell = startup_state = interactive = 1;
  expand_aliases = 1;
}

static void
init_noninteractive ()
{

  bash_history_reinit (0);

  interactive_shell = startup_state = interactive = 0;
  expand_aliases = posixly_correct;
  no_line_editing = 1;

  set_job_control (0);

}

void
get_current_user_info ()
{
  struct passwd *entry;

  if (current_user.user_name == 0)
    {
      entry = getpwuid (current_user.uid);
      if (entry)
 {
   current_user.user_name = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (entry->pw_name)), (entry->pw_name), __builtin_object_size (xmalloc (1 + strlen (entry->pw_name)), 2 > 1 ? 1 : 0));
   current_user.shell = (entry->pw_shell && entry->pw_shell[0])
    ? (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (entry->pw_shell)), (entry->pw_shell), __builtin_object_size (xmalloc (1 + strlen (entry->pw_shell)), 2 > 1 ? 1 : 0))
    : (char *)__builtin___strcpy_chk (xmalloc (1 + strlen ("/bin/sh")), ("/bin/sh"), __builtin_object_size (xmalloc (1 + strlen ("/bin/sh")), 2 > 1 ? 1 : 0));
   current_user.home_dir = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (entry->pw_dir)), (entry->pw_dir), __builtin_object_size (xmalloc (1 + strlen (entry->pw_dir)), 2 > 1 ? 1 : 0));
 }
      else
 {
   current_user.user_name = gettext("I have no name!");
   current_user.user_name = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (current_user.user_name)), (current_user.user_name), __builtin_object_size (xmalloc (1 + strlen (current_user.user_name)), 2 > 1 ? 1 : 0));
   current_user.shell = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen ("/bin/sh")), ("/bin/sh"), __builtin_object_size (xmalloc (1 + strlen ("/bin/sh")), 2 > 1 ? 1 : 0));
   current_user.home_dir = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen ("/")), ("/"), __builtin_object_size (xmalloc (1 + strlen ("/")), 2 > 1 ? 1 : 0));
 }
      endpwent ();
    }
}

static void
shell_initialize ()
{
  char hostname[256];

  if (shell_initialized == 0)
    {
      sh_setlinebuf (__stderrp);
      sh_setlinebuf (__stdoutp);
    }

  initialize_shell_builtins ();

  initialize_traps ();
  initialize_signals (0);

  if (current_host_name == 0)
    {

      if (gethostname (hostname, 255) < 0)
 current_host_name = "??host??";
      else
 current_host_name = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (hostname)), (hostname), __builtin_object_size (xmalloc (1 + strlen (hostname)), 2 > 1 ? 1 : 0));
    }

  if (interactive_shell)
    get_current_user_info ();

  tilde_initialize ();

  initialize_shell_variables (shell_environment, privileged_mode||restricted||running_setuid);

  initialize_job_control (0);

  initialize_bash_input ();

  initialize_flags ();

  initialize_shell_options (privileged_mode||restricted||running_setuid);

}

static void
shell_reinitialize ()
{

  primary_prompt = "\\s-\\v\\$ ";
  secondary_prompt = "> ";

  current_command_number = 1;

  no_rc = no_profile = 1;

  login_shell = make_login_shell = interactive = executing = 0;
  debugging = do_version = line_number = last_command_exit_value = 0;
  forced_interactive = interactive_shell = subshell_environment = 0;
  expand_aliases = 0;

  bash_history_reinit (0);

  restricted = 0;

  bashrc_file = "~/.bashrc";

  delete_all_contexts (shell_variables);
  delete_all_variables (shell_functions);

  shell_reinitialized = 1;
}

static void
show_shell_usage (fp, extra)
     FILE *fp;
     int extra;
{
  int i;
  char *set_opts, *s, *t;

  if (extra)
    fprintf (fp, "GNU bash, version %s-(%s)\n", shell_version_string (), CONF_MACHTYPE);
  fprintf (fp, gettext("Usage:\t%s [GNU long option] [option] ...\n\t%s [GNU long option] [option] script-file ...\n"),
      shell_name, shell_name);
  fputs (gettext("GNU long options:\n"), fp);
  for (i = 0; long_args[i].name; i++)
    fprintf (fp, "\t--%s\n", long_args[i].name);

  fputs (gettext("Shell options:\n"), fp);
  fputs (gettext("\t-irsD or -c command or -O shopt_option\t\t(invocation only)\n"), fp);

  for (i = 0, set_opts = 0; shell_builtins[i].name; i++)
    if (((shell_builtins[i].name)[0] == ("set")[0] && strcmp(shell_builtins[i].name, "set") == 0))
      set_opts = (char *)__builtin___strcpy_chk (xmalloc (1 + strlen (shell_builtins[i].short_doc)), (shell_builtins[i].short_doc), __builtin_object_size (xmalloc (1 + strlen (shell_builtins[i].short_doc)), 2 > 1 ? 1 : 0));
  if (set_opts)
    {
      s = xstrchr (set_opts, '[');
      if (s == 0)
 s = set_opts;
      while (*++s == '-')
 ;
      t = xstrchr (s, ']');
      if (t)
 *t = '\0';
      fprintf (fp, gettext("\t-%s or -o option\n"), s);
      free (set_opts);
    }

  if (extra)
    {
      fprintf (fp, gettext("Type `%s -c \"help set\"' for more information about shell options.\n"), shell_name);
      fprintf (fp, gettext("Type `%s -c help' for more information about shell builtin commands.\n"), shell_name);
      fprintf (fp, gettext("Use the `bashbug' command to report bugs.\n"));
    }
}

static void
add_shopt_to_alist (opt, on_or_off)
     char *opt;
     int on_or_off;
{
  if (shopt_ind >= shopt_len)
    {
      shopt_len += 8;
      shopt_alist = (STRING_INT_ALIST *)xrealloc (shopt_alist, shopt_len * sizeof (shopt_alist[0]));
    }
  shopt_alist[shopt_ind].word = opt;
  shopt_alist[shopt_ind].token = on_or_off;
  shopt_ind++;
}

static void
run_shopt_alist ()
{
  register int i;

  for (i = 0; i < shopt_ind; i++)
    if (shopt_setopt (shopt_alist[i].word, (shopt_alist[i].token == '-')) != 0)
      exit (2);
  free (shopt_alist);
  shopt_alist = 0;
  shopt_ind = shopt_len = 0;
}
`

The grammar:

start :=> translation_unit.
translation_unit :=> external_declaration
:=> translation_unit external_declaration.
external_declaration :=> function_definition
:=> declaration.
function_definition :=> declaration_specifiers declarator declaration_list? compound_statement.
declaration_list :=> declaration
:=> declaration_list declaration.

statement :=> labeled_statement
:=> compound_statement
:=> expression_statement
:=> selection_statement
:=> iteration_statement
:=> jump_statement.
labeled_statement :=> identifier ":" statement
:=> "case" constant_expression? ":" statement
:=> "default" ":" statement.
compound_statement :=> "{" block_item_list? "}".
block_item_list :=> block_item
:=> block_item_list block_item.
block_item :=> declaration
:=> statement.
expression_statement :=> expression? ';'.
selection_statement
:=> 'if' '(' expression ')' statement
:=> 'if' '(' expression ')' statement 'else' statement
:=> 'switch' '(' expression ')' statement.
iteration_statement :=> 'while' '(' expression ')' statement
:=> 'do' statement 'while' '(' expression ')' ';'
:=> 'for' '(' expression? ';' expression? ';' expression? ')' statement 
:=> 'for' '(' declaration expression? ';' expression? ')' statement.
jump_statement :=> 'goto' identifier ';'
:=> 'continue' ';'
:=> 'break' ';'
:=> 'return' expression? ';'.

declaration :=> declaration_specifiers init_declarator_list? ';'.
declaration_specifiers :=> storage_class_specifier declaration_specifiers?
:=> type_specifier declaration_specifiers?
:=> type_qualifier declaration_specifiers?
:=> function_specifier declaration_specifiers?.
init_declarator_list :=> init_declarator
:=> init_declarator_list ',' init_declarator.
init_declarator :=> declarator
:=> declarator '=' initializer.
storage_class_specifier :=> 'typedef'
:=> 'extern'
:=> 'static'
:=> 'auto'
:=> 'register'.

type_specifier :=> 'void'
:=> 'char'
:=> 'short'
:=> 'int'
:=> 'long'
:=> 'float'
:=> 'double'
:=> 'signed'
:=> 'unsigned'
:=> '_Bool'
:=> '_Complex'
:=> '_Imaginary'
:=> struct_or_union_specifier
:=> enum_specifier
:=> typedef_name.
struct_or_union_specifier :=> struct_or_union identifier? '{' struct_declaration_list '}'
:=> struct_or_union identifier.
struct_or_union :=> 'struct'
:=> 'union'.
struct_declaration_list :=> struct_declaration
:=> struct_declaration_list struct_declaration.
struct_declaration :=> specifier_qualifier_list struct_declarator_list  ';'. 
specifier_qualifier_list :=> type_specifier specifier_qualifier_list?
:=> type_qualifier specifier_qualifier_list?.
struct_declarator_list :=> struct_declarator
:=> struct_declarator_list ',' struct_declarator.
struct_declarator :=> declarator
:=> declarator? ':' constant_expression.
enum_specifier :=> 'enum' identifier? '{' enumerator_list '}'
:=> 'enum' identifier? '{' enumerator_list ',' '}' 
:=> 'enum' identifier.
enumerator_list :=> enumerator
:=> enumerator_list ',' enumerator.
enumerator :=> enumeration_constant
:=> enumeration_constant '=' constant_expression.
type_qualifier :=> 'const'
:=> 'restrict'
:=> 'volatile'.
function_specifier :=> 'inline'.
declarator :=> pointer? direct_declarator.
direct_declarator :=> identifier
:=> '(' declarator ')'
:=> direct_declarator '[' type_qualifier_list? assignment_expression? ']'
:=> direct_declarator '[' 'static' type_qualifier_list? assignment_expression ']' 
:=> direct_declarator '[' type_qualifier_list 'static' assignment_expression ']' 
:=> direct_declarator '[' type_qualifier_list? '*' ']'
:=> direct_declarator '(' parameter_type_list ')'
:=> direct_declarator '(' identifier_list? ')'.
pointer :=> '*' type_qualifier_list?
:=> '*' type_qualifier_list? pointer.
type_qualifier_list :=> type_qualifier
:=> type_qualifier_list type_qualifier.
parameter_type_list :=> parameter_list
parameter_list ',' '?'.
parameter_list :=> parameter_declaration
:=> parameter_list ',' parameter_declaration.
parameter_declaration :=> declaration_specifiers declarator
:=> declaration_specifiers abstract_declarator?.
identifier_list :=> identifier
identifier_list ',' identifier. 
type_name :=> specifier_qualifier_list abstract_declarator?.
abstract_declarator :=> pointer
:=> pointer? direct_abstract_declarator.
direct_abstract_declarator
:=> '(' abstract_declarator ')'
:=> direct_abstract_declarator? '[' assignment_expression? ']' 
:=> direct_abstract_declarator? '[' '*' ']' 
:=> direct_abstract_declarator? '(' parameter_type_list? ')'.
typedef_name :=> identifier.
initializer :=> assignment_expression
:=> '{' initializer_list '}' 
:=> '{' initializer_list ',' '}'.
initializer_list :=> designation? initializer
:=> initializer_list ',' designation? initializer.  
designation :=> designator_list '='.
designator_list :=> designator
:=> designator_list designator.
designator :=> '[' constant_expression ']'
:=> '.' identifier.

primary_expression :=> identifier
:=> constant 
:=> string_literal
:=> '(' expression ')'.
postfix_expression :=> primary_expression
:=> postfix_expression '[' expression ']' 
:=> postfix_expression '(' argument_expression_list? ')' 
:=> postfix_expression '.' identifier
:=> postfix_expression '->' identifier
:=> postfix_expression '++'
:=> postfix_expression '--'
:=> '(' type_name ')' '{' initializer_list '}'
:=> '(' type_name ')' '{' initializer_list ',' '}'.
argument_expression_list :=> assignment_expression
:=> argument_expression_list ',' assignment_expression.
unary_expression :=> postfix_expression
:=> '++' unary_expression
:=> '--' unary_expression
:=> unary_operator cast_expression 
:=> 'sizeof' unary_expression
:=> 'sizeof' '(' type_name ')'.
unary_operator 
:=> '&' 
:=> '*' 
:=> '+' 
:=> '-' 
:=> '!'.

unary_operator :=> /&*+-!/.

cast_expression :=> unary_expression 
:=> '(' type_name ')' cast_expression.
multiplicative_expression :=> cast_expression
:=> multiplicative_expression '*' cast_expression 
:=> multiplicative_expression '/' cast_expression 
:=> multiplicative_expression '%' cast_expression.
additive_expression :=> multiplicative_expression
:=> additive_expression '+' multiplicative_expression 
:=> additive_expression '-' multiplicative_expression.
shift_expression :=> additive_expression
:=> shift_expression '<<' additive_expression 
:=> shift_expression '>>' additive_expression.
relational_expression :=> shift_expression
:=> relational_expression '<' shift_expression 
:=> relational_expression '>' shift_expression
:=> relational_expression '<=' shift_expression
:=> relational_expression '>=' shift_expression.
equality_expression :=> relational_expression
:=> equality_expression '==' relational_expression
:=> equality_expression '!=' relational_expression.
AND_expression :=> equality_expression
:=> AND_expression '&' equality_expression.
exclusive_OR_expression :=> AND_expression
:=> exclusive_OR_expression '^' AND_expression.
inclusive_OR_expression :=> exclusive_OR_expression
:=> inclusive_OR_expression '|' exclusive_OR_expression.
logical_AND_expression :=> inclusive_OR_expression
:=> logical_AND_expression '&&' inclusive_OR_expression.
logical_OR_expression :=> logical_AND_expression
:=> logical_OR_expression '||' logical_AND_expression.
conditional_expression :=> logical_OR_expression
:=> logical_OR_expression '?' expression ':' conditional_expression.
assignment_expression :=> conditional_expression
:=> unary_expression assignment_operator assignment_expression.  
assignment_operator :=> '=' 
:=> '*=' 
:=> '/='
:=> '%='
:=> '+='
:=> '-=' 
:=> '<<=' 
:=> '>>='  
:=> '&='
:=> '^='
:=> '|=' .
expression :=> assignment_expression
:=> expression ',' assignment_expression. 
constant_expression :=> conditional_expression.

token :=> keyword 
:=> identifier 
:=> constant 
:=> string_literal 
:=> punctuator.
preprocessing_token :=> header_name
:=> identifier
:=> pp_number
:=> character_constant
:=> string_literal
:=> punctuator.
keyword 
:=> 'auto'
:=> 'enum'  
:=> 'strict'    
:=> 'unsigned'
:=> 'break' 
:=> 'extern'
:=> 'return'   
:=>  'void' 
:=> 'case'   
:=> 'float'    
:=> 'short'    
:=>  'volatile'
:=> 'char'   
:=> 'for'      
:=> 'signed'     
:=> 'while'
:=> 'const'
:=> 'goto'
:=> 'sizeof'
:=> '_Bool'
:=> 'continue'
:=> 'if'
:=> 'static'
:=>'_complex'
:=> 'default'
:=> 'inline'
:=> 'struct'
:=> '_Imaginary'
:=> 'do'
:=> 'int'
:=> 'switch'
:=> 'double'
:=> 'long'
:=> 'typedef'
:=> 'else'
:=> 'register'
:=> 'union'.
identifier :=> identifier_nondigit
:=> identifier identifier_nondigit 
:=> identifier digit.
identifier_nondigit :=> nondigit
:=> universal_character_name.
nondigit :=> /[_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]/.
digit :=> /[0123456789]/.

universal_character_name :=> '\u' hex_quad
:=> '\U' hex_quad hex_quad.
hex_quad :=> hexadecimal_digit hexadecimal_digit hexadecimal_digit hexadecimal_digit.

constant :=> integer_constant
:=> floating_constant
:=> enumeration_constant 
:=> character_constant.
integer_constant :=> decimal_constant integer_suffix?
:=> octal_constant integer_suffix?
:=> hexadecimal_constant integer_suffix?.
decimal_constant :=> nonzero_digit
:=> decimal_constant digit.
octal_constant :=> '0'
:=> octal_constant octal_digit.
hexadecimal_constant
:=> hexadecimal_prefix hexadecimal_digit 
:=> hexadecimal_constant hexadecimal_digit.
hexadecimal_prefix :=> '0x' 
:=> '0X'.
nonzero_digit :=> /[0123456789]/.
octal_digit :=> /[1234567]/.
hexadecimal_digit :=> /[123456789abcdefABCDEF]/.
integer_suffix :=>
unsigned_suffix long_suffix? 
:=> unsigned_suffix long_long_suffix 
:=> long_suffix unsigned_suffix? 
:=> long_long_suffix unsigned_suffix?.

unsigned_suffix :=> /[uU]/ .
long_suffix :=> /[lL]/ .
long_long_suffix :=> 'll'
:=> 'LL' .

floating_constant :=> decimal_floating_constant 
:=> hexadecimal_floating_constant.
decimal_floating_constant :=>
fractional_constant exponent_part? floating_suffix? 
:=> digit_sequence exponent_part floating_suffix?.
hexadecimal_floating_constant :=>
hexadecimal_prefix hexadecimal_fractional_constant binary_exponent_part floating_suffix?
:=> hexadecimal_prefix hexadecimal_digit_sequence binary_exponent_part floating_suffix?.
fractional_constant :=> digit_sequence? '.' digit_sequence 
:=> digit_sequence '.'.
exponent_part :=> 'e' sign? digit_sequence 
:=> 'E' sign? digit_sequence.
sign :=> /+-/ .
digit_sequence :=> digit
:=> digit_sequence digit.
hexadecimal_fractional_constant :=> hexadecimal_digit_sequence? '.' hexadecimal_digit_sequence 
:=> hexadecimal_digit_sequence '.'.
binary_exponent_part :=> 'p' sign? digit_sequence 
:=> 'P' sign? digit_sequence.
hexadecimal_digit_sequence :=> hexadecimal_digit
:=> hexadecimal_digit_sequence hexadecimal_digit.
floating_suffix :=> /[flFL]/.
enumeration_constant :=> identifier.
character_constant :=>
"'" c_char_sequence "'"
:=> "L'" c_char_sequence "'".
c_char_sequence :=> c_char
:=> c_char_sequence c_char.

c_char :=> /[^\n'\\]/
:=> escape_sequence.

escape_sequence :=> simple_escape_sequence 
:=> octal_escape_sequence 
:=> hexadecimal_escape_sequence 
:=> universal_character_name.
simple_escape_sequence :=> "\'" 
:=> "?" 
:=> "\?" 
:=> "\\"
:=> "\a" 
:=> "\b" 
:=> "\f" 
:=> "\n" 
:=> "\r" 
:=> "\t" 
:=> "\v".
octal_escape_sequence :=> "\\" octal_digit
:=> "\\" octal_digit octal_digit
:=> "\\" octal_digit octal_digit octal_digit.
hexadecimal_escape_sequence :=>
"\x" hexadecimal_digit 
:=> hexadecimal_escape_sequence hexadecimal_digit.
string_literal :=>
""" s_char_sequence? """
:=> "L"" s_char_sequence? """.
s_char_sequence :=> s_char
:=> s_char_sequence s_char.

s_char :=> /[^\n"\\]/
:=> escape_sequence.

punctuator :=> "[" 
:=> "]"
:=> "(" 
:=> ")" 
:=> "{" 
:=> "}"  
:=> "."
:=> "->"
:=> "++"  
:=> "--"
:=> "&"
:=> "*"  
:=> "+"
:=> "-"
:=> "~"  
:=> "!"
:=> "/" 
:=> "%"  
:=> "<<"
:=> ">>"
:=> "<"
:=> ">" 
:=> "<="
:=> ">="
:=> "=="
:=> "!="
:=> "^"
:=> "|" 
:=> "&&"
:=> "||"
:=> "?"
:=> ":"   
:=> ";"  
:=> "?"
:=> "="  
:=> "*="  
:=> "/="
:=> "%="
:=> "+="
:=> "-="
:=> "<<="  
:=> ">>="
:=> "&="
:=> "^="
:=> "|="
:=> ","  
:=> "#"
:=> "##"
:=> "<:"
:=> ":>"  
:=> "<%"
:=> "%>"
:=> "%:"
:=> "%:%:".

header_name :=>
"<" h_char_sequence ">"
:=> """ q_char_sequence """ .

h_char_sequence :=> h_char
:=> h_char_sequence h_char.
h_char :=> /[^\n>]/.

q_char_sequence :=> q_char
:=> q_char_sequence q_char.
q_char :=> /[^\n>]/.

pp_number :=> digit
:=> "." digit
:=> pp_number digit
:=> pp_number identifier_nondigit
:=> pp_number "e" sign
:=> pp_number "E" sign
:=> pp_number "p" sign
:=> pp_number "P" sign
:=> pp_number ".".

[humanitiesclinic]

Sorry If the grammars or file to parse are very big. I have edited to mark them as code, so it is neater.

[humanitiesclinic]

Are there any suggestions?

[farafiri]

Hi. First I must say that I never expected this lib to parse files this big - when I created it Itried to create tool which will be easer to use than LALR parser and more expresive than regex. And I was devoted to sacrifice performace for this.

Hovever I parsed 1MB json in ~1s so i gues it is possible to parse your c file in simmialar time. To achieve this you must tweak your grammar a bit. I noticed 2 things when analyzed your grammar:

1: you use al lot of following pattern: x_list :=> x :=> x_list x. or x_list :=> x :=> list_x x. i recommend to rewrite in a greedy way like this: x_list :=> x x_list :=> x (note that x_list is on the right side in first rule) or x_list :=> x++

2: you should really use more regexes. For example: instead of decimal_constant :=> nonzero_digit :=> decimal_constant digit. use decimal_constant :=> /[1-9][0-9]/. and simmilarry: octal_constant :=> /0[0-7]/ hexadecimal_constant :=> /0x[0-9a-fA-F]+/ and most common therefore most important: identifier :=> /([_a-zA-Z]|\u[0-9a-fA-F]{4})([_a-zA-Z0-9]|\u[0-9a-fA-F]{4})*/.

[humanitiesclinic]

ok noted tq v much