global.c

/gondow/xci/src/xci_def.h

extern void * __builtin_next_arg () ;
extern void * __builtin_alloca () ;
extern void * __builtin_apply_args () ;
extern void * __builtin_apply () ;
extern void __builtin_memcpy () ;
typedef void * __builtin_va_list ;
extern void __builtin_stdarg_start () ;
extern void __builtin_va_end () ;
extern int yylex () ;

global.c

typedef int ptrdiff_t ;
typedef unsigned int size_t ;
typedef short unsigned int wchar_t ;
typedef unsigned int wint_t ;
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 long time_t ;
typedef long daddr_t ;
typedef char * caddr_t ;
typedef unsigned long ino_t ;
typedef unsigned long vm_offset_t ;
typedef unsigned long vm_size_t ;
typedef char int8_t ;
typedef unsigned char u_int8_t ;
typedef short int16_t ;
typedef unsigned short u_int16_t ;
typedef int int32_t ;
typedef unsigned int u_int32_t ;
typedef long long int64_t ;
typedef unsigned long long u_int64_t ;
typedef int32_t register_t ;
typedef short dev_t ;
typedef long off_t ;
typedef unsigned short uid_t ;
typedef unsigned short gid_t ;
typedef int pid_t ;
typedef long key_t ;
typedef long ssize_t ;
typedef char * addr_t ;
typedef int mode_t ;
typedef unsigned short nlink_t ;
typedef long fd_mask ;
typedef struct _types_fd_set {
fd_mask fds_bits [ ( ( ( 64 ) + ( ( ( sizeof ( fd_mask ) * 8 ) ) - 1 ) ) / ( ( sizeof ( fd_mask ) * 8 ) ) ) ] ;
} _types_fd_set ;
typedef int __int32_t ;
typedef unsigned int __uint32_t ;
typedef unsigned long clock_t ;
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 ;
} ;
clock_t clock ( void ) ;
double difftime ( time_t _time2 , time_t _time1 ) ;
time_t mktime ( struct tm * _timeptr ) ;
time_t time ( time_t * _timer ) ;
char * asctime ( const struct tm * _tblock ) ;
char * ctime ( const time_t * _time ) ;
struct tm * gmtime ( const time_t * _timer ) ;
struct tm * localtime ( const time_t * _timer ) ;
size_t strftime ( char * _s , size_t _maxsize , const char * _fmt , const struct tm * _t ) ;
char * asctime_r ( const struct tm * , char * ) ;
char * ctime_r ( const time_t * , char * ) ;
struct tm * gmtime_r ( const time_t * , struct tm * ) ;
struct tm * localtime_r ( const time_t * , struct tm * ) ;
extern time_t * __imp__timezone ;
extern int * __imp__daylight ;
extern char * ( ( * __imp__tzname ) [ 2 ] ) ;
char * timezone ( void ) ;
void tzset ( void ) ;
struct stat {
dev_t st_dev ;
ino_t st_ino ;
mode_t st_mode ;
nlink_t st_nlink ;
uid_t st_uid ;
gid_t st_gid ;
dev_t st_rdev ;
off_t st_size ;
time_t st_atime ;
long st_spare1 ;
time_t st_mtime ;
long st_spare2 ;
time_t st_ctime ;
long st_spare3 ;
long st_blksize ;
long st_blocks ;
long st_spare4 [ 2 ] ;
} ;
int chmod ( const char * __path , mode_t __mode ) ;
int fchmod ( int __fd , mode_t __mode ) ;
int fstat ( int __fd , struct stat * __sbuf ) ;
int mkdir ( const char * _path , mode_t __mode ) ;
int mkfifo ( char * __path , mode_t __mode ) ;
int stat ( const char * __path , struct stat * __sbuf ) ;
mode_t umask ( mode_t __mask ) ;
int _fstat ( int __fd , struct stat * __sbuf ) ;
int _stat ( const char * __path , struct stat * __sbuf ) ;
int lstat ( const char * __path , struct stat * __buf ) ;
int isalnum ( int __c ) ;
int isalpha ( int __c ) ;
int iscntrl ( int __c ) ;
int isdigit ( int __c ) ;
int isgraph ( int __c ) ;
int islower ( int __c ) ;
int isprint ( int __c ) ;
int ispunct ( int __c ) ;
int isspace ( int __c ) ;
int isupper ( int __c ) ;
int isxdigit ( int __c ) ;
int tolower ( int __c ) ;
int toupper ( int __c ) ;
int isascii ( int __c ) ;
int toascii ( int __c ) ;
int _tolower ( int __c ) ;
int _toupper ( int __c ) ;
extern const char _ctype_ [ ] ;
typedef void * __gnuc_va_list ;
struct _glue {
struct _glue * _next ;
int _niobs ;
struct __sFILE * _iobs ;
} ;
struct _Bigint {
struct _Bigint * _next ;
int _k _maxwds _sign _wds ;
unsigned long _x [ 1 ] ;
} ;
struct _atexit {
struct _atexit * _next ;
int _ind ;
void ( * _fns [ 32 ] ) ( void ) ;
} ;
struct __sbuf {
unsigned char * _base ;
int _size ;
} ;
typedef long _fpos_t ;
struct __sFILE {
unsigned char * _p ;
int _r ;
int _w ;
short _flags ;
short _file ;
struct __sbuf _bf ;
int _lbfsize ;
void * _cookie ;
int ( * _read ) ( void * _cookie , char * _buf , int _n ) ;
int ( * _write ) ( void * _cookie , const char * _buf , int _n ) ;
_fpos_t ( * _seek ) ( void * _cookie , _fpos_t _offset , int _whence ) ;
int ( * _close ) ( void * _cookie ) ;
struct __sbuf _ub ;
unsigned char * _up ;
int _ur ;
unsigned char _ubuf [ 3 ] ;
unsigned char _nbuf [ 1 ] ;
struct __sbuf _lb ;
int _blksize ;
int _offset ;
struct _reent * _data ;
} ;
struct _reent {
int _errno ;
struct __sFILE * _stdin * _stdout * _stderr ;
int _inc ;
char _emergency [ 25 ] ;
int _current_category ;
const char * _current_locale ;
int __sdidinit ;
void ( * __cleanup ) ( struct _reent * ) ;
struct _Bigint * _result ;
int _result_k ;
struct _Bigint * _p5s ;
struct _Bigint * * _freelist ;
int _cvtlen ;
char * _cvtbuf ;
unsigned char * _nextf [ 30 ] ;
unsigned int _nmalloc [ 30 ] ;
struct _atexit * _atexit ;
struct _atexit _atexit0 ;
void ( * * ( _sig_func ) ) ( void ) ;
struct _glue __sglue ;
struct __sFILE __sf [ 3 ] ;
} ;
extern struct _reent * _impure_ptr ;
void _reclaim_reent ( struct _reent * ) ;
typedef _fpos_t fpos_t ;
typedef struct __sFILE FILE ;
int remove ( const char * ) ;
int rename ( const char * , const char * ) ;
char * tempnam ( const char * , const char * ) ;
FILE * tmpfile ( void ) ;
char * tmpnam ( char * ) ;
int fclose ( FILE * ) ;
int fflush ( FILE * ) ;
FILE * freopen ( const char * , const char * , FILE * ) ;
void setbuf ( FILE * , char * ) ;
int setvbuf ( FILE * , char * , int , size_t ) ;
int fprintf ( FILE * , const char * ) ;
int fscanf ( FILE * , const char * ) ;
int printf ( const char * ) ;
int scanf ( const char * ) ;
int sscanf ( const char * , const char * ) ;
int vfprintf ( FILE * , const char * , __gnuc_va_list ) ;
int vprintf ( const char * , __gnuc_va_list ) ;
int vsprintf ( char * , const char * , __gnuc_va_list ) ;
int fgetc ( FILE * ) ;
char * fgets ( char * , int , FILE * ) ;
int fputc ( int , FILE * ) ;
int fputs ( const char * , FILE * ) ;
int getc ( FILE * ) ;
int getchar ( void ) ;
char * gets ( char * ) ;
int putc ( int , FILE * ) ;
int putchar ( int ) ;
int puts ( const char * ) ;
int ungetc ( int , FILE * ) ;
size_t fread ( void * , size_t _size , size_t _n , FILE * ) ;
size_t fwrite ( const void * , size_t _size , size_t _n , FILE * ) ;
int fgetpos ( FILE * , fpos_t * ) ;
int fseek ( FILE * , long , int ) ;
int fsetpos ( FILE * , const fpos_t * ) ;
long ftell ( FILE * ) ;
void rewind ( FILE * ) ;
void clearerr ( FILE * ) ;
int feof ( FILE * ) ;
int ferror ( FILE * ) ;
void perror ( const char * ) ;
FILE * fopen ( const char * _name , const char * _type ) ;
int sprintf ( char * , const char * ) ;
int vfiprintf ( FILE * , const char * , __gnuc_va_list ) ;
int iprintf ( const char * ) ;
int fiprintf ( FILE * , const char * ) ;
int siprintf ( char * , const char * ) ;
FILE * fdopen ( int , const char * ) ;
int fileno ( FILE * ) ;
int getw ( FILE * ) ;
int pclose ( FILE * ) ;
FILE * popen ( const char * , const char * ) ;
int putw ( int , FILE * ) ;
void setbuffer ( FILE * , char * , int ) ;
int setlinebuf ( FILE * ) ;
FILE * _fdopen_r ( struct _reent * , int , const char * ) ;
FILE * _fopen_r ( struct _reent * , const char * , const char * ) ;
int _getchar_r ( struct _reent * ) ;
char * _gets_r ( struct _reent * , char * ) ;
int _iprintf_r ( struct _reent * , const char * ) ;
int _mkstemp_r ( struct _reent * , char * ) ;
char * _mktemp_r ( struct _reent * , char * ) ;
void _perror_r ( struct _reent * , const char * ) ;
int _printf_r ( struct _reent * , const char * ) ;
int _putchar_r ( struct _reent * , int ) ;
int _puts_r ( struct _reent * , const char * ) ;
int _remove_r ( struct _reent * , const char * ) ;
int _rename_r ( struct _reent * , const char * _old , const char * _new ) ;
int _scanf_r ( struct _reent * , const char * ) ;
int _sprintf_r ( struct _reent * , char * , const char * ) ;
char * _tempnam_r ( struct _reent * , char * , char * ) ;
FILE * _tmpfile_r ( struct _reent * ) ;
char * _tmpnam_r ( struct _reent * , char * ) ;
int _vfprintf_r ( struct _reent * , FILE * , const char * , __gnuc_va_list ) ;
int _vprintf_r ( struct _reent * , const char * , __gnuc_va_list ) ;
int _vsprintf_r ( struct _reent * , char * , const char * , __gnuc_va_list ) ;
int __srget ( FILE * ) ;
int __swbuf ( int , FILE * ) ;
FILE * funopen ( const void * _cookie , int ( * readfn ) ( void * _cookie , char * _buf , int _n ) , int ( * writefn ) ( void * _cookie , const char * _buf , int _n ) , fpos_t ( * seekfn ) ( void * _cookie , fpos_t _off , int _whence ) , int ( * closefn ) ( void * _cookie ) ) ;
typedef struct {
int quot ;
int rem ;
} div_t ;
typedef struct {
long quot ;
long rem ;
} ldiv_t ;
extern int __mb_cur_max ;
void abort ( void ) ;
int abs ( int ) ;
int atexit ( void ( * __func ) ( void ) ) ;
double atof ( const char * __nptr ) ;
float atoff ( const char * __nptr ) ;
int atoi ( const char * __nptr ) ;
long atol ( const char * __nptr ) ;
void * bsearch ( const void * __key , const void * __base , size_t __nmemb , size_t __size , int ( * _compar ) ( const void * , const void * ) ) ;
void * calloc ( size_t __nmemb , size_t __size ) ;
div_t div ( int __numer , int __denom ) ;
void exit ( int __status ) ;
void free ( void * ) ;
char * getenv ( const char * __string ) ;
long labs ( long ) ;
ldiv_t ldiv ( long __numer , long __denom ) ;
void * malloc ( size_t __size ) ;
int mblen ( const char * , size_t ) ;
int mbtowc ( wchar_t * , const char * , size_t ) ;
int _mbtowc_r ( struct _reent * , wchar_t * , const char * , size_t , int * ) ;
int wctomb ( char * , wchar_t ) ;
int _wctomb_r ( struct _reent * , char * , wchar_t , int * ) ;
size_t mbstowcs ( wchar_t * , const char * , size_t ) ;
size_t _mbstowcs_r ( struct _reent * , wchar_t * , const char * , size_t , int * ) ;
size_t wcstombs ( char * , const wchar_t * , size_t ) ;
size_t _wcstombs_r ( struct _reent * , char * , const wchar_t * , size_t , int * ) ;
void qsort ( void * __base , size_t __nmemb , size_t __size , int ( * _compar ) ( const void * , const void * ) ) ;
int rand ( void ) ;
void * realloc ( void * __r , size_t __size ) ;
void srand ( unsigned __seed ) ;
double strtod ( const char * __n , char * * _end_PTR ) ;
float strtodf ( const char * __n , char * * _end_PTR ) ;
long strtol ( const char * __n , char * * _end_PTR , int __base ) ;
unsigned long strtoul ( const char * _n_PTR , char * * _end_PTR , int __base ) ;
unsigned long _strtoul_r ( struct _reent * , const char * _n_PTR , char * * _end_PTR , int __base ) ;
int system ( const char * __string ) ;
void cfree ( void * ) ;
int putenv ( const char * __string ) ;
int setenv ( const char * __string , const char * __value , int __overwrite ) ;
char * gcvt ( double , int , char * ) ;
char * gcvtf ( float , int , char * ) ;
char * fcvt ( double , int , int * , int * ) ;
char * fcvtf ( float , int , int * , int * ) ;
char * ecvt ( double , int , int * , int * ) ;
char * ecvtbuf ( double , int , int * , int * , char * ) ;
char * fcvtbuf ( double , int , int * , int * , char * ) ;
char * ecvtf ( float , int , int * , int * ) ;
char * dtoa ( double , int , int , int * , int * , char * * ) ;
int rand_r ( unsigned * __seed ) ;
char * realpath ( const char * , char * ) ;
void unsetenv ( const char * __string ) ;
int random ( void ) ;
long srandom ( unsigned __seed ) ;
char * _dtoa_r ( struct _reent * , double , int , int , int * , int * , char * * ) ;
void * _malloc_r ( struct _reent * , size_t ) ;
void * _calloc_r ( struct _reent * , size_t , size_t ) ;
void _free_r ( struct _reent * , void * ) ;
void * _realloc_r ( struct _reent * , void * , size_t ) ;
void _mstats_r ( struct _reent * , char * ) ;
int _system_r ( struct _reent * , const char * ) ;
void __eprintf ( const char * , const char * , unsigned int , const char * ) ;
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 ) ;
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 bcmp ( const char * , const char * , size_t ) ;
void bcopy ( const char * , char * , size_t ) ;
void bzero ( char * , size_t ) ;
int ffs ( int ) ;
char * index ( const char * , int ) ;
void * memccpy ( void * , const void * , int , size_t ) ;
char * rindex ( const char * , int ) ;
int strcasecmp ( const char * , const char * ) ;
char * strdup ( const char * ) ;
int strncasecmp ( const char * , const char * , size_t ) ;
char * strsep ( char * * , const char * ) ;
char * strlwr ( char * ) ;
char * strupr ( char * ) ;
char * strsignal ( int __signo ) ;
int strtosigno ( const char * __name ) ;
extern char * * environ ;
void _exit ( int __status ) ;
int access ( const char * __path , int __amode ) ;
unsigned alarm ( unsigned __secs ) ;
int chdir ( const char * __path ) ;
int chmod ( const char * __path , mode_t __mode ) ;
int chown ( const char * __path , uid_t __owner , gid_t __group ) ;
int close ( int __fildes ) ;
char * ctermid ( char * __s ) ;
char * cuserid ( char * __s ) ;
int dup ( int __fildes ) ;
int dup2 ( int __fildes , int __fildes2 ) ;
int execl ( const char * __path , const char * ) ;
int execle ( const char * __path , const char * ) ;
int execlp ( const char * __file , const char * ) ;
int execv ( const char * __path , char *const __argv [ ] ) ;
int execve ( const char * __path , char *const __argv [ ] , char *const __envp [ ] ) ;
int execvp ( const char * __file , char *const __argv [ ] ) ;
pid_t fork ( void ) ;
long fpathconf ( int __fd , int __name ) ;
int fsync ( int __fd ) ;
char * getcwd ( char * __buf , size_t __size ) ;
gid_t getegid ( void ) ;
uid_t geteuid ( void ) ;
gid_t getgid ( void ) ;
int getgroups ( int __gidsetsize , gid_t __grouplist [ ] ) ;
char * getlogin ( void ) ;
size_t getpagesize ( void ) ;
pid_t getpgrp ( void ) ;
pid_t getpid ( void ) ;
pid_t getppid ( void ) ;
uid_t getuid ( void ) ;
int isatty ( int __fildes ) ;
int link ( const char * __path1 , const char * __path2 ) ;
off_t lseek ( int __fildes , off_t __offset , int __whence ) ;
long pathconf ( char * __path , int __name ) ;
int pause ( void ) ;
int pipe ( int __fildes [ 2 ] ) ;
int read ( int __fildes , void * __buf , size_t __nbyte ) ;
int rmdir ( const char * __path ) ;
void * sbrk ( size_t __incr ) ;
int setgid ( gid_t __gid ) ;
int setpgid ( pid_t __pid , pid_t __pgid ) ;
pid_t setsid ( void ) ;
int setuid ( uid_t __uid ) ;
unsigned sleep ( unsigned int __seconds ) ;
void swab ( const void * , void * , ssize_t ) ;
long sysconf ( int __name ) ;
pid_t tcgetpgrp ( int __fildes ) ;
int tcsetpgrp ( int __fildes , pid_t __pgrp_id ) ;
char * ttyname ( int __fildes ) ;
int unlink ( const char * __path ) ;
int write ( int __fildes , const void * __buf , size_t __nbyte ) ;
int _close ( int __fildes ) ;
pid_t _fork ( void ) ;
pid_t _getpid ( void ) ;
int _link ( const char * __path1 , const char * __path2 ) ;
off_t _lseek ( int __fildes , off_t __offset , int __whence ) ;
int _read ( int __fildes , void * __buf , size_t __nbyte ) ;
void * _sbrk ( size_t __incr ) ;
int _unlink ( const char * __path ) ;
int _write ( int __fildes , const void * __buf , size_t __nbyte ) ;
unsigned usleep ( unsigned int __useconds ) ;
int ftruncate ( int __fd , off_t __length ) ;
int truncate ( const char * , off_t __length ) ;
int gethostname ( char * __name , size_t __len ) ;
char * mktemp ( char * ) ;
int sync ( void ) ;
int readlink ( const char * __path , char * __buf , int __buflen ) ;
int symlink ( const char * __name1 , const char * __name2 ) ;
long sysconf ( int __name ) ;
extern char * optarg ;
extern int optind ;
extern int opterr ;
extern int optopt ;
struct option {
const char * name ;
int has_arg ;
int * flag ;
int val ;
} ;
extern int getopt () ;
extern int getopt_long ( int argc , char *const * argv , const char * shortopts , const struct option * longopts , int * longind ) ;
extern int getopt_long_only ( int argc , char *const * argv , const char * shortopts , const struct option * longopts , int * longind ) ;
extern int _getopt_internal ( int argc , char *const * argv , const char * shortopts , const struct option * longopts , int * longind , int long_only ) ;
typedef struct _strbuf {
char * name ;
char * sbuf ;
char * endp ;
char * curp ;
int sbufsize ;
int alloc_failed ;
} STRBUF ;
void __strbuf_expandbuf ( STRBUF * , int ) ;
STRBUF * strbuf_open ( int ) ;
char * strbuf_value ( STRBUF * ) ;
void strbuf_trim ( STRBUF * ) ;
int strbuf_unputc ( STRBUF * , int ) ;
void strbuf_close ( STRBUF * ) ;
char * strbuf_fgets ( STRBUF * , FILE * , int ) ;
char * configpath ( void ) ;
void openconf ( void ) ;
int getconfn ( const char * , int * ) ;
int getconfs ( const char * , STRBUF * ) ;
int getconfb ( const char * ) ;
char * getconfline ( void ) ;
void closeconf ( void ) ;
typedef u_int32_t pgno_t ;
typedef u_int16_t indx_t ;
typedef u_int32_t recno_t ;
typedef struct {
void * data ;
size_t size ;
} DBT ;
typedef enum {
DB_BTREE,
DB_HASH,
DB_RECNO
} DBTYPE ;
typedef struct __db {
DBTYPE type ;
int ( * close ) ( struct __db * ) ;
int ( * del ) ( const struct __db * , const DBT * , u_int ) ;
int ( * get ) ( const struct __db * , const DBT * , DBT * , u_int ) ;
int ( * put ) ( const struct __db * , DBT * , const DBT * , u_int ) ;
int ( * seq ) ( const struct __db * , DBT * , DBT * , u_int ) ;
int ( * sync ) ( const struct __db * , u_int ) ;
void * internal ;
int ( * fd ) ( const struct __db * ) ;
} DB ;
typedef struct {
u_long flags ;
u_int cachesize ;
int maxkeypage ;
int minkeypage ;
u_int psize ;
int ( * compare ) ( const DBT * , const DBT * ) ;
size_t ( * prefix2 ) ( const DBT * , const DBT * ) ;
int lorder ;
} BTREEINFO ;
typedef struct {
u_int bsize ;
u_int ffactor ;
u_int nelem ;
u_int cachesize ;
u_int32_t ( * hash ) ( const void * , size_t ) ;
int lorder ;
} HASHINFO ;
typedef struct {
u_long flags ;
u_int cachesize ;
u_int psize ;
int lorder ;
size_t reclen ;
u_char bval ;
char * bfname ;
} RECNOINFO ;
DB * dbopen ( const char * , int , int , DBTYPE , const void * ) ;
DB * __bt_open ( const char * , int , int , const BTREEINFO * , int ) ;
DB * __hash_open ( const char * , int , int , const HASHINFO * , int ) ;
DB * __rec_open ( const char * , int , int , const RECNOINFO * , int ) ;
void __dbpanic ( DB * dbp ) ;
typedef long int s_reg_t ;
typedef unsigned long int active_reg_t ;
typedef unsigned long int reg_syntax_t ;
extern reg_syntax_t re_syntax_options ;
typedef enum {
REG_NOERROR = 0 ,
REG_NOMATCH,
REG_BADPAT,
REG_ECOLLATE,
REG_ECTYPE,
REG_EESCAPE,
REG_ESUBREG,
REG_EBRACK,
REG_EPAREN,
REG_EBRACE,
REG_BADBR,
REG_ERANGE,
REG_ESPACE,
REG_BADRPT,
REG_EEND,
REG_ESIZE,
REG_ERPAREN
} reg_errcode_t ;
struct re_pattern_buffer {
unsigned char * buffer ;
unsigned long int allocated ;
unsigned long int used ;
reg_syntax_t syntax ;
char * fastmap ;
char * translate ;
size_t re_nsub ;
unsigned can_be_null : ;
unsigned regs_allocated : ;
unsigned fastmap_accurate : ;
unsigned no_sub : ;
unsigned not_bol : ;
unsigned not_eol : ;
unsigned newline_anchor : ;
} ;
typedef struct re_pattern_buffer regex_t ;
typedef int regoff_t ;
struct re_registers {
unsigned num_regs ;
regoff_t * start ;
regoff_t * end ;
} ;
typedef struct {
regoff_t rm_so ;
regoff_t rm_eo ;
} regmatch_t ;
extern reg_syntax_t re_set_syntax ( reg_syntax_t syntax ) ;
extern const char * re_compile_pattern ( const char * pattern , size_t length , struct re_pattern_buffer * buffer ) ;
extern int re_compile_fastmap ( struct re_pattern_buffer * buffer ) ;
extern int re_search ( struct re_pattern_buffer * buffer , const char * string , int length , int start , int range , struct re_registers * regs ) ;
extern int re_search_2 ( struct re_pattern_buffer * buffer , const char * string1 , int length1 , const char * string2 , int length2 , int start , int range , struct re_registers * regs , int stop ) ;
extern int re_match ( struct re_pattern_buffer * buffer , const char * string , int length , int start , struct re_registers * regs ) ;
extern int re_match_2 ( struct re_pattern_buffer * buffer , const char * string1 , int length1 , const char * string2 , int length2 , int start , struct re_registers * regs , int stop ) ;
extern void re_set_registers ( struct re_pattern_buffer * buffer , struct re_registers * regs , unsigned num_regs , regoff_t * starts , regoff_t * ends ) ;
extern int regcomp ( regex_t * __preg , const char * __pattern , int __cflags ) ;
extern int regexec ( const regex_t * __preg , const char * __string , size_t __nmatch , regmatch_t __pmatch [ ] , int __eflags ) ;
extern size_t regerror ( int __errcode , const regex_t * __preg , char * __errbuf , size_t __errbuf_size ) ;
extern void regfree ( regex_t * __preg ) ;
typedef struct {
DB * db ;
char dbname [ ( 260 - 1 ) + 1 ] ;
char key [ 300 + 1 ] ;
int keylen ;
regex_t * preg ;
char prev [ 300 + 1 ] ;
char * lastkey ;
char * lastdat ;
int openflags ;
int ioflags ;
int perm ;
} DBOP ;
DBOP * dbop_open ( const char * , int , int , int ) ;
char * dbop_get ( DBOP * , const char * ) ;
void dbop_put ( DBOP * , const char * , const char * ) ;
void dbop_del ( DBOP * , const char * ) ;
char * dbop_first ( DBOP * , const char * , regex_t * , int ) ;
char * dbop_next ( DBOP * ) ;
void dbop_close ( DBOP * ) ;
int defined ( const char * ) ;
void va_end ( __gnuc_va_list ) ;
typedef __gnuc_va_list va_list ;
extern const char * progname ;
void die ( const char * s ) ;
int snprintf ( char * s , size_t n , const char * format ) ;
int issource ( char * ) ;
void ffindopen ( void ) ;
char * ffindread ( int * ) ;
void ffindclose ( void ) ;
void gfindopen ( char * , char * ) ;
char * gfindread ( void ) ;
void gfindclose ( void ) ;
int gtagsexist ( char * , char * , int , int ) ;
void getdbpath ( char * , char * , char * , int ) ;
typedef struct {
DBOP * dbop ;
int format_version ;
int format ;
int mode ;
int db ;
int flags ;
char root [ ( 260 - 1 ) + 1 ] ;
int opened ;
char * line ;
char tag [ 512 + 1 ] ;
char prev_tag [ 512 + 1 ] ;
char path [ ( 260 - 1 ) + 1 ] ;
char prev_path [ ( 260 - 1 ) + 1 ] ;
STRBUF * sb ;
STRBUF * ib ;
FILE * fp ;
char * lnop ;
int lno ;
} GTOP ;
const char * dbname ( int ) ;
void makecommand ( char * , char * , STRBUF * ) ;
int formatcheck ( char * , int ) ;
int notnamechar ( char * ) ;
GTOP * gtagsopen ( char * , char * , int , int , int ) ;
void gtagsput ( GTOP * , char * , char * ) ;
char * gtagsget ( GTOP * , char * ) ;
void gtagsadd ( GTOP * , char * , char * , int ) ;
void gtagsdelete ( GTOP * , char * ) ;
char * gtagsfirst ( GTOP * , char * , int ) ;
char * gtagsnext ( GTOP * ) ;
void gtagsclose ( GTOP * ) ;
char * locatestring ( const char * , const char * , int ) ;
char * makepath ( const char * , const char * , const char * ) ;
int isabspath ( char * ) ;
char * canonpath ( char * ) ;
int pathopen ( const char * , int ) ;
char * pathget ( const char * ) ;
char * pathiget ( int ) ;
void pathput ( const char * ) ;
void pathdel ( const char * ) ;
void pathclose ( void ) ;
int nextkey ( void ) ;
char * strmake ( const char * , const char * ) ;
void settabs ( int ) ;
void detab ( FILE * , char * ) ;
void entab ( char * ) ;
int test ( const char * , const char * ) ;
extern unsigned char * sp , * cp , * lp ;
extern int lineno ;
extern int crflag ;
extern int cmode ;
extern int cppmode ;
extern int ymode ;
extern unsigned char token [ 512 ] ;
extern unsigned char curfile [ ( 260 - 1 ) ] ;
int opentoken ( char * ) ;
void rewindtoken ( void ) ;
void closetoken ( void ) ;
int nexttoken ( const char * , int ( * ) ( char * ) ) ;
void pushbacktoken ( void ) ;
int peekc ( int ) ;
int atfirst_exceptspace ( void ) ;
char * usable ( char * ) ;
extern const char * progname ;
void version ( const char * , const int ) ;
const char * progname = " global " ;
static void usage ( void ) ;
static void help ( void ) ;
static void setcom ( int ) ;
int main ( int , char * * ) ;
void makefilter ( STRBUF * ) ;
FILE * openfilter ( void ) ;
void closefilter ( FILE * ) ;
void completion ( char * , char * , char * ) ;
void relative_filter ( STRBUF * , char * , char * ) ;
void idutils ( char * , char * ) ;
void grep ( char * , char * ) ;
void pathlist ( char * , char * ) ;
void parsefile ( int , char * * , char * , char * , char * , int ) ;
void printtag ( FILE * , char * ) ;
int search ( char * , char * , char * , int ) ;
int includepath ( char * , char * ) ;
void ffformat ( char * , int , char * ) ;
char sort_command [ 1024 + 1 ] ;
char sed_command [ 1024 + 1 ] ;
STRBUF * sortfilter ;
STRBUF * pathfilter ;
char * localprefix ;
int aflag ;
int cflag ;
int fflag ;
int gflag ;
int iflag ;
int Iflag ;
int lflag ;
int nflag ;
int pflag ;
int Pflag ;
int rflag ;
int sflag ;
int tflag ;
int vflag ;
int xflag ;
int show_version ;
int show_help ;
int show_filter ;
int use_tagfiles ;
int debug ;
char * extra_options ;
const char * usage_const = " Usage: global [-alnrstvx] pattern\n global -c[sv] [prefix]\n global -f[anrstvx] files\n global -g[alntvx] pattern\n global -G[alntvx] pattern\n global -i[v]\n global -I[alntvx] pattern\n global -p[rv]\n global -P[alntvx] [pattern]\n " ;
const char * help_const = " Pattern accept POSIX 1003.2 regular expression.\nCommands:\n (none) pattern\n print the locations of specified functions.\n -c, --completion [prefix]\n print candidate function names which start with prefix.\n -f, --file files\n print all functions in the files.\n -g, --grep pattern\n print all lines which match to the pattern.\n -i, --incremental\n locate tag files and reconstruct them incrementally.\n -I, --idutils\n print all lines which match to the pattern using idutils.\n -p, --print-dbpath\n print the location of tag files.\n -P, --path [pattern]\n print the path which match to the pattern.\n -s, --symbol pattern\n print the locations of specified symbol other than function.\n --version\n show version number.\n --help show help.\nOptions:\n -a, --absolute\n print absolute path name.\n -l, --local\n print just objects which exist under the current directory.\n -n, --nofilter\n suppress sort filter and path conversion filter.\n -r, --reference (--rootdir)\n print the locations of object references.\n with the -p option print the root directory of source tree.\n -t, --tags\n print with standard ctags format.\n -v, --verbose\n verbose mode.\n -x, --cxref\n produce the line number and the line contents.\n " ;

static void usage ()
{
fputs ( usage_const , ( _impure_ptr _stderr -> ) ) ;
exit ( 2 ) ;
}

static void help ()
{
fputs ( usage_const , ( _impure_ptr _stdout -> ) ) ;
fputs ( help_const , ( _impure_ptr _stdout -> ) ) ;
exit ( 0 ) ;
}

static struct option const long_options [ ] = { { " absolute " , 0 , ( ( void * ) 0 ) , 'a' } , { " completion " , 0 , ( ( void * ) 0 ) , 'c' } , { " file " , 0 , ( ( void * ) 0 ) , 'f' } , { " local " , 0 , ( ( void * ) 0 ) , 'l' } , { " nofilter " , 0 , ( ( void * ) 0 ) , 'n' } , { " grep " , 0 , ( ( void * ) 0 ) , 'g' } , { " incremental " , 0 , ( ( void * ) 0 ) , 'i' } , { " print-dbpath " , 0 , ( ( void * ) 0 ) , 'p' } , { " path " , 0 , ( ( void * ) 0 ) , 'P' } , { " reference " , 0 , ( ( void * ) 0 ) , 'r' } , { " rootdir " , 0 , ( ( void * ) 0 ) , 'r' } , { " symbol " , 0 , ( ( void * ) 0 ) , 's' } , { " tags " , 0 , ( ( void * ) 0 ) , 't' } , { " verbose " , 0 , ( ( void * ) 0 ) , 'v' } , { " cxref " , 0 , ( ( void * ) 0 ) , 'x' } , { " debug " , 0 , & debug , 1 } , { " idutils " , 2 , & Iflag , 1 } , { " version " , 0 , & show_version , 1 } , { " help " , 0 , & show_help , 1 } , { " filter " , 0 , & show_filter , 1 } , { 0 } } ;
static int command ;

static void setcom (c)
int c ;
{
if ( command == 0 )
command = c ;
else if ( command != c )
usage ( usage ) ;
}

int main (argc, argv)
int argc ;
char * argv [ ] ;
{
char * av ;
int count ;
int db ;
int optchar ;
int option_index = 0 ;
char cwd [ ( 260 - 1 ) + 1 ] ;
char root [ ( 260 - 1 ) + 1 ] ;
char dbpath [ ( 260 - 1 ) + 1 ] ;
while ( ( optchar = getopt_long ( argc , argv , " acfgGiIlnpPrstvx " , long_options , & option_index ) ) != ( - 1 ) ){
switch ( optchar ){
case 0 :
if ( ! strcmp ( " idutils " , long_options [ option_index ] name . ) )
extra_options = optarg ;
break ;
case 'a' :
aflag ++ ;
break ;
case 'c' :
cflag ++ ;
setcom ( optchar ) ;
break ;
case 'f' :
fflag ++ ;
xflag ++ ;
setcom ( optchar ) ;
break ;
case 'l' :
lflag ++ ;
break ;
case 'n' :
nflag ++ ;
break ;
case 'g' :
gflag ++ ;
setcom ( optchar ) ;
break ;
case 'i' :
iflag ++ ;
setcom ( optchar ) ;
break ;
case 'I' :
Iflag ++ ;
setcom ( optchar ) ;
break ;
case 'p' :
pflag ++ ;
setcom ( optchar ) ;
break ;
case 'P' :
Pflag ++ ;
setcom ( optchar ) ;
break ;
case 'r' :
rflag ++ ;
break ;
case 's' :
sflag ++ ;
break ;
case 't' :
tflag ++ ;
break ;
case 'v' :
vflag ++ ;
break ;
case 'x' :
xflag ++ ;
break ;
default :
usage ( usage ) ;
break ;
}
}
if ( show_help )
help ( help ) ;
argc -= optind ;
argv += optind ;
av = ( argc > 0 ) ? * argv : ( ( void * ) 0 ) ;
if ( show_version )
version ( av , vflag ) ;
if ( sflag && rflag )
die ( " both of -s and -r are not allowed. " ) ;
if ( ! av && ! show_filter ){
switch ( command ){
case 'c' :
case 'i' :
case 'p' :
case 'P' :
break ;
default :
usage ( usage ) ;
break ;
}
}
if ( av ){
switch ( command ){
case 'i' :
case 'p' :
usage ( usage ) ;
default :
break ;
}
}
if ( fflag )
lflag = 0 ;
if ( ! Iflag && ! gflag && av )
for ( ; * av == '\' || * av == '\t' ; av ++ )
;
if ( cflag && av && notnamechar ( av ) )
die ( " only name char is allowed with -c option. " ) ;
getdbpath ( cwd , root , dbpath , ( pflag && vflag ) ) ;
if ( Iflag && strcmp ( root , dbpath ) )
die ( " You must have idutils\'s index at the root of source tree. " ) ;
if ( pflag ){
char * dir = ( rflag ) ? root : dbpath ;
fprintf ( ( _impure_ptr _stdout -> ) , " %s\n " , dir ) ;
exit ( 0 ) ;
}
if ( iflag ){
STRBUF * sb = strbuf_open ( 0 ) ;
if ( chdir ( root ) < 0 )
die ( " cannot change directory to \'%s\'. " , root ) ;
do {
unsigned int _length = strlen ( " gtags -i " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " gtags -i " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
if ( vflag )
do {
if ( ! sb alloc_failed -> ){
if ( sb curp -> >= sb endp -> )
__strbuf_expandbuf ( sb , 0 ) ;
* sb curp -> ++ = 'v' ;
}
} while ( 0 );
do {
if ( ! sb alloc_failed -> ){
if ( sb curp -> >= sb endp -> )
__strbuf_expandbuf ( sb , 0 ) ;
* sb curp -> ++ = '\' ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( dbpath ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , dbpath , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
if ( system ( strbuf_value ( sb ) ) )
exit ( 1 ) ;
strbuf_close ( sb ) ;
exit ( 0 ) ;
}
if ( cflag ){
completion ( dbpath , root , av ) ;
exit ( 0 ) ;
}
STRBUF * sb = strbuf_open ( 0 ) ;
if ( ! getconfs ( " sort_command " , sb ) )
die ( " cannot get sort command name. " ) ;
if ( ! locatestring ( strbuf_value ( sb ) , " .exe " , 2 ) )
do {
unsigned int _length = strlen ( " .exe " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " .exe " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
strcpy ( sort_command , strbuf_value ( sb ) ) ;
do {
sb curp -> = sb sbuf -> ;
sb alloc_failed -> = 0 ;
} while ( 0 );
if ( ! getconfs ( " sed_command " , sb ) )
die ( " cannot get sed command name. " ) ;
if ( ! locatestring ( strbuf_value ( sb ) , " .exe " , 2 ) )
do {
unsigned int _length = strlen ( " .exe " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " .exe " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
strcpy ( sed_command , strbuf_value ( sb ) ) ;
strbuf_close ( sb ) ;
}
if ( lflag ){
char * p = cwd + strlen ( root ) ;
STRBUF * sb = strbuf_open ( 0 ) ;
do {
if ( ! sb alloc_failed -> ){
if ( sb curp -> >= sb endp -> )
__strbuf_expandbuf ( sb , 0 ) ;
* sb curp -> ++ = '.' ;
}
} while ( 0 );
if ( * p )
do {
unsigned int _length = strlen ( p ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , p , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
do {
if ( ! sb alloc_failed -> ){
if ( sb curp -> >= sb endp -> )
__strbuf_expandbuf ( sb , 0 ) ;
* sb curp -> ++ = '/' ;
}
} while ( 0 );
localprefix = strdup ( strbuf_value ( sb ) ) ;
if ( ! localprefix )
die ( " short of memory. " ) ;
strbuf_close ( sb ) ;
}
else {
localprefix = ( ( void * ) 0 ) ;
}
sortfilter = strbuf_open ( 0 ) ;
do {
unsigned int _length = strlen ( sort_command ) ;
if ( ! sortfilter alloc_failed -> ){
if ( sortfilter curp -> + _length > sortfilter endp -> )
__strbuf_expandbuf ( sortfilter , _length ) ;
strncpy ( sortfilter curp -> , sort_command , _length ) ;
sortfilter curp -> += _length ;
}
} while ( 0 );
do {
if ( ! sortfilter alloc_failed -> ){
if ( sortfilter curp -> >= sortfilter endp -> )
__strbuf_expandbuf ( sortfilter , 0 ) ;
* sortfilter curp -> ++ = '\' ;
}
} while ( 0 );
if ( tflag )
do {
unsigned int _length = strlen ( " +0 -1 +1 -2 +2n -3 " ) ;
if ( ! sortfilter alloc_failed -> ){
if ( sortfilter curp -> + _length > sortfilter endp -> )
__strbuf_expandbuf ( sortfilter , _length ) ;
strncpy ( sortfilter curp -> , " +0 -1 +1 -2 +2n -3 " , _length ) ;
sortfilter curp -> += _length ;
}
} while ( 0 );
else if ( fflag )
do {
unsigned int _length = 0 ;
if ( ! sortfilter alloc_failed -> ){
if ( _length < ( sortfilter curp -> - sortfilter sbuf -> ) )
sortfilter curp -> = sortfilter sbuf -> + _length ;
else if ( _length > ( sortfilter curp -> - sortfilter sbuf -> ) )
__strbuf_expandbuf ( sortfilter , _length - ( sortfilter curp -> - sortfilter sbuf -> ) ) ;
}
} while ( 0 );
else if ( xflag )
do {
unsigned int _length = strlen ( " +0 -1 +2 -3 +1n -2 " ) ;
if ( ! sortfilter alloc_failed -> ){
if ( sortfilter curp -> + _length > sortfilter endp -> )
__strbuf_expandbuf ( sortfilter , _length ) ;
strncpy ( sortfilter curp -> , " +0 -1 +2 -3 +1n -2 " , _length ) ;
sortfilter curp -> += _length ;
}
} while ( 0 );
else
do {
unsigned int _length = strlen ( " -u " ) ;
if ( ! sortfilter alloc_failed -> ){
if ( sortfilter curp -> + _length > sortfilter endp -> )
__strbuf_expandbuf ( sortfilter , _length ) ;
strncpy ( sortfilter curp -> , " -u " , _length ) ;
sortfilter curp -> += _length ;
}
} while ( 0 );
pathfilter = strbuf_open ( 0 ) ;
if ( aflag ){
do {
unsigned int _length = strlen ( sed_command ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , sed_command , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> >= pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , 0 ) ;
* pathfilter curp -> ++ = '\' ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " -e \"s@\\.@ " ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , " -e \"s@\\.@ " , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( root ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , root , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " @\" " ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , " @\" " , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
}
else if ( lflag ){
do {
unsigned int _length = strlen ( sed_command ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , sed_command , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> >= pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , 0 ) ;
* pathfilter curp -> ++ = '\' ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " -e \"s@\\ " ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , " -e \"s@\\ " , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( localprefix ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , localprefix , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " @@\" " ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , " @@\" " , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
}
else {
relative_filter ( pathfilter , root , cwd ) ;
}
if ( show_filter ){
STRBUF * sb = strbuf_open ( 0 ) ;
makefilter ( sb ) ;
fprintf ( ( _impure_ptr _stdout -> ) , " %s\n " , strbuf_value ( sb ) ) ;
strbuf_close ( sb ) ;
exit ( 0 ) ;
}
if ( Iflag ){
if ( ! usable ( " gid " ) )
die ( " gid(idutils) not found. " ) ;
chdir ( root ) ;
idutils ( av , dbpath ) ;
exit ( 0 ) ;
}
if ( gflag ){
chdir ( root ) ;
grep ( av , dbpath ) ;
exit ( 0 ) ;
}
if ( Pflag ){
pathlist ( dbpath , av ) ;
exit ( 0 ) ;
}
db = ( rflag ) ? 2 : ( ( sflag ) ? 3 : 1 ) ;
if ( fflag ){
parsefile ( argc , argv , cwd , root , dbpath , db ) ;
exit ( 0 ) ;
}
count = search ( av , root , dbpath , db ) ;
if ( count == 0 && ! lflag && ! rflag && ! sflag && ! notnamechar ( av ) && getenv ( " GTAGSLIBPATH " ) ){
char buf [ 1024 + 1 ] ;
char libdbpath [ ( 260 - 1 ) + 1 ] ;
char * p , * lib ;
strcpy ( buf , getenv ( " GTAGSLIBPATH " ) ) ;
p = buf ;
while ( p ){
lib = p ;
if ( ( p = locatestring ( p , " : " , 0 ) ) != ( ( void * ) 0 ) )
* p ++ = 0 ;
if ( ! gtagsexist ( lib , libdbpath , sizeof ( libdbpath ) , 0 ) )
continue ;
if ( ! strcmp ( dbpath , libdbpath ) )
continue ;
if ( aflag ){
do {
pathfilter curp -> = pathfilter sbuf -> ;
pathfilter alloc_failed -> = 0 ;
} while ( 0 );
do {
unsigned int _length = strlen ( sed_command ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , sed_command , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> >= pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , 0 ) ;
* pathfilter curp -> ++ = '\' ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " -e \"s@\\.@ " ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , " -e \"s@\\.@ " , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( lib ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , lib , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " @\" " ) ;
if ( ! pathfilter alloc_failed -> ){
if ( pathfilter curp -> + _length > pathfilter endp -> )
__strbuf_expandbuf ( pathfilter , _length ) ;
strncpy ( pathfilter curp -> , " @\" " , _length ) ;
pathfilter curp -> += _length ;
}
} while ( 0 );
}
else {
do {
pathfilter curp -> = pathfilter sbuf -> ;
pathfilter alloc_failed -> = 0 ;
} while ( 0 );
relative_filter ( pathfilter , lib , cwd ) ;
}
count = search ( av , lib , libdbpath , db ) ;
if ( count > 0 ){
strcpy ( dbpath , libdbpath ) ;
break ;
}
}
}
if ( vflag ){
if ( count ){
if ( count == 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d object located " , count ) ;
if ( count > 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d objects located " , count ) ;
}
else {
fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' not found " , av ) ;
}
fprintf ( ( _impure_ptr _stderr -> ) , " (using \'%s\').\n " , makepath ( dbpath , dbname ( db ) , ( ( void * ) 0 ) ) ) ;
}
strbuf_close ( sortfilter ) ;
strbuf_close ( pathfilter ) ;
return 0 ;
}

void makefilter (sb)
STRBUF * sb ;
{
if ( ! nflag ){
do {
unsigned int _length = strlen ( strbuf_value ( sortfilter ) ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , strbuf_value ( sortfilter ) , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
if ( ( sortfilter curp -> - sortfilter sbuf -> ) && ( pathfilter curp -> - pathfilter sbuf -> ) )
do {
unsigned int _length = strlen ( " | " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " | " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( strbuf_value ( pathfilter ) ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , strbuf_value ( pathfilter ) , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
}
}

FILE * openfilter ( void )
{
FILE * op ;
STRBUF * sb = strbuf_open ( 0 ) ;
makefilter ( sb ) ;
if ( ( sb curp -> - sb sbuf -> ) == 0 )
op = ( _impure_ptr _stdout -> ) ;
else
op = popen ( strbuf_value ( sb ) , " w " ) ;
strbuf_close ( sb ) ;
return op ;
}

void closefilter (op)
FILE * op ;
{
if ( op != ( _impure_ptr _stdout -> ) )
pclose ( op ) ;
}

void completion (dbpath, root, prefix)
char * dbpath ;
char * root ;
char * prefix ;
{
char * p ;
int flags = 1 ;
GTOP * gtop ;
int db ;
flags |= 8 ;
if ( prefix && * prefix == 0 )
prefix = ( ( void * ) 0 ) ;
if ( prefix )
flags |= 2 ;
db = ( sflag ) ? 3 : 1 ;
gtop = gtagsopen ( dbpath , root , db , 0 , 0 ) ;
for ( p = gtagsfirst ( gtop , prefix , flags ) ; p ; p = gtagsnext ( gtop ) )
( void ) fprintf ( ( _impure_ptr _stdout -> ) , " %s\n " , p ) ;
gtagsclose ( gtop ) ;
}

void relative_filter (sb, root, cwd)
STRBUF * sb ;
char * root ;
char * cwd ;
{
char * p , * c , * branch ;
branch = cwd ;
for ( p = root , c = cwd ; * p && * c && * p == * c ; p ++ , c ++ )
if ( * c == '/' )
branch = c ;
if ( * p == 0 && ( * c == 0 || * c == '/' ) )
branch = c ;
do {
unsigned int _length = strlen ( sed_command ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , sed_command , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
do {
if ( ! sb alloc_failed -> ){
if ( sb curp -> >= sb endp -> )
__strbuf_expandbuf ( sb , 0 ) ;
* sb curp -> ++ = '\' ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " -e \"s@\\./@ " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " -e \"s@\\./@ " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
for ( c = branch ; * c ; c ++ )
if ( * c == '/' )
do {
unsigned int _length = strlen ( " ../ " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " ../ " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
p = root + ( branch - cwd ) ;
if ( * p ){
p ++ ;
do {
unsigned int _length = strlen ( p ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , p , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
do {
if ( ! sb alloc_failed -> ){
if ( sb curp -> >= sb endp -> )
__strbuf_expandbuf ( sb , 0 ) ;
* sb curp -> ++ = '/' ;
}
} while ( 0 );
}
do {
unsigned int _length = strlen ( " @\" " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " @\" " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
if ( * branch ){
char unit [ 256 ] ;
p = unit ;
for ( c = branch + 1 ; ; c ++ ){
if ( * c == 0 || * c == '/' ){
* p = 0 ;
do {
unsigned int _length = strlen ( " -e \"s@\\.\\./ " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " -e \"s@\\.\\./ " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( unit ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , unit , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " /@@\" " ) ;
if ( ! sb alloc_failed -> ){
if ( sb curp -> + _length > sb endp -> )
__strbuf_expandbuf ( sb , _length ) ;
strncpy ( sb curp -> , " /@@\" " , _length ) ;
sb curp -> += _length ;
}
} while ( 0 );
if ( * c == 0 )
break ;
p = unit ;
}
else
* p ++ = * c ;
}
}
}

void printtag (op, bp)
FILE * op ;
char * bp ;
{
if ( tflag ){
char buf [ 1024 + 1 ] ;
char lno [ 20 ] , * l = lno ;
char * p = bp ;
char * q = buf ;
while ( * p && ! ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) )
* q ++ = * p ++ ;
* q ++ = '\t' ;
for ( ; * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) ; p ++ )
;
while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 4 ) )
* l ++ = * p ++ ;
* l = 0 ;
for ( ; * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) ; p ++ )
;
while ( * p && ! ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) )
* q ++ = * p ++ ;
* q ++ = '\t' ;
l = lno ;
while ( * l )
* q ++ = * l ++ ;
* q = 0 ;
fprintf ( op , " %s\n " , buf ) ;
}
else if ( ! xflag ){
char * p = locatestring ( bp , " ./ " , 0 ) ;
if ( p == ( ( void * ) 0 ) )
die ( " illegal tag format (path not found). " ) ;
fputs ( strmake ( p , " \t " ) , op ) ;
( void ) ( -- ( op ) _w -> < 0 ? ( op ) _w -> >= ( op ) _lbfsize -> ? ( * ( op ) _p -> = ( '\n' ) ) , * ( op ) _p -> != '\n' ? ( int ) * ( op ) _p -> ++ : __swbuf ( '\n' , op ) : __swbuf ( ( int ) ( '\n' ) , op ) : ( * ( op ) _p -> = ( '\n' ) , ( int ) * ( op ) _p -> ++ ) ) ;
}
else
fprintf ( op , " %s\n " , bp ) ;
}

void idutils (pattern, dbpath)
char * pattern ;
char * dbpath ;
{
FILE * ip , * op ;
STRBUF * ib = strbuf_open ( 0 ) ;
char edit [ 512 + 1 ] ;
char * line , * p , * path , * lno ;
int linenum , count , editlen ;
ffformat ( edit , sizeof ( edit ) , pattern ) ;
editlen = strlen ( edit ) ;
do {
unsigned int _length = strlen ( " gid " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " gid " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " --separator=newline " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " --separator=newline " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
if ( ! tflag && ! xflag )
do {
unsigned int _length = strlen ( " --result=filenames --key=none " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " --result=filenames --key=none " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
else
do {
unsigned int _length = strlen ( " --result=grep " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " --result=grep " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
if ( extra_options ){
do {
unsigned int _length = strlen ( extra_options ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , extra_options , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
do {
if ( ! ib alloc_failed -> ){
if ( ib curp -> >= ib endp -> )
__strbuf_expandbuf ( ib , 0 ) ;
* ib curp -> ++ = '\' ;
}
} while ( 0 );
}
do {
if ( ! ib alloc_failed -> ){
if ( ib curp -> >= ib endp -> )
__strbuf_expandbuf ( ib , 0 ) ;
* ib curp -> ++ = '\'' ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( pattern ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , pattern , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
do {
if ( ! ib alloc_failed -> ){
if ( ib curp -> >= ib endp -> )
__strbuf_expandbuf ( ib , 0 ) ;
* ib curp -> ++ = '\'' ;
}
} while ( 0 );
if ( debug )
fprintf ( ( _impure_ptr _stderr -> ) , " idutils: %s\n " , strbuf_value ( ib ) ) ;
if ( ! ( ip = popen ( strbuf_value ( ib ) , " r " ) ) )
die ( " cannot execute \'%s\'. " , strbuf_value ( ib ) ) ;
if ( ! ( op = openfilter ( openfilter ) ) )
die ( " cannot open output filter. " ) ;
count = 0 ;
while ( ( line = strbuf_fgets ( ib , ip , 2 ) ) != ( ( void * ) 0 ) ){
p = line ;
path = p ;
while ( * p && * p != ':' )
p ++ ;
if ( ( xflag || tflag ) && ! * p )
die ( " illegal gid(idutils) output format. \'%s\' " , line ) ;
* p ++ = 0 ;
if ( lflag ){
if ( ! locatestring ( path , localprefix + 2 , 1 ) )
continue ;
}
count ++ ;
if ( ! xflag && ! tflag ){
fprintf ( op , " ./%s\n " , path ) ;
continue ;
}
while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) )
p ++ ;
lno = p ;
while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 4 ) )
p ++ ;
if ( * p != ':' )
die ( " illegal grep output format. \'%s\' " , line ) ;
* p ++ = 0 ;
linenum = atoi ( lno ) ;
if ( linenum <= 0 )
die ( " illegal grep output format. \'%s\' " , line ) ;
if ( tflag )
fprintf ( op , " %s\t./%s\t%d\n " , edit , path , linenum ) ;
else {
char buf [ ( 260 - 1 ) + 1 ] ;
snprintf ( buf , sizeof ( buf ) , " ./%s " , path ) ;
if ( editlen >= 16 && linenum >= 1000 )
fprintf ( op , " %-16s %4d %-16s %s\n " , edit , linenum , buf , p ) ;
else
fprintf ( op , " %-16s%4d %-16s %s\n " , edit , linenum , buf , p ) ;
}
}
pclose ( ip ) ;
closefilter ( op ) ;
strbuf_close ( ib ) ;
if ( vflag ){
if ( count == 0 )
fprintf ( ( _impure_ptr _stderr -> ) , " object not found " ) ;
if ( count == 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d object located " , count ) ;
if ( count > 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d objects located " , count ) ;
fprintf ( ( _impure_ptr _stderr -> ) , " (using idutils index in \'%s\').\n " , dbpath ) ;
}
}

void grep (pattern, dbpath)
char * pattern ;
char * dbpath ;
{
FILE * ip , * op ;
STRBUF * ib = strbuf_open ( 0 ) ;
char edit [ 512 + 1 ] ;
char * line , * p , * path , * lno ;
int linenum , count , editlen ;
ffformat ( edit , sizeof ( edit ) , pattern ) ;
editlen = strlen ( edit ) ;
do {
unsigned int _length = strlen ( " gtags --find " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " gtags --find " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
if ( lflag )
do {
unsigned int _length = strlen ( localprefix ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , localprefix , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " | xargs grep " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " | xargs grep " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
if ( ! tflag && ! xflag )
do {
unsigned int _length = strlen ( " -l " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " -l " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
else
do {
unsigned int _length = strlen ( " -n " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " -n " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
do {
if ( ! ib alloc_failed -> ){
if ( ib curp -> >= ib endp -> )
__strbuf_expandbuf ( ib , 0 ) ;
* ib curp -> ++ = '\'' ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( pattern ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , pattern , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
do {
if ( ! ib alloc_failed -> ){
if ( ib curp -> >= ib endp -> )
__strbuf_expandbuf ( ib , 0 ) ;
* ib curp -> ++ = '\'' ;
}
} while ( 0 );
do {
unsigned int _length = strlen ( " /dev/null " ) ;
if ( ! ib alloc_failed -> ){
if ( ib curp -> + _length > ib endp -> )
__strbuf_expandbuf ( ib , _length ) ;
strncpy ( ib curp -> , " /dev/null " , _length ) ;
ib curp -> += _length ;
}
} while ( 0 );
if ( debug )
fprintf ( ( _impure_ptr _stderr -> ) , " grep: %s\n " , strbuf_value ( ib ) ) ;
if ( ! ( ip = popen ( strbuf_value ( ib ) , " r " ) ) )
die ( " cannot execute \'%s\'. " , strbuf_value ( ib ) ) ;
if ( ! ( op = openfilter ( openfilter ) ) )
die ( " cannot open output filter. " ) ;
count = 0 ;
while ( ( line = strbuf_fgets ( ib , ip , 2 ) ) != ( ( void * ) 0 ) ){
p = line ;
path = p ;
while ( * p && * p != ':' )
p ++ ;
if ( ( xflag || tflag ) && ! * p )
die ( " illegal grep output format. \'%s\' " , line ) ;
* p ++ = 0 ;
if ( ! xflag && ! tflag ){
fprintf ( op , " %s\n " , path ) ;
continue ;
}
while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) )
p ++ ;
lno = p ;
while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 4 ) )
p ++ ;
if ( * p != ':' )
die ( " illegal grep output format. \'%s\' " , line ) ;
* p ++ = 0 ;
linenum = atoi ( lno ) ;
if ( linenum <= 0 )
die ( " illegal grep output format. \'%s\' " , line ) ;
count ++ ;
if ( tflag )
fprintf ( op , " %s\t%s\t%d\n " , edit , path , linenum ) ;
else if ( ! xflag ){
fprintf ( op , " %s\n " , path ) ;
}
else if ( editlen >= 16 && linenum >= 1000 )
fprintf ( op , " %-16s %4d %-16s %s\n " , edit , linenum , path , p ) ;
else
fprintf ( op , " %-16s%4d %-16s %s\n " , edit , linenum , path , p ) ;
}
pclose ( ip ) ;
closefilter ( op ) ;
strbuf_close ( ib ) ;
if ( vflag ){
if ( count == 0 )
fprintf ( ( _impure_ptr _stderr -> ) , " object not found " ) ;
if ( count == 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d object located " , count ) ;
if ( count > 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d objects located " , count ) ;
fprintf ( ( _impure_ptr _stderr -> ) , " (no index used).\n " ) ;
}
}

void pathlist (dbpath, av)
char * dbpath ;
char * av ;
{
FILE * op ;
char * path , * p ;
regex_t preg ;
int count ;
if ( av ){
if ( regcomp ( & preg , av , 1 ) != 0 )
die ( " illegal regular expression. " ) ;
}
if ( ! localprefix )
localprefix = " ./ " ;
if ( ! ( op = openfilter ( openfilter ) ) )
die ( " cannot open output filter. " ) ;
count = 0 ;
for ( gfindopen ( dbpath , localprefix ) ; ( path = gfindread ( gfindread ) ) != ( ( void * ) 0 ) ; ){
p = path + strlen ( localprefix ) - 1 ;
if ( av && regexec ( & preg , p , 0 , 0 , 0 ) != 0 )
continue ;
if ( xflag )
fprintf ( op , " path\t1 %s \n " , path ) ;
else if ( tflag )
fprintf ( op , " path\t%s\t1\n " , path ) ;
else
fprintf ( op , " %s\n " , path ) ;
count ++ ;
}
gfindclose ( gfindclose ) ;
closefilter ( op ) ;
if ( av )
regfree ( & preg ) ;
if ( vflag ){
if ( count == 0 )
fprintf ( ( _impure_ptr _stderr -> ) , " path not found " ) ;
if ( count == 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d path located " , count ) ;
if ( count > 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d paths located " , count ) ;
fprintf ( ( _impure_ptr _stderr -> ) , " (using \'%s\').\n " , makepath ( dbpath , dbname ( 0 ) , ( ( void * ) 0 ) ) ) ;
}
}

void parsefile (argc, argv, cwd, root, dbpath, db)
int argc ;
char * * argv ;
char * cwd ;
char * root ;
char * dbpath ;
int db ;
{
char buf [ ( 260 - 1 ) + 1 ] , * path ;
char env [ ( 260 - 1 ) + 1 ] ;
char * p ;
FILE * ip , * op ;
char * parser , * av ;
int count ;
STRBUF * sb = strbuf_open ( 0 ) ;
STRBUF * com = strbuf_open ( 0 ) ;
STRBUF * ib = strbuf_open ( 1024 ) ;
snprintf ( env , sizeof ( env ) , " GTAGSDBPATH=%s " , dbpath ) ;
putenv ( env ) ;
if ( ! getconfs ( dbname ( db ) , sb ) )
die ( " cannot get parser for %s. " , dbname ( db ) ) ;
parser = strbuf_value ( sb ) ;
if ( ! ( op = openfilter ( openfilter ) ) )
die ( " cannot open output filter. " ) ;
if ( pathopen ( dbpath , 0 ) < 0 )
die ( " GPATH not found. " ) ;
count = 0 ;
for ( ; argc > 0 ; argv ++ , argc -- ){
av = argv [ 0 ] ;
if ( test ( " d " , av ) ){
fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' is a directory.\n " , av ) ;
continue ;
}
if ( ! test ( " f " , ( ( void * ) 0 ) ) ){
fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' not found.\n " , av ) ;
continue ;
}
path = realpath ( av , buf ) ;
if ( ! isabspath ( path ) )
die ( " realpath(3) is not compatible with BSD version. " ) ;
if ( strncmp ( path , root , strlen ( root ) ) ){
fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' is out of source tree.\n " , path ) ;
continue ;
}
path += strlen ( root ) - 1 ;
* path = '.' ;
if ( ! pathget ( path ) ){
fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' not found in GPATH.\n " , path ) ;
continue ;
}
if ( chdir ( root ) < 0 )
die ( " cannot move to \'%s\' directory. " , root ) ;
do {
com curp -> = com sbuf -> ;
com alloc_failed -> = 0 ;
} while ( 0 );
makecommand ( parser , path , com ) ;
if ( debug )
fprintf ( ( _impure_ptr _stderr -> ) , " executing %s\n " , strbuf_value ( com ) ) ;
if ( ! ( ip = popen ( strbuf_value ( com ) , " r " ) ) )
die ( " cannot execute \'%s\'. " , strbuf_value ( com ) ) ;
while ( ( p = strbuf_fgets ( ib , ip , 2 ) ) != ( ( void * ) 0 ) ){
count ++ ;
printtag ( op , p ) ;
}
pclose ( ip ) ;
if ( chdir ( cwd ) < 0 )
die ( " cannot move to \'%s\' directory. " , cwd ) ;
}
pathclose ( pathclose ) ;
closefilter ( op ) ;
strbuf_close ( sb ) ;
strbuf_close ( com ) ;
strbuf_close ( ib ) ;
if ( vflag ){
if ( count == 0 )
fprintf ( ( _impure_ptr _stderr -> ) , " object not found " ) ;
if ( count == 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d object located " , count ) ;
if ( count > 1 )
fprintf ( ( _impure_ptr _stderr -> ) , " %d objects located " , count ) ;
fprintf ( ( _impure_ptr _stderr -> ) , " (no index used).\n " ) ;
}
}

int search (pattern, root, dbpath, db)
char * pattern ;
char * root ;
char * dbpath ;
int db ;
{
char * p ;
int count = 0 ;
FILE * op ;
GTOP * gtop ;
int flags = 0 ;
gtop = gtagsopen ( dbpath , root , db , 0 , 0 ) ;
if ( ! ( op = openfilter ( openfilter ) ) )
die ( " cannot open output filter. " ) ;
if ( nflag > 1 )
flags |= 4 ;
for ( p = gtagsfirst ( gtop , pattern , flags ) ; p ; p = gtagsnext ( gtop ) ){
if ( lflag ){
char * q ;
q = locatestring ( p , " ./ " , 0 ) ;
if ( ! locatestring ( q , localprefix , 1 ) )
continue ;
}
printtag ( op , p ) ;
count ++ ;
}
closefilter ( op ) ;
gtagsclose ( gtop ) ;
return count ;
}

int includepath (line, path)
char * line ;
char * path ;
{
char * p ;
int length ;
if ( ! ( p = locatestring ( line , " ./ " , 0 ) ) )
die ( " illegal tag format (path not found). " ) ;
length = strlen ( path ) ;
if ( strncmp ( p , path , length ) )
return 0 ;
p += length ;
if ( * p == '\' || * p == '\t' )
return 1 ;
return 0 ;
}

void ffformat (to, size, from)
char * to ;
int size ;
char * from ;
{
char * p , * e = to ;
for ( p = from ; * p ; p ++ ){
if ( * p == '%' || * p == '\' || * p == '\t' ){
if ( size <= 3 )
break ;
snprintf ( e , size , " %%%02x " , * p ) ;
e += 3 ;
size -= 3 ;
}
else {
if ( size <= 1 )
break ;
* e ++ = * p ;
size -- ;
}
}
* e = 0 ;
}