/gondow/xci/src/xci_def.h


  1. extern void * __builtin_next_arg () ;
  2. extern void * __builtin_alloca () ;
  3. extern void * __builtin_apply_args () ;
  4. extern void * __builtin_apply () ;
  5. extern void __builtin_memcpy () ;
  6. typedef void * __builtin_va_list ;
  7. extern void __builtin_stdarg_start () ;
  8. extern void __builtin_va_end () ;
  9. extern int yylex () ;




  10. global.c


  11. typedef int ptrdiff_t ;
  12. typedef unsigned int size_t ;
  13. typedef short unsigned int wchar_t ;
  14. typedef unsigned int wint_t ;
  15. typedef unsigned char u_char ;
  16. typedef unsigned short u_short ;
  17. typedef unsigned int u_int ;
  18. typedef unsigned long u_long ;
  19. typedef unsigned short ushort ;
  20. typedef unsigned int uint ;
  21. typedef long time_t ;
  22. typedef long daddr_t ;
  23. typedef char * caddr_t ;
  24. typedef unsigned long ino_t ;
  25. typedef unsigned long vm_offset_t ;
  26. typedef unsigned long vm_size_t ;
  27. typedef char int8_t ;
  28. typedef unsigned char u_int8_t ;
  29. typedef short int16_t ;
  30. typedef unsigned short u_int16_t ;
  31. typedef int int32_t ;
  32. typedef unsigned int u_int32_t ;
  33. typedef long long int64_t ;
  34. typedef unsigned long long u_int64_t ;
  35. typedef int32_t register_t ;
  36. typedef short dev_t ;
  37. typedef long off_t ;
  38. typedef unsigned short uid_t ;
  39. typedef unsigned short gid_t ;
  40. typedef int pid_t ;
  41. typedef long key_t ;
  42. typedef long ssize_t ;
  43. typedef char * addr_t ;
  44. typedef int mode_t ;
  45. typedef unsigned short nlink_t ;
  46. typedef long fd_mask ;
  47. typedef struct _types_fd_set {
  48.       fd_mask fds_bits [ ( ( ( 64 ) + ( ( ( sizeof ( fd_mask ) * 8 ) ) - 1 ) ) / ( ( sizeof ( fd_mask ) * 8 ) ) ) ] ;
  49.       } _types_fd_set ;
  50. typedef int __int32_t ;
  51. typedef unsigned int __uint32_t ;
  52. typedef unsigned long clock_t ;
  53. struct tm {
  54.       int tm_sec ;
  55.       int tm_min ;
  56.       int tm_hour ;
  57.       int tm_mday ;
  58.       int tm_mon ;
  59.       int tm_year ;
  60.       int tm_wday ;
  61.       int tm_yday ;
  62.       int tm_isdst ;
  63.       } ;
  64. clock_t clock ( void ) ;
  65. double difftime ( time_t _time2 , time_t _time1 ) ;
  66. time_t mktime ( struct tm * _timeptr ) ;
  67. time_t time ( time_t * _timer ) ;
  68. char * asctime ( const struct tm * _tblock ) ;
  69. char * ctime ( const time_t * _time ) ;
  70. struct tm * gmtime ( const time_t * _timer ) ;
  71. struct tm * localtime ( const time_t * _timer ) ;
  72. size_t strftime ( char * _s , size_t _maxsize , const char * _fmt , const struct tm * _t ) ;
  73. char * asctime_r ( const struct tm * , char * ) ;
  74. char * ctime_r ( const time_t * , char * ) ;
  75. struct tm * gmtime_r ( const time_t * , struct tm * ) ;
  76. struct tm * localtime_r ( const time_t * , struct tm * ) ;
  77. extern time_t * __imp__timezone ;
  78. extern int * __imp__daylight ;
  79. extern char * ( ( * __imp__tzname ) [ 2 ] ) ;
  80. char * timezone ( void ) ;
  81. void tzset ( void ) ;
  82. struct stat {
  83.       dev_t st_dev ;
  84.       ino_t st_ino ;
  85.       mode_t st_mode ;
  86.       nlink_t st_nlink ;
  87.       uid_t st_uid ;
  88.       gid_t st_gid ;
  89.       dev_t st_rdev ;
  90.       off_t st_size ;
  91.       time_t st_atime ;
  92.       long st_spare1 ;
  93.       time_t st_mtime ;
  94.       long st_spare2 ;
  95.       time_t st_ctime ;
  96.       long st_spare3 ;
  97.       long st_blksize ;
  98.       long st_blocks ;
  99.       long st_spare4 [ 2 ] ;
  100.       } ;
  101. int chmod ( const char * __path , mode_t __mode ) ;
  102. int fchmod ( int __fd , mode_t __mode ) ;
  103. int fstat ( int __fd , struct stat * __sbuf ) ;
  104. int mkdir ( const char * _path , mode_t __mode ) ;
  105. int mkfifo ( char * __path , mode_t __mode ) ;
  106. int stat ( const char * __path , struct stat * __sbuf ) ;
  107. mode_t umask ( mode_t __mask ) ;
  108. int _fstat ( int __fd , struct stat * __sbuf ) ;
  109. int _stat ( const char * __path , struct stat * __sbuf ) ;
  110. int lstat ( const char * __path , struct stat * __buf ) ;
  111. int isalnum ( int __c ) ;
  112. int isalpha ( int __c ) ;
  113. int iscntrl ( int __c ) ;
  114. int isdigit ( int __c ) ;
  115. int isgraph ( int __c ) ;
  116. int islower ( int __c ) ;
  117. int isprint ( int __c ) ;
  118. int ispunct ( int __c ) ;
  119. int isspace ( int __c ) ;
  120. int isupper ( int __c ) ;
  121. int isxdigit ( int __c ) ;
  122. int tolower ( int __c ) ;
  123. int toupper ( int __c ) ;
  124. int isascii ( int __c ) ;
  125. int toascii ( int __c ) ;
  126. int _tolower ( int __c ) ;
  127. int _toupper ( int __c ) ;
  128. extern const char _ctype_ [ ] ;
  129. typedef void * __gnuc_va_list ;
  130. struct _glue {
  131.       struct _glue * _next ;
  132.       int _niobs ;
  133.       struct __sFILE * _iobs ;
  134.       } ;
  135. struct _Bigint {
  136.       struct _Bigint * _next ;
  137.       int _k _maxwds _sign _wds ;
  138.       unsigned long _x [ 1 ] ;
  139.       } ;
  140. struct _atexit {
  141.       struct _atexit * _next ;
  142.       int _ind ;
  143.       void ( * _fns [ 32 ] ) ( void ) ;
  144.       } ;
  145. struct __sbuf {
  146.       unsigned char * _base ;
  147.       int _size ;
  148.       } ;
  149. typedef long _fpos_t ;
  150. struct __sFILE {
  151.       unsigned char * _p ;
  152.       int _r ;
  153.       int _w ;
  154.       short _flags ;
  155.       short _file ;
  156.       struct __sbuf _bf ;
  157.       int _lbfsize ;
  158.       void * _cookie ;
  159.       int ( * _read ) ( void * _cookie , char * _buf , int _n ) ;
  160.       int ( * _write ) ( void * _cookie , const char * _buf , int _n ) ;
  161.       _fpos_t ( * _seek ) ( void * _cookie , _fpos_t _offset , int _whence ) ;
  162.       int ( * _close ) ( void * _cookie ) ;
  163.       struct __sbuf _ub ;
  164.       unsigned char * _up ;
  165.       int _ur ;
  166.       unsigned char _ubuf [ 3 ] ;
  167.       unsigned char _nbuf [ 1 ] ;
  168.       struct __sbuf _lb ;
  169.       int _blksize ;
  170.       int _offset ;
  171.       struct _reent * _data ;
  172.       } ;
  173. struct _reent {
  174.       int _errno ;
  175.       struct __sFILE * _stdin * _stdout * _stderr ;
  176.       int _inc ;
  177.       char _emergency [ 25 ] ;
  178.       int _current_category ;
  179.       const char * _current_locale ;
  180.       int __sdidinit ;
  181.       void ( * __cleanup ) ( struct _reent * ) ;
  182.       struct _Bigint * _result ;
  183.       int _result_k ;
  184.       struct _Bigint * _p5s ;
  185.       struct _Bigint * * _freelist ;
  186.       int _cvtlen ;
  187.       char * _cvtbuf ;
  188.       unsigned char * _nextf [ 30 ] ;
  189.       unsigned int _nmalloc [ 30 ] ;
  190.       struct _atexit * _atexit ;
  191.       struct _atexit _atexit0 ;
  192.       void ( * * ( _sig_func ) ) ( void ) ;
  193.       struct _glue __sglue ;
  194.       struct __sFILE __sf [ 3 ] ;
  195.       } ;
  196. extern struct _reent * _impure_ptr ;
  197. void _reclaim_reent ( struct _reent * ) ;
  198. typedef _fpos_t fpos_t ;
  199. typedef struct __sFILE FILE ;
  200. int remove ( const char * ) ;
  201. int rename ( const char * , const char * ) ;
  202. char * tempnam ( const char * , const char * ) ;
  203. FILE * tmpfile ( void ) ;
  204. char * tmpnam ( char * ) ;
  205. int fclose ( FILE * ) ;
  206. int fflush ( FILE * ) ;
  207. FILE * freopen ( const char * , const char * , FILE * ) ;
  208. void setbuf ( FILE * , char * ) ;
  209. int setvbuf ( FILE * , char * , int , size_t ) ;
  210. int fprintf ( FILE * , const char * ) ;
  211. int fscanf ( FILE * , const char * ) ;
  212. int printf ( const char * ) ;
  213. int scanf ( const char * ) ;
  214. int sscanf ( const char * , const char * ) ;
  215. int vfprintf ( FILE * , const char * , __gnuc_va_list ) ;
  216. int vprintf ( const char * , __gnuc_va_list ) ;
  217. int vsprintf ( char * , const char * , __gnuc_va_list ) ;
  218. int fgetc ( FILE * ) ;
  219. char * fgets ( char * , int , FILE * ) ;
  220. int fputc ( int , FILE * ) ;
  221. int fputs ( const char * , FILE * ) ;
  222. int getc ( FILE * ) ;
  223. int getchar ( void ) ;
  224. char * gets ( char * ) ;
  225. int putc ( int , FILE * ) ;
  226. int putchar ( int ) ;
  227. int puts ( const char * ) ;
  228. int ungetc ( int , FILE * ) ;
  229. size_t fread ( void * , size_t _size , size_t _n , FILE * ) ;
  230. size_t fwrite ( const void * , size_t _size , size_t _n , FILE * ) ;
  231. int fgetpos ( FILE * , fpos_t * ) ;
  232. int fseek ( FILE * , long , int ) ;
  233. int fsetpos ( FILE * , const fpos_t * ) ;
  234. long ftell ( FILE * ) ;
  235. void rewind ( FILE * ) ;
  236. void clearerr ( FILE * ) ;
  237. int feof ( FILE * ) ;
  238. int ferror ( FILE * ) ;
  239. void perror ( const char * ) ;
  240. FILE * fopen ( const char * _name , const char * _type ) ;
  241. int sprintf ( char * , const char * ) ;
  242. int vfiprintf ( FILE * , const char * , __gnuc_va_list ) ;
  243. int iprintf ( const char * ) ;
  244. int fiprintf ( FILE * , const char * ) ;
  245. int siprintf ( char * , const char * ) ;
  246. FILE * fdopen ( int , const char * ) ;
  247. int fileno ( FILE * ) ;
  248. int getw ( FILE * ) ;
  249. int pclose ( FILE * ) ;
  250. FILE * popen ( const char * , const char * ) ;
  251. int putw ( int , FILE * ) ;
  252. void setbuffer ( FILE * , char * , int ) ;
  253. int setlinebuf ( FILE * ) ;
  254. FILE * _fdopen_r ( struct _reent * , int , const char * ) ;
  255. FILE * _fopen_r ( struct _reent * , const char * , const char * ) ;
  256. int _getchar_r ( struct _reent * ) ;
  257. char * _gets_r ( struct _reent * , char * ) ;
  258. int _iprintf_r ( struct _reent * , const char * ) ;
  259. int _mkstemp_r ( struct _reent * , char * ) ;
  260. char * _mktemp_r ( struct _reent * , char * ) ;
  261. void _perror_r ( struct _reent * , const char * ) ;
  262. int _printf_r ( struct _reent * , const char * ) ;
  263. int _putchar_r ( struct _reent * , int ) ;
  264. int _puts_r ( struct _reent * , const char * ) ;
  265. int _remove_r ( struct _reent * , const char * ) ;
  266. int _rename_r ( struct _reent * , const char * _old , const char * _new ) ;
  267. int _scanf_r ( struct _reent * , const char * ) ;
  268. int _sprintf_r ( struct _reent * , char * , const char * ) ;
  269. char * _tempnam_r ( struct _reent * , char * , char * ) ;
  270. FILE * _tmpfile_r ( struct _reent * ) ;
  271. char * _tmpnam_r ( struct _reent * , char * ) ;
  272. int _vfprintf_r ( struct _reent * , FILE * , const char * , __gnuc_va_list ) ;
  273. int _vprintf_r ( struct _reent * , const char * , __gnuc_va_list ) ;
  274. int _vsprintf_r ( struct _reent * , char * , const char * , __gnuc_va_list ) ;
  275. int __srget ( FILE * ) ;
  276. int __swbuf ( int , FILE * ) ;
  277. 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 ) ) ;
  278. typedef struct {
  279.       int quot ;
  280.       int rem ;
  281.       } div_t ;
  282. typedef struct {
  283.       long quot ;
  284.       long rem ;
  285.       } ldiv_t ;
  286. extern int __mb_cur_max ;
  287. void abort ( void ) ;
  288. int abs ( int ) ;
  289. int atexit ( void ( * __func ) ( void ) ) ;
  290. double atof ( const char * __nptr ) ;
  291. float atoff ( const char * __nptr ) ;
  292. int atoi ( const char * __nptr ) ;
  293. long atol ( const char * __nptr ) ;
  294. void * bsearch ( const void * __key , const void * __base , size_t __nmemb , size_t __size , int ( * _compar ) ( const void * , const void * ) ) ;
  295. void * calloc ( size_t __nmemb , size_t __size ) ;
  296. div_t div ( int __numer , int __denom ) ;
  297. void exit ( int __status ) ;
  298. void free ( void * ) ;
  299. char * getenv ( const char * __string ) ;
  300. long labs ( long ) ;
  301. ldiv_t ldiv ( long __numer , long __denom ) ;
  302. void * malloc ( size_t __size ) ;
  303. int mblen ( const char * , size_t ) ;
  304. int mbtowc ( wchar_t * , const char * , size_t ) ;
  305. int _mbtowc_r ( struct _reent * , wchar_t * , const char * , size_t , int * ) ;
  306. int wctomb ( char * , wchar_t ) ;
  307. int _wctomb_r ( struct _reent * , char * , wchar_t , int * ) ;
  308. size_t mbstowcs ( wchar_t * , const char * , size_t ) ;
  309. size_t _mbstowcs_r ( struct _reent * , wchar_t * , const char * , size_t , int * ) ;
  310. size_t wcstombs ( char * , const wchar_t * , size_t ) ;
  311. size_t _wcstombs_r ( struct _reent * , char * , const wchar_t * , size_t , int * ) ;
  312. void qsort ( void * __base , size_t __nmemb , size_t __size , int ( * _compar ) ( const void * , const void * ) ) ;
  313. int rand ( void ) ;
  314. void * realloc ( void * __r , size_t __size ) ;
  315. void srand ( unsigned __seed ) ;
  316. double strtod ( const char * __n , char * * _end_PTR ) ;
  317. float strtodf ( const char * __n , char * * _end_PTR ) ;
  318. long strtol ( const char * __n , char * * _end_PTR , int __base ) ;
  319. unsigned long strtoul ( const char * _n_PTR , char * * _end_PTR , int __base ) ;
  320. unsigned long _strtoul_r ( struct _reent * , const char * _n_PTR , char * * _end_PTR , int __base ) ;
  321. int system ( const char * __string ) ;
  322. void cfree ( void * ) ;
  323. int putenv ( const char * __string ) ;
  324. int setenv ( const char * __string , const char * __value , int __overwrite ) ;
  325. char * gcvt ( double , int , char * ) ;
  326. char * gcvtf ( float , int , char * ) ;
  327. char * fcvt ( double , int , int * , int * ) ;
  328. char * fcvtf ( float , int , int * , int * ) ;
  329. char * ecvt ( double , int , int * , int * ) ;
  330. char * ecvtbuf ( double , int , int * , int * , char * ) ;
  331. char * fcvtbuf ( double , int , int * , int * , char * ) ;
  332. char * ecvtf ( float , int , int * , int * ) ;
  333. char * dtoa ( double , int , int , int * , int * , char * * ) ;
  334. int rand_r ( unsigned * __seed ) ;
  335. char * realpath ( const char * , char * ) ;
  336. void unsetenv ( const char * __string ) ;
  337. int random ( void ) ;
  338. long srandom ( unsigned __seed ) ;
  339. char * _dtoa_r ( struct _reent * , double , int , int , int * , int * , char * * ) ;
  340. void * _malloc_r ( struct _reent * , size_t ) ;
  341. void * _calloc_r ( struct _reent * , size_t , size_t ) ;
  342. void _free_r ( struct _reent * , void * ) ;
  343. void * _realloc_r ( struct _reent * , void * , size_t ) ;
  344. void _mstats_r ( struct _reent * , char * ) ;
  345. int _system_r ( struct _reent * , const char * ) ;
  346. void __eprintf ( const char * , const char * , unsigned int , const char * ) ;
  347. void * memchr ( const void * , int , size_t ) ;
  348. int memcmp ( const void * , const void * , size_t ) ;
  349. void * memcpy ( void * , const void * , size_t ) ;
  350. void * memmove ( void * , const void * , size_t ) ;
  351. void * memset ( void * , int , size_t ) ;
  352. char * strcat ( char * , const char * ) ;
  353. char * strchr ( const char * , int ) ;
  354. int strcmp ( const char * , const char * ) ;
  355. int strcoll ( const char * , const char * ) ;
  356. char * strcpy ( char * , const char * ) ;
  357. size_t strcspn ( const char * , const char * ) ;
  358. char * strerror ( int ) ;
  359. size_t strlen ( const char * ) ;
  360. char * strncat ( char * , const char * , size_t ) ;
  361. int strncmp ( const char * , const char * , size_t ) ;
  362. char * strncpy ( char * , const char * , size_t ) ;
  363. char * strpbrk ( const char * , const char * ) ;
  364. char * strrchr ( const char * , int ) ;
  365. size_t strspn ( const char * , const char * ) ;
  366. char * strstr ( const char * , const char * ) ;
  367. char * strtok ( char * , const char * ) ;
  368. size_t strxfrm ( char * , const char * , size_t ) ;
  369. char * strtok_r ( char * , const char * , char * * ) ;
  370. int bcmp ( const char * , const char * , size_t ) ;
  371. void bcopy ( const char * , char * , size_t ) ;
  372. void bzero ( char * , size_t ) ;
  373. int ffs ( int ) ;
  374. char * index ( const char * , int ) ;
  375. void * memccpy ( void * , const void * , int , size_t ) ;
  376. char * rindex ( const char * , int ) ;
  377. int strcasecmp ( const char * , const char * ) ;
  378. char * strdup ( const char * ) ;
  379. int strncasecmp ( const char * , const char * , size_t ) ;
  380. char * strsep ( char * * , const char * ) ;
  381. char * strlwr ( char * ) ;
  382. char * strupr ( char * ) ;
  383. char * strsignal ( int __signo ) ;
  384. int strtosigno ( const char * __name ) ;
  385. extern char * * environ ;
  386. void _exit ( int __status ) ;
  387. int access ( const char * __path , int __amode ) ;
  388. unsigned alarm ( unsigned __secs ) ;
  389. int chdir ( const char * __path ) ;
  390. int chmod ( const char * __path , mode_t __mode ) ;
  391. int chown ( const char * __path , uid_t __owner , gid_t __group ) ;
  392. int close ( int __fildes ) ;
  393. char * ctermid ( char * __s ) ;
  394. char * cuserid ( char * __s ) ;
  395. int dup ( int __fildes ) ;
  396. int dup2 ( int __fildes , int __fildes2 ) ;
  397. int execl ( const char * __path , const char * ) ;
  398. int execle ( const char * __path , const char * ) ;
  399. int execlp ( const char * __file , const char * ) ;
  400. int execv ( const char * __path , char *const __argv [ ] ) ;
  401. int execve ( const char * __path , char *const __argv [ ] , char *const __envp [ ] ) ;
  402. int execvp ( const char * __file , char *const __argv [ ] ) ;
  403. pid_t fork ( void ) ;
  404. long fpathconf ( int __fd , int __name ) ;
  405. int fsync ( int __fd ) ;
  406. char * getcwd ( char * __buf , size_t __size ) ;
  407. gid_t getegid ( void ) ;
  408. uid_t geteuid ( void ) ;
  409. gid_t getgid ( void ) ;
  410. int getgroups ( int __gidsetsize , gid_t __grouplist [ ] ) ;
  411. char * getlogin ( void ) ;
  412. size_t getpagesize ( void ) ;
  413. pid_t getpgrp ( void ) ;
  414. pid_t getpid ( void ) ;
  415. pid_t getppid ( void ) ;
  416. uid_t getuid ( void ) ;
  417. int isatty ( int __fildes ) ;
  418. int link ( const char * __path1 , const char * __path2 ) ;
  419. off_t lseek ( int __fildes , off_t __offset , int __whence ) ;
  420. long pathconf ( char * __path , int __name ) ;
  421. int pause ( void ) ;
  422. int pipe ( int __fildes [ 2 ] ) ;
  423. int read ( int __fildes , void * __buf , size_t __nbyte ) ;
  424. int rmdir ( const char * __path ) ;
  425. void * sbrk ( size_t __incr ) ;
  426. int setgid ( gid_t __gid ) ;
  427. int setpgid ( pid_t __pid , pid_t __pgid ) ;
  428. pid_t setsid ( void ) ;
  429. int setuid ( uid_t __uid ) ;
  430. unsigned sleep ( unsigned int __seconds ) ;
  431. void swab ( const void * , void * , ssize_t ) ;
  432. long sysconf ( int __name ) ;
  433. pid_t tcgetpgrp ( int __fildes ) ;
  434. int tcsetpgrp ( int __fildes , pid_t __pgrp_id ) ;
  435. char * ttyname ( int __fildes ) ;
  436. int unlink ( const char * __path ) ;
  437. int write ( int __fildes , const void * __buf , size_t __nbyte ) ;
  438. int _close ( int __fildes ) ;
  439. pid_t _fork ( void ) ;
  440. pid_t _getpid ( void ) ;
  441. int _link ( const char * __path1 , const char * __path2 ) ;
  442. off_t _lseek ( int __fildes , off_t __offset , int __whence ) ;
  443. int _read ( int __fildes , void * __buf , size_t __nbyte ) ;
  444. void * _sbrk ( size_t __incr ) ;
  445. int _unlink ( const char * __path ) ;
  446. int _write ( int __fildes , const void * __buf , size_t __nbyte ) ;
  447. unsigned usleep ( unsigned int __useconds ) ;
  448. int ftruncate ( int __fd , off_t __length ) ;
  449. int truncate ( const char * , off_t __length ) ;
  450. int gethostname ( char * __name , size_t __len ) ;
  451. char * mktemp ( char * ) ;
  452. int sync ( void ) ;
  453. int readlink ( const char * __path , char * __buf , int __buflen ) ;
  454. int symlink ( const char * __name1 , const char * __name2 ) ;
  455. long sysconf ( int __name ) ;
  456. extern char * optarg ;
  457. extern int optind ;
  458. extern int opterr ;
  459. extern int optopt ;
  460. struct option {
  461.       const char * name ;
  462.       int has_arg ;
  463.       int * flag ;
  464.       int val ;
  465.       } ;
  466. extern int getopt () ;
  467. extern int getopt_long ( int argc , char *const * argv , const char * shortopts , const struct option * longopts , int * longind ) ;
  468. extern int getopt_long_only ( int argc , char *const * argv , const char * shortopts , const struct option * longopts , int * longind ) ;
  469. extern int _getopt_internal ( int argc , char *const * argv , const char * shortopts , const struct option * longopts , int * longind , int long_only ) ;
  470. typedef struct _strbuf {
  471.       char * name ;
  472.       char * sbuf ;
  473.       char * endp ;
  474.       char * curp ;
  475.       int sbufsize ;
  476.       int alloc_failed ;
  477.       } STRBUF ;
  478. void __strbuf_expandbuf ( STRBUF * , int ) ;
  479. STRBUF * strbuf_open ( int ) ;
  480. char * strbuf_value ( STRBUF * ) ;
  481. void strbuf_trim ( STRBUF * ) ;
  482. int strbuf_unputc ( STRBUF * , int ) ;
  483. void strbuf_close ( STRBUF * ) ;
  484. char * strbuf_fgets ( STRBUF * , FILE * , int ) ;
  485. char * configpath ( void ) ;
  486. void openconf ( void ) ;
  487. int getconfn ( const char * , int * ) ;
  488. int getconfs ( const char * , STRBUF * ) ;
  489. int getconfb ( const char * ) ;
  490. char * getconfline ( void ) ;
  491. void closeconf ( void ) ;
  492. typedef u_int32_t pgno_t ;
  493. typedef u_int16_t indx_t ;
  494. typedef u_int32_t recno_t ;
  495. typedef struct {
  496.       void * data ;
  497.       size_t size ;
  498.       } DBT ;
  499. typedef enum {
  500.       DB_BTREE,
  501.       DB_HASH,
  502.       DB_RECNO
  503.       } DBTYPE ;
  504. typedef struct __db {
  505.       DBTYPE type ;
  506.       int ( * close ) ( struct __db * ) ;
  507.       int ( * del ) ( const struct __db * , const DBT * , u_int ) ;
  508.       int ( * get ) ( const struct __db * , const DBT * , DBT * , u_int ) ;
  509.       int ( * put ) ( const struct __db * , DBT * , const DBT * , u_int ) ;
  510.       int ( * seq ) ( const struct __db * , DBT * , DBT * , u_int ) ;
  511.       int ( * sync ) ( const struct __db * , u_int ) ;
  512.       void * internal ;
  513.       int ( * fd ) ( const struct __db * ) ;
  514.       } DB ;
  515. typedef struct {
  516.       u_long flags ;
  517.       u_int cachesize ;
  518.       int maxkeypage ;
  519.       int minkeypage ;
  520.       u_int psize ;
  521.       int ( * compare ) ( const DBT * , const DBT * ) ;
  522.       size_t ( * prefix2 ) ( const DBT * , const DBT * ) ;
  523.       int lorder ;
  524.       } BTREEINFO ;
  525. typedef struct {
  526.       u_int bsize ;
  527.       u_int ffactor ;
  528.       u_int nelem ;
  529.       u_int cachesize ;
  530.       u_int32_t ( * hash ) ( const void * , size_t ) ;
  531.       int lorder ;
  532.       } HASHINFO ;
  533. typedef struct {
  534.       u_long flags ;
  535.       u_int cachesize ;
  536.       u_int psize ;
  537.       int lorder ;
  538.       size_t reclen ;
  539.       u_char bval ;
  540.       char * bfname ;
  541.       } RECNOINFO ;
  542. DB * dbopen ( const char * , int , int , DBTYPE , const void * ) ;
  543. DB * __bt_open ( const char * , int , int , const BTREEINFO * , int ) ;
  544. DB * __hash_open ( const char * , int , int , const HASHINFO * , int ) ;
  545. DB * __rec_open ( const char * , int , int , const RECNOINFO * , int ) ;
  546. void __dbpanic ( DB * dbp ) ;
  547. typedef long int s_reg_t ;
  548. typedef unsigned long int active_reg_t ;
  549. typedef unsigned long int reg_syntax_t ;
  550. extern reg_syntax_t re_syntax_options ;
  551. typedef enum {
  552.       REG_NOERROR = 0 ,
  553.       REG_NOMATCH,
  554.       REG_BADPAT,
  555.       REG_ECOLLATE,
  556.       REG_ECTYPE,
  557.       REG_EESCAPE,
  558.       REG_ESUBREG,
  559.       REG_EBRACK,
  560.       REG_EPAREN,
  561.       REG_EBRACE,
  562.       REG_BADBR,
  563.       REG_ERANGE,
  564.       REG_ESPACE,
  565.       REG_BADRPT,
  566.       REG_EEND,
  567.       REG_ESIZE,
  568.       REG_ERPAREN
  569.       } reg_errcode_t ;
  570. struct re_pattern_buffer {
  571.       unsigned char * buffer ;
  572.       unsigned long int allocated ;
  573.       unsigned long int used ;
  574.       reg_syntax_t syntax ;
  575.       char * fastmap ;
  576.       char * translate ;
  577.       size_t re_nsub ;
  578.       unsigned can_be_null : ;
  579.       unsigned regs_allocated : ;
  580.       unsigned fastmap_accurate : ;
  581.       unsigned no_sub : ;
  582.       unsigned not_bol : ;
  583.       unsigned not_eol : ;
  584.       unsigned newline_anchor : ;
  585.       } ;
  586. typedef struct re_pattern_buffer regex_t ;
  587. typedef int regoff_t ;
  588. struct re_registers {
  589.       unsigned num_regs ;
  590.       regoff_t * start ;
  591.       regoff_t * end ;
  592.       } ;
  593. typedef struct {
  594.       regoff_t rm_so ;
  595.       regoff_t rm_eo ;
  596.       } regmatch_t ;
  597. extern reg_syntax_t re_set_syntax ( reg_syntax_t syntax ) ;
  598. extern const char * re_compile_pattern ( const char * pattern , size_t length , struct re_pattern_buffer * buffer ) ;
  599. extern int re_compile_fastmap ( struct re_pattern_buffer * buffer ) ;
  600. extern int re_search ( struct re_pattern_buffer * buffer , const char * string , int length , int start , int range , struct re_registers * regs ) ;
  601. 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 ) ;
  602. extern int re_match ( struct re_pattern_buffer * buffer , const char * string , int length , int start , struct re_registers * regs ) ;
  603. 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 ) ;
  604. extern void re_set_registers ( struct re_pattern_buffer * buffer , struct re_registers * regs , unsigned num_regs , regoff_t * starts , regoff_t * ends ) ;
  605. extern int regcomp ( regex_t * __preg , const char * __pattern , int __cflags ) ;
  606. extern int regexec ( const regex_t * __preg , const char * __string , size_t __nmatch , regmatch_t __pmatch [ ] , int __eflags ) ;
  607. extern size_t regerror ( int __errcode , const regex_t * __preg , char * __errbuf , size_t __errbuf_size ) ;
  608. extern void regfree ( regex_t * __preg ) ;
  609. typedef struct {
  610.       DB * db ;
  611.       char dbname [ ( 260 - 1 ) + 1 ] ;
  612.       char key [ 300 + 1 ] ;
  613.       int keylen ;
  614.       regex_t * preg ;
  615.       char prev [ 300 + 1 ] ;
  616.       char * lastkey ;
  617.       char * lastdat ;
  618.       int openflags ;
  619.       int ioflags ;
  620.       int perm ;
  621.       } DBOP ;
  622. DBOP * dbop_open ( const char * , int , int , int ) ;
  623. char * dbop_get ( DBOP * , const char * ) ;
  624. void dbop_put ( DBOP * , const char * , const char * ) ;
  625. void dbop_del ( DBOP * , const char * ) ;
  626. char * dbop_first ( DBOP * , const char * , regex_t * , int ) ;
  627. char * dbop_next ( DBOP * ) ;
  628. void dbop_close ( DBOP * ) ;
  629. int defined ( const char * ) ;
  630. void va_end ( __gnuc_va_list ) ;
  631. typedef __gnuc_va_list va_list ;
  632. extern const char * progname ;
  633. void die ( const char * s ) ;
  634. int snprintf ( char * s , size_t n , const char * format ) ;
  635. int issource ( char * ) ;
  636. void ffindopen ( void ) ;
  637. char * ffindread ( int * ) ;
  638. void ffindclose ( void ) ;
  639. void gfindopen ( char * , char * ) ;
  640. char * gfindread ( void ) ;
  641. void gfindclose ( void ) ;
  642. int gtagsexist ( char * , char * , int , int ) ;
  643. void getdbpath ( char * , char * , char * , int ) ;
  644. typedef struct {
  645.       DBOP * dbop ;
  646.       int format_version ;
  647.       int format ;
  648.       int mode ;
  649.       int db ;
  650.       int flags ;
  651.       char root [ ( 260 - 1 ) + 1 ] ;
  652.       int opened ;
  653.       char * line ;
  654.       char tag [ 512 + 1 ] ;
  655.       char prev_tag [ 512 + 1 ] ;
  656.       char path [ ( 260 - 1 ) + 1 ] ;
  657.       char prev_path [ ( 260 - 1 ) + 1 ] ;
  658.       STRBUF * sb ;
  659.       STRBUF * ib ;
  660.       FILE * fp ;
  661.       char * lnop ;
  662.       int lno ;
  663.       } GTOP ;
  664. const char * dbname ( int ) ;
  665. void makecommand ( char * , char * , STRBUF * ) ;
  666. int formatcheck ( char * , int ) ;
  667. int notnamechar ( char * ) ;
  668. GTOP * gtagsopen ( char * , char * , int , int , int ) ;
  669. void gtagsput ( GTOP * , char * , char * ) ;
  670. char * gtagsget ( GTOP * , char * ) ;
  671. void gtagsadd ( GTOP * , char * , char * , int ) ;
  672. void gtagsdelete ( GTOP * , char * ) ;
  673. char * gtagsfirst ( GTOP * , char * , int ) ;
  674. char * gtagsnext ( GTOP * ) ;
  675. void gtagsclose ( GTOP * ) ;
  676. char * locatestring ( const char * , const char * , int ) ;
  677. char * makepath ( const char * , const char * , const char * ) ;
  678. int isabspath ( char * ) ;
  679. char * canonpath ( char * ) ;
  680. int pathopen ( const char * , int ) ;
  681. char * pathget ( const char * ) ;
  682. char * pathiget ( int ) ;
  683. void pathput ( const char * ) ;
  684. void pathdel ( const char * ) ;
  685. void pathclose ( void ) ;
  686. int nextkey ( void ) ;
  687. char * strmake ( const char * , const char * ) ;
  688. void settabs ( int ) ;
  689. void detab ( FILE * , char * ) ;
  690. void entab ( char * ) ;
  691. int test ( const char * , const char * ) ;
  692. extern unsigned char * sp , * cp , * lp ;
  693. extern int lineno ;
  694. extern int crflag ;
  695. extern int cmode ;
  696. extern int cppmode ;
  697. extern int ymode ;
  698. extern unsigned char token [ 512 ] ;
  699. extern unsigned char curfile [ ( 260 - 1 ) ] ;
  700. int opentoken ( char * ) ;
  701. void rewindtoken ( void ) ;
  702. void closetoken ( void ) ;
  703. int nexttoken ( const char * , int ( * ) ( char * ) ) ;
  704. void pushbacktoken ( void ) ;
  705. int peekc ( int ) ;
  706. int atfirst_exceptspace ( void ) ;
  707. char * usable ( char * ) ;
  708. extern const char * progname ;
  709. void version ( const char * , const int ) ;
  710. const char * progname = " global " ;
  711. static void usage ( void ) ;
  712. static void help ( void ) ;
  713. static void setcom ( int ) ;
  714. int main ( int , char * * ) ;
  715. void makefilter ( STRBUF * ) ;
  716. FILE * openfilter ( void ) ;
  717. void closefilter ( FILE * ) ;
  718. void completion ( char * , char * , char * ) ;
  719. void relative_filter ( STRBUF * , char * , char * ) ;
  720. void idutils ( char * , char * ) ;
  721. void grep ( char * , char * ) ;
  722. void pathlist ( char * , char * ) ;
  723. void parsefile ( int , char * * , char * , char * , char * , int ) ;
  724. void printtag ( FILE * , char * ) ;
  725. int search ( char * , char * , char * , int ) ;
  726. int includepath ( char * , char * ) ;
  727. void ffformat ( char * , int , char * ) ;
  728. char sort_command [ 1024 + 1 ] ;
  729. char sed_command [ 1024 + 1 ] ;
  730. STRBUF * sortfilter ;
  731. STRBUF * pathfilter ;
  732. char * localprefix ;
  733. int aflag ;
  734. int cflag ;
  735. int fflag ;
  736. int gflag ;
  737. int iflag ;
  738. int Iflag ;
  739. int lflag ;
  740. int nflag ;
  741. int pflag ;
  742. int Pflag ;
  743. int rflag ;
  744. int sflag ;
  745. int tflag ;
  746. int vflag ;
  747. int xflag ;
  748. int show_version ;
  749. int show_help ;
  750. int show_filter ;
  751. int use_tagfiles ;
  752. int debug ;
  753. char * extra_options ;
  754. 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 " ;
  755. 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 " ;


  756. static void usage ()
  757. {
  758.      fputs ( usage_const , ( _impure_ptr _stderr -> ) ) ;
  759.      exit ( 2 ) ;
  760. }




  761. static void help ()
  762. {
  763.      fputs ( usage_const , ( _impure_ptr _stdout -> ) ) ;
  764.      fputs ( help_const , ( _impure_ptr _stdout -> ) ) ;
  765.      exit ( 0 ) ;
  766. }


  767. 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 } } ;
  768. static int command ;


  769. static void setcom (c)
  770.      int c ;
  771. {
  772.      if ( command == 0 )
  773.                command = c ;
  774.      else if ( command != c )
  775.                     usage ( usage ) ;
  776. }




  777. int main (argc, argv)
  778.      int argc ;
  779.      char * argv [ ] ;
  780. {
  781.      char * av ;
  782.      int count ;
  783.      int db ;
  784.      int optchar ;
  785.      int option_index = 0 ;
  786.      char cwd [ ( 260 - 1 ) + 1 ] ;
  787.      char root [ ( 260 - 1 ) + 1 ] ;
  788.      char dbpath [ ( 260 - 1 ) + 1 ] ;
  789.      while ( ( optchar = getopt_long ( argc , argv , " acfgGiIlnpPrstvx " , long_options , & option_index ) ) != ( - 1 ) ){
  790.                switch ( optchar ){
  791.                     case 0 :
  792.                          if ( ! strcmp ( " idutils " , long_options [ option_index ] name . ) )
  793.                                         extra_options = optarg ;
  794.                          break ;
  795.                     case 'a' :
  796.                          aflag ++ ;
  797.                          break ;
  798.                     case 'c' :
  799.                          cflag ++ ;
  800.                          setcom ( optchar ) ;
  801.                          break ;
  802.                     case 'f' :
  803.                          fflag ++ ;
  804.                          xflag ++ ;
  805.                          setcom ( optchar ) ;
  806.                          break ;
  807.                     case 'l' :
  808.                          lflag ++ ;
  809.                          break ;
  810.                     case 'n' :
  811.                          nflag ++ ;
  812.                          break ;
  813.                     case 'g' :
  814.                          gflag ++ ;
  815.                          setcom ( optchar ) ;
  816.                          break ;
  817.                     case 'i' :
  818.                          iflag ++ ;
  819.                          setcom ( optchar ) ;
  820.                          break ;
  821.                     case 'I' :
  822.                          Iflag ++ ;
  823.                          setcom ( optchar ) ;
  824.                          break ;
  825.                     case 'p' :
  826.                          pflag ++ ;
  827.                          setcom ( optchar ) ;
  828.                          break ;
  829.                     case 'P' :
  830.                          Pflag ++ ;
  831.                          setcom ( optchar ) ;
  832.                          break ;
  833.                     case 'r' :
  834.                          rflag ++ ;
  835.                          break ;
  836.                     case 's' :
  837.                          sflag ++ ;
  838.                          break ;
  839.                     case 't' :
  840.                          tflag ++ ;
  841.                          break ;
  842.                     case 'v' :
  843.                          vflag ++ ;
  844.                          break ;
  845.                     case 'x' :
  846.                          xflag ++ ;
  847.                          break ;
  848.                     default :
  849.                          usage ( usage ) ;
  850.                          break ;
  851.                     }
  852.           }
  853.      if ( show_help )
  854.                help ( help ) ;
  855.      argc -= optind ;
  856.      argv += optind ;
  857.      av = ( argc > 0 ) ? * argv : ( ( void * ) 0 ) ;
  858.      if ( show_version )
  859.                version ( av , vflag ) ;
  860.      if ( sflag && rflag )
  861.                die ( " both of -s and -r are not allowed. " ) ;
  862.      if ( ! av && ! show_filter ){
  863.                switch ( command ){
  864.                     case 'c' :
  865.                          case 'i' :
  866.                               case 'p' :
  867.                                    case 'P' :
  868.                                         break ;
  869.                     default :
  870.                          usage ( usage ) ;
  871.                          break ;
  872.                     }
  873.           }
  874.      if ( av ){
  875.                switch ( command ){
  876.                     case 'i' :
  877.                          case 'p' :
  878.                               usage ( usage ) ;
  879.                     default :
  880.                          break ;
  881.                     }
  882.           }
  883.      if ( fflag )
  884.                lflag = 0 ;
  885.      if ( ! Iflag && ! gflag && av )
  886.                for ( ; * av == '\' || * av == '\t' ; av ++ )
  887.                     ;
  888.      if ( cflag && av && notnamechar ( av ) )
  889.                die ( " only name char is allowed with -c option. " ) ;
  890.      getdbpath ( cwd , root , dbpath , ( pflag && vflag ) ) ;
  891.      if ( Iflag && strcmp ( root , dbpath ) )
  892.                die ( " You must have idutils\'s index at the root of source tree. " ) ;
  893.      if ( pflag ){
  894.                char * dir = ( rflag ) ? root : dbpath ;
  895.                fprintf ( ( _impure_ptr _stdout -> ) , " %s\n " , dir ) ;
  896.                exit ( 0 ) ;
  897.           }
  898.      if ( iflag ){
  899.                STRBUF * sb = strbuf_open ( 0 ) ;
  900.                if ( chdir ( root ) < 0 )
  901.                          die ( " cannot change directory to \'%s\'. " , root ) ;
  902.                do {
  903.                          unsigned int _length = strlen ( " gtags -i " ) ;
  904.                          if ( ! sb alloc_failed -> ){
  905.                                    if ( sb curp -> + _length > sb endp -> )
  906.                                              __strbuf_expandbuf ( sb , _length ) ;
  907.                                    strncpy ( sb curp -> , " gtags -i " , _length ) ;
  908.                                    sb curp -> += _length ;
  909.                               }
  910.                    
  911.                     } while ( 0 );
  912.                if ( vflag )
  913.                          do {
  914.                               if ( ! sb alloc_failed -> ){
  915.                                         if ( sb curp -> >= sb endp -> )
  916.                                                   __strbuf_expandbuf ( sb , 0 ) ;
  917.                                         * sb curp -> ++ = 'v' ;
  918.                                    }
  919.                         
  920.                          } while ( 0 );
  921.                do {
  922.                          if ( ! sb alloc_failed -> ){
  923.                                    if ( sb curp -> >= sb endp -> )
  924.                                              __strbuf_expandbuf ( sb , 0 ) ;
  925.                                    * sb curp -> ++ = '\' ;
  926.                               }
  927.                    
  928.                     } while ( 0 );
  929.                do {
  930.                          unsigned int _length = strlen ( dbpath ) ;
  931.                          if ( ! sb alloc_failed -> ){
  932.                                    if ( sb curp -> + _length > sb endp -> )
  933.                                              __strbuf_expandbuf ( sb , _length ) ;
  934.                                    strncpy ( sb curp -> , dbpath , _length ) ;
  935.                                    sb curp -> += _length ;
  936.                               }
  937.                    
  938.                     } while ( 0 );
  939.                if ( system ( strbuf_value ( sb ) ) )
  940.                          exit ( 1 ) ;
  941.                strbuf_close ( sb ) ;
  942.                exit ( 0 ) ;
  943.           }
  944.      if ( cflag ){
  945.                completion ( dbpath , root , av ) ;
  946.                exit ( 0 ) ;
  947.           }
  948.     
  949.           STRBUF * sb = strbuf_open ( 0 ) ;
  950.           if ( ! getconfs ( " sort_command " , sb ) )
  951.                     die ( " cannot get sort command name. " ) ;
  952.           if ( ! locatestring ( strbuf_value ( sb ) , " .exe " , 2 ) )
  953.                     do {
  954.                          unsigned int _length = strlen ( " .exe " ) ;
  955.                          if ( ! sb alloc_failed -> ){
  956.                                    if ( sb curp -> + _length > sb endp -> )
  957.                                              __strbuf_expandbuf ( sb , _length ) ;
  958.                                    strncpy ( sb curp -> , " .exe " , _length ) ;
  959.                                    sb curp -> += _length ;
  960.                               }
  961.                    
  962.                     } while ( 0 );
  963.           strcpy ( sort_command , strbuf_value ( sb ) ) ;
  964.           do {
  965.                     sb curp -> = sb sbuf -> ;
  966.                     sb alloc_failed -> = 0 ;
  967.               
  968.                } while ( 0 );
  969.           if ( ! getconfs ( " sed_command " , sb ) )
  970.                     die ( " cannot get sed command name. " ) ;
  971.           if ( ! locatestring ( strbuf_value ( sb ) , " .exe " , 2 ) )
  972.                     do {
  973.                          unsigned int _length = strlen ( " .exe " ) ;
  974.                          if ( ! sb alloc_failed -> ){
  975.                                    if ( sb curp -> + _length > sb endp -> )
  976.                                              __strbuf_expandbuf ( sb , _length ) ;
  977.                                    strncpy ( sb curp -> , " .exe " , _length ) ;
  978.                                    sb curp -> += _length ;
  979.                               }
  980.                    
  981.                     } while ( 0 );
  982.           strcpy ( sed_command , strbuf_value ( sb ) ) ;
  983.           strbuf_close ( sb ) ;
  984.      }
  985.      if ( lflag ){
  986.                char * p = cwd + strlen ( root ) ;
  987.                STRBUF * sb = strbuf_open ( 0 ) ;
  988.                do {
  989.                          if ( ! sb alloc_failed -> ){
  990.                                    if ( sb curp -> >= sb endp -> )
  991.                                              __strbuf_expandbuf ( sb , 0 ) ;
  992.                                    * sb curp -> ++ = '.' ;
  993.                               }
  994.                    
  995.                     } while ( 0 );
  996.                if ( * p )
  997.                          do {
  998.                               unsigned int _length = strlen ( p ) ;
  999.                               if ( ! sb alloc_failed -> ){
  1000.                                         if ( sb curp -> + _length > sb endp -> )
  1001.                                                   __strbuf_expandbuf ( sb , _length ) ;
  1002.                                         strncpy ( sb curp -> , p , _length ) ;
  1003.                                         sb curp -> += _length ;
  1004.                                    }
  1005.                         
  1006.                          } while ( 0 );
  1007.                do {
  1008.                          if ( ! sb alloc_failed -> ){
  1009.                                    if ( sb curp -> >= sb endp -> )
  1010.                                              __strbuf_expandbuf ( sb , 0 ) ;
  1011.                                    * sb curp -> ++ = '/' ;
  1012.                               }
  1013.                    
  1014.                     } while ( 0 );
  1015.                localprefix = strdup ( strbuf_value ( sb ) ) ;
  1016.                if ( ! localprefix )
  1017.                          die ( " short of memory. " ) ;
  1018.                strbuf_close ( sb ) ;
  1019.           }
  1020.      else {
  1021.                localprefix = ( ( void * ) 0 ) ;
  1022.           }
  1023.      sortfilter = strbuf_open ( 0 ) ;
  1024.      do {
  1025.                unsigned int _length = strlen ( sort_command ) ;
  1026.                if ( ! sortfilter alloc_failed -> ){
  1027.                          if ( sortfilter curp -> + _length > sortfilter endp -> )
  1028.                                    __strbuf_expandbuf ( sortfilter , _length ) ;
  1029.                          strncpy ( sortfilter curp -> , sort_command , _length ) ;
  1030.                          sortfilter curp -> += _length ;
  1031.                     }
  1032.          
  1033.           } while ( 0 );
  1034.      do {
  1035.                if ( ! sortfilter alloc_failed -> ){
  1036.                          if ( sortfilter curp -> >= sortfilter endp -> )
  1037.                                    __strbuf_expandbuf ( sortfilter , 0 ) ;
  1038.                          * sortfilter curp -> ++ = '\' ;
  1039.                     }
  1040.          
  1041.           } while ( 0 );
  1042.      if ( tflag )
  1043.                do {
  1044.                     unsigned int _length = strlen ( " +0 -1 +1 -2 +2n -3 " ) ;
  1045.                     if ( ! sortfilter alloc_failed -> ){
  1046.                               if ( sortfilter curp -> + _length > sortfilter endp -> )
  1047.                                         __strbuf_expandbuf ( sortfilter , _length ) ;
  1048.                               strncpy ( sortfilter curp -> , " +0 -1 +1 -2 +2n -3 " , _length ) ;
  1049.                               sortfilter curp -> += _length ;
  1050.                          }
  1051.               
  1052.                } while ( 0 );
  1053.      else if ( fflag )
  1054.                do {
  1055.                     unsigned int _length = 0 ;
  1056.                     if ( ! sortfilter alloc_failed -> ){
  1057.                               if ( _length < ( sortfilter curp -> - sortfilter sbuf -> ) )
  1058.                                    sortfilter curp -> = sortfilter sbuf -> + _length ;
  1059.                               else if ( _length > ( sortfilter curp -> - sortfilter sbuf -> ) )
  1060.                                         __strbuf_expandbuf ( sortfilter , _length - ( sortfilter curp -> - sortfilter sbuf -> ) ) ;
  1061.                          }
  1062.               
  1063.                } while ( 0 );
  1064.      else if ( xflag )
  1065.                do {
  1066.                     unsigned int _length = strlen ( " +0 -1 +2 -3 +1n -2 " ) ;
  1067.                     if ( ! sortfilter alloc_failed -> ){
  1068.                               if ( sortfilter curp -> + _length > sortfilter endp -> )
  1069.                                         __strbuf_expandbuf ( sortfilter , _length ) ;
  1070.                               strncpy ( sortfilter curp -> , " +0 -1 +2 -3 +1n -2 " , _length ) ;
  1071.                               sortfilter curp -> += _length ;
  1072.                          }
  1073.               
  1074.                } while ( 0 );
  1075.      else
  1076.                do {
  1077.                     unsigned int _length = strlen ( " -u " ) ;
  1078.                     if ( ! sortfilter alloc_failed -> ){
  1079.                               if ( sortfilter curp -> + _length > sortfilter endp -> )
  1080.                                         __strbuf_expandbuf ( sortfilter , _length ) ;
  1081.                               strncpy ( sortfilter curp -> , " -u " , _length ) ;
  1082.                               sortfilter curp -> += _length ;
  1083.                          }
  1084.               
  1085.                } while ( 0 );
  1086.      pathfilter = strbuf_open ( 0 ) ;
  1087.      if ( aflag ){
  1088.                do {
  1089.                          unsigned int _length = strlen ( sed_command ) ;
  1090.                          if ( ! pathfilter alloc_failed -> ){
  1091.                                    if ( pathfilter curp -> + _length > pathfilter endp -> )
  1092.                                              __strbuf_expandbuf ( pathfilter , _length ) ;
  1093.                                    strncpy ( pathfilter curp -> , sed_command , _length ) ;
  1094.                                    pathfilter curp -> += _length ;
  1095.                               }
  1096.                    
  1097.                     } while ( 0 );
  1098.                do {
  1099.                          if ( ! pathfilter alloc_failed -> ){
  1100.                                    if ( pathfilter curp -> >= pathfilter endp -> )
  1101.                                              __strbuf_expandbuf ( pathfilter , 0 ) ;
  1102.                                    * pathfilter curp -> ++ = '\' ;
  1103.                               }
  1104.                    
  1105.                     } while ( 0 );
  1106.                do {
  1107.                          unsigned int _length = strlen ( " -e \"s@\\.@ " ) ;
  1108.                          if ( ! pathfilter alloc_failed -> ){
  1109.                                    if ( pathfilter curp -> + _length > pathfilter endp -> )
  1110.                                              __strbuf_expandbuf ( pathfilter , _length ) ;
  1111.                                    strncpy ( pathfilter curp -> , " -e \"s@\\.@ " , _length ) ;
  1112.                                    pathfilter curp -> += _length ;
  1113.                               }
  1114.                    
  1115.                     } while ( 0 );
  1116.                do {
  1117.                          unsigned int _length = strlen ( root ) ;
  1118.                          if ( ! pathfilter alloc_failed -> ){
  1119.                                    if ( pathfilter curp -> + _length > pathfilter endp -> )
  1120.                                              __strbuf_expandbuf ( pathfilter , _length ) ;
  1121.                                    strncpy ( pathfilter curp -> , root , _length ) ;
  1122.                                    pathfilter curp -> += _length ;
  1123.                               }
  1124.                    
  1125.                     } while ( 0 );
  1126.                do {
  1127.                          unsigned int _length = strlen ( " @\" " ) ;
  1128.                          if ( ! pathfilter alloc_failed -> ){
  1129.                                    if ( pathfilter curp -> + _length > pathfilter endp -> )
  1130.                                              __strbuf_expandbuf ( pathfilter , _length ) ;
  1131.                                    strncpy ( pathfilter curp -> , " @\" " , _length ) ;
  1132.                                    pathfilter curp -> += _length ;
  1133.                               }
  1134.                    
  1135.                     } while ( 0 );
  1136.           }
  1137.      else if ( lflag ){
  1138.                do {
  1139.                          unsigned int _length = strlen ( sed_command ) ;
  1140.                          if ( ! pathfilter alloc_failed -> ){
  1141.                                    if ( pathfilter curp -> + _length > pathfilter endp -> )
  1142.                                              __strbuf_expandbuf ( pathfilter , _length ) ;
  1143.                                    strncpy ( pathfilter curp -> , sed_command , _length ) ;
  1144.                                    pathfilter curp -> += _length ;
  1145.                               }
  1146.                    
  1147.                     } while ( 0 );
  1148.                do {
  1149.                          if ( ! pathfilter alloc_failed -> ){
  1150.                                    if ( pathfilter curp -> >= pathfilter endp -> )
  1151.                                              __strbuf_expandbuf ( pathfilter , 0 ) ;
  1152.                                    * pathfilter curp -> ++ = '\' ;
  1153.                               }
  1154.                    
  1155.                     } while ( 0 );
  1156.                do {
  1157.                          unsigned int _length = strlen ( " -e \"s@\\ " ) ;
  1158.                          if ( ! pathfilter alloc_failed -> ){
  1159.                                    if ( pathfilter curp -> + _length > pathfilter endp -> )
  1160.                                              __strbuf_expandbuf ( pathfilter , _length ) ;
  1161.                                    strncpy ( pathfilter curp -> , " -e \"s@\\ " , _length ) ;
  1162.                                    pathfilter curp -> += _length ;
  1163.                               }
  1164.                    
  1165.                     } while ( 0 );
  1166.                do {
  1167.                          unsigned int _length = strlen ( localprefix ) ;
  1168.                          if ( ! pathfilter alloc_failed -> ){
  1169.                                    if ( pathfilter curp -> + _length > pathfilter endp -> )
  1170.                                              __strbuf_expandbuf ( pathfilter , _length ) ;
  1171.                                    strncpy ( pathfilter curp -> , localprefix , _length ) ;
  1172.                                    pathfilter curp -> += _length ;
  1173.                               }
  1174.                    
  1175.                     } while ( 0 );
  1176.                do {
  1177.                          unsigned int _length = strlen ( " @@\" " ) ;
  1178.                          if ( ! pathfilter alloc_failed -> ){
  1179.                                    if ( pathfilter curp -> + _length > pathfilter endp -> )
  1180.                                              __strbuf_expandbuf ( pathfilter , _length ) ;
  1181.                                    strncpy ( pathfilter curp -> , " @@\" " , _length ) ;
  1182.                                    pathfilter curp -> += _length ;
  1183.                               }
  1184.                    
  1185.                     } while ( 0 );
  1186.           }
  1187.      else {
  1188.                relative_filter ( pathfilter , root , cwd ) ;
  1189.           }
  1190.      if ( show_filter ){
  1191.                STRBUF * sb = strbuf_open ( 0 ) ;
  1192.                makefilter ( sb ) ;
  1193.                fprintf ( ( _impure_ptr _stdout -> ) , " %s\n " , strbuf_value ( sb ) ) ;
  1194.                strbuf_close ( sb ) ;
  1195.                exit ( 0 ) ;
  1196.           }
  1197.      if ( Iflag ){
  1198.                if ( ! usable ( " gid " ) )
  1199.                          die ( " gid(idutils) not found. " ) ;
  1200.                chdir ( root ) ;
  1201.                idutils ( av , dbpath ) ;
  1202.                exit ( 0 ) ;
  1203.           }
  1204.      if ( gflag ){
  1205.                chdir ( root ) ;
  1206.                grep ( av , dbpath ) ;
  1207.                exit ( 0 ) ;
  1208.           }
  1209.      if ( Pflag ){
  1210.                pathlist ( dbpath , av ) ;
  1211.                exit ( 0 ) ;
  1212.           }
  1213.      db = ( rflag ) ? 2 : ( ( sflag ) ? 3 : 1 ) ;
  1214.      if ( fflag ){
  1215.                parsefile ( argc , argv , cwd , root , dbpath , db ) ;
  1216.                exit ( 0 ) ;
  1217.           }
  1218.      count = search ( av , root , dbpath , db ) ;
  1219.      if ( count == 0 && ! lflag && ! rflag && ! sflag && ! notnamechar ( av ) && getenv ( " GTAGSLIBPATH " ) ){
  1220.                char buf [ 1024 + 1 ] ;
  1221.                char libdbpath [ ( 260 - 1 ) + 1 ] ;
  1222.                char * p , * lib ;
  1223.                strcpy ( buf , getenv ( " GTAGSLIBPATH " ) ) ;
  1224.                p = buf ;
  1225.                while ( p ){
  1226.                          lib = p ;
  1227.                          if ( ( p = locatestring ( p , " : " , 0 ) ) != ( ( void * ) 0 ) )
  1228.                                    * p ++ = 0 ;
  1229.                          if ( ! gtagsexist ( lib , libdbpath , sizeof ( libdbpath ) , 0 ) )
  1230.                                    continue ;
  1231.                          if ( ! strcmp ( dbpath , libdbpath ) )
  1232.                                    continue ;
  1233.                          if ( aflag ){
  1234.                                    do {
  1235.                                              pathfilter curp -> = pathfilter sbuf -> ;
  1236.                                              pathfilter alloc_failed -> = 0 ;
  1237.                                        
  1238.                                         } while ( 0 );
  1239.                                    do {
  1240.                                              unsigned int _length = strlen ( sed_command ) ;
  1241.                                              if ( ! pathfilter alloc_failed -> ){
  1242.                                                        if ( pathfilter curp -> + _length > pathfilter endp -> )
  1243.                                                                  __strbuf_expandbuf ( pathfilter , _length ) ;
  1244.                                                        strncpy ( pathfilter curp -> , sed_command , _length ) ;
  1245.                                                        pathfilter curp -> += _length ;
  1246.                                                   }
  1247.                                        
  1248.                                         } while ( 0 );
  1249.                                    do {
  1250.                                              if ( ! pathfilter alloc_failed -> ){
  1251.                                                        if ( pathfilter curp -> >= pathfilter endp -> )
  1252.                                                                  __strbuf_expandbuf ( pathfilter , 0 ) ;
  1253.                                                        * pathfilter curp -> ++ = '\' ;
  1254.                                                   }
  1255.                                        
  1256.                                         } while ( 0 );
  1257.                                    do {
  1258.                                              unsigned int _length = strlen ( " -e \"s@\\.@ " ) ;
  1259.                                              if ( ! pathfilter alloc_failed -> ){
  1260.                                                        if ( pathfilter curp -> + _length > pathfilter endp -> )
  1261.                                                                  __strbuf_expandbuf ( pathfilter , _length ) ;
  1262.                                                        strncpy ( pathfilter curp -> , " -e \"s@\\.@ " , _length ) ;
  1263.                                                        pathfilter curp -> += _length ;
  1264.                                                   }
  1265.                                        
  1266.                                         } while ( 0 );
  1267.                                    do {
  1268.                                              unsigned int _length = strlen ( lib ) ;
  1269.                                              if ( ! pathfilter alloc_failed -> ){
  1270.                                                        if ( pathfilter curp -> + _length > pathfilter endp -> )
  1271.                                                                  __strbuf_expandbuf ( pathfilter , _length ) ;
  1272.                                                        strncpy ( pathfilter curp -> , lib , _length ) ;
  1273.                                                        pathfilter curp -> += _length ;
  1274.                                                   }
  1275.                                        
  1276.                                         } while ( 0 );
  1277.                                    do {
  1278.                                              unsigned int _length = strlen ( " @\" " ) ;
  1279.                                              if ( ! pathfilter alloc_failed -> ){
  1280.                                                        if ( pathfilter curp -> + _length > pathfilter endp -> )
  1281.                                                                  __strbuf_expandbuf ( pathfilter , _length ) ;
  1282.                                                        strncpy ( pathfilter curp -> , " @\" " , _length ) ;
  1283.                                                        pathfilter curp -> += _length ;
  1284.                                                   }
  1285.                                        
  1286.                                         } while ( 0 );
  1287.                               }
  1288.                               else {
  1289.                                    do {
  1290.                                              pathfilter curp -> = pathfilter sbuf -> ;
  1291.                                              pathfilter alloc_failed -> = 0 ;
  1292.                                        
  1293.                                         } while ( 0 );
  1294.                                    relative_filter ( pathfilter , lib , cwd ) ;
  1295.                               }
  1296.                          count = search ( av , lib , libdbpath , db ) ;
  1297.                          if ( count > 0 ){
  1298.                                    strcpy ( dbpath , libdbpath ) ;
  1299.                                    break ;
  1300.                               }
  1301.                     }
  1302.           }
  1303.      if ( vflag ){
  1304.                if ( count ){
  1305.                          if ( count == 1 )
  1306.                                    fprintf ( ( _impure_ptr _stderr -> ) , " %d object located " , count ) ;
  1307.                          if ( count > 1 )
  1308.                                    fprintf ( ( _impure_ptr _stderr -> ) , " %d objects located " , count ) ;
  1309.                     }
  1310.                     else {
  1311.                          fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' not found " , av ) ;
  1312.                     }
  1313.                fprintf ( ( _impure_ptr _stderr -> ) , " (using \'%s\').\n " , makepath ( dbpath , dbname ( db ) , ( ( void * ) 0 ) ) ) ;
  1314.           }
  1315.      strbuf_close ( sortfilter ) ;
  1316.      strbuf_close ( pathfilter ) ;
  1317.      return 0 ;
  1318. }




  1319. void makefilter (sb)
  1320.      STRBUF * sb ;
  1321. {
  1322.      if ( ! nflag ){
  1323.                do {
  1324.                          unsigned int _length = strlen ( strbuf_value ( sortfilter ) ) ;
  1325.                          if ( ! sb alloc_failed -> ){
  1326.                                    if ( sb curp -> + _length > sb endp -> )
  1327.                                              __strbuf_expandbuf ( sb , _length ) ;
  1328.                                    strncpy ( sb curp -> , strbuf_value ( sortfilter ) , _length ) ;
  1329.                                    sb curp -> += _length ;
  1330.                               }
  1331.                    
  1332.                     } while ( 0 );
  1333.                if ( ( sortfilter curp -> - sortfilter sbuf -> ) && ( pathfilter curp -> - pathfilter sbuf -> ) )
  1334.                          do {
  1335.                               unsigned int _length = strlen ( " | " ) ;
  1336.                               if ( ! sb alloc_failed -> ){
  1337.                                         if ( sb curp -> + _length > sb endp -> )
  1338.                                                   __strbuf_expandbuf ( sb , _length ) ;
  1339.                                         strncpy ( sb curp -> , " | " , _length ) ;
  1340.                                         sb curp -> += _length ;
  1341.                                    }
  1342.                         
  1343.                          } while ( 0 );
  1344.                do {
  1345.                          unsigned int _length = strlen ( strbuf_value ( pathfilter ) ) ;
  1346.                          if ( ! sb alloc_failed -> ){
  1347.                                    if ( sb curp -> + _length > sb endp -> )
  1348.                                              __strbuf_expandbuf ( sb , _length ) ;
  1349.                                    strncpy ( sb curp -> , strbuf_value ( pathfilter ) , _length ) ;
  1350.                                    sb curp -> += _length ;
  1351.                               }
  1352.                    
  1353.                     } while ( 0 );
  1354.           }
  1355. }




  1356. FILE * openfilter ( void )
  1357. {
  1358.      FILE * op ;
  1359.      STRBUF * sb = strbuf_open ( 0 ) ;
  1360.      makefilter ( sb ) ;
  1361.      if ( ( sb curp -> - sb sbuf -> ) == 0 )
  1362.                op = ( _impure_ptr _stdout -> ) ;
  1363.      else
  1364.                op = popen ( strbuf_value ( sb ) , " w " ) ;
  1365.      strbuf_close ( sb ) ;
  1366.      return op ;
  1367. }




  1368. void closefilter (op)
  1369.      FILE * op ;
  1370. {
  1371.      if ( op != ( _impure_ptr _stdout -> ) )
  1372.                pclose ( op ) ;
  1373. }




  1374. void completion (dbpath, root, prefix)
  1375.      char * dbpath ;
  1376.      char * root ;
  1377.      char * prefix ;
  1378. {
  1379.      char * p ;
  1380.      int flags = 1 ;
  1381.      GTOP * gtop ;
  1382.      int db ;
  1383.      flags |= 8 ;
  1384.      if ( prefix && * prefix == 0 )
  1385.                prefix = ( ( void * ) 0 ) ;
  1386.      if ( prefix )
  1387.                flags |= 2 ;
  1388.      db = ( sflag ) ? 3 : 1 ;
  1389.      gtop = gtagsopen ( dbpath , root , db , 0 , 0 ) ;
  1390.      for ( p = gtagsfirst ( gtop , prefix , flags ) ; p ; p = gtagsnext ( gtop ) )
  1391.                ( void ) fprintf ( ( _impure_ptr _stdout -> ) , " %s\n " , p ) ;
  1392.      gtagsclose ( gtop ) ;
  1393. }




  1394. void relative_filter (sb, root, cwd)
  1395.      STRBUF * sb ;
  1396.      char * root ;
  1397.      char * cwd ;
  1398. {
  1399.      char * p , * c , * branch ;
  1400.      branch = cwd ;
  1401.      for ( p = root , c = cwd ; * p && * c && * p == * c ; p ++ , c ++ )
  1402.                if ( * c == '/' )
  1403.                     branch = c ;
  1404.      if ( * p == 0 && ( * c == 0 || * c == '/' ) )
  1405.                branch = c ;
  1406.      do {
  1407.                unsigned int _length = strlen ( sed_command ) ;
  1408.                if ( ! sb alloc_failed -> ){
  1409.                          if ( sb curp -> + _length > sb endp -> )
  1410.                                    __strbuf_expandbuf ( sb , _length ) ;
  1411.                          strncpy ( sb curp -> , sed_command , _length ) ;
  1412.                          sb curp -> += _length ;
  1413.                     }
  1414.          
  1415.           } while ( 0 );
  1416.      do {
  1417.                if ( ! sb alloc_failed -> ){
  1418.                          if ( sb curp -> >= sb endp -> )
  1419.                                    __strbuf_expandbuf ( sb , 0 ) ;
  1420.                          * sb curp -> ++ = '\' ;
  1421.                     }
  1422.          
  1423.           } while ( 0 );
  1424.      do {
  1425.                unsigned int _length = strlen ( " -e \"s@\\./@ " ) ;
  1426.                if ( ! sb alloc_failed -> ){
  1427.                          if ( sb curp -> + _length > sb endp -> )
  1428.                                    __strbuf_expandbuf ( sb , _length ) ;
  1429.                          strncpy ( sb curp -> , " -e \"s@\\./@ " , _length ) ;
  1430.                          sb curp -> += _length ;
  1431.                     }
  1432.          
  1433.           } while ( 0 );
  1434.      for ( c = branch ; * c ; c ++ )
  1435.                if ( * c == '/' )
  1436.                     do {
  1437.                          unsigned int _length = strlen ( " ../ " ) ;
  1438.                          if ( ! sb alloc_failed -> ){
  1439.                                    if ( sb curp -> + _length > sb endp -> )
  1440.                                              __strbuf_expandbuf ( sb , _length ) ;
  1441.                                    strncpy ( sb curp -> , " ../ " , _length ) ;
  1442.                                    sb curp -> += _length ;
  1443.                               }
  1444.                    
  1445.                     } while ( 0 );
  1446.      p = root + ( branch - cwd ) ;
  1447.      if ( * p ){
  1448.                p ++ ;
  1449.                do {
  1450.                          unsigned int _length = strlen ( p ) ;
  1451.                          if ( ! sb alloc_failed -> ){
  1452.                                    if ( sb curp -> + _length > sb endp -> )
  1453.                                              __strbuf_expandbuf ( sb , _length ) ;
  1454.                                    strncpy ( sb curp -> , p , _length ) ;
  1455.                                    sb curp -> += _length ;
  1456.                               }
  1457.                    
  1458.                     } while ( 0 );
  1459.                do {
  1460.                          if ( ! sb alloc_failed -> ){
  1461.                                    if ( sb curp -> >= sb endp -> )
  1462.                                              __strbuf_expandbuf ( sb , 0 ) ;
  1463.                                    * sb curp -> ++ = '/' ;
  1464.                               }
  1465.                    
  1466.                     } while ( 0 );
  1467.           }
  1468.      do {
  1469.                unsigned int _length = strlen ( " @\" " ) ;
  1470.                if ( ! sb alloc_failed -> ){
  1471.                          if ( sb curp -> + _length > sb endp -> )
  1472.                                    __strbuf_expandbuf ( sb , _length ) ;
  1473.                          strncpy ( sb curp -> , " @\" " , _length ) ;
  1474.                          sb curp -> += _length ;
  1475.                     }
  1476.          
  1477.           } while ( 0 );
  1478.      if ( * branch ){
  1479.                char unit [ 256 ] ;
  1480.                p = unit ;
  1481.                for ( c = branch + 1 ; ; c ++ ){
  1482.                          if ( * c == 0 || * c == '/' ){
  1483.                                    * p = 0 ;
  1484.                                    do {
  1485.                                              unsigned int _length = strlen ( " -e \"s@\\.\\./ " ) ;
  1486.                                              if ( ! sb alloc_failed -> ){
  1487.                                                        if ( sb curp -> + _length > sb endp -> )
  1488.                                                                  __strbuf_expandbuf ( sb , _length ) ;
  1489.                                                        strncpy ( sb curp -> , " -e \"s@\\.\\./ " , _length ) ;
  1490.                                                        sb curp -> += _length ;
  1491.                                                   }
  1492.                                        
  1493.                                         } while ( 0 );
  1494.                                    do {
  1495.                                              unsigned int _length = strlen ( unit ) ;
  1496.                                              if ( ! sb alloc_failed -> ){
  1497.                                                        if ( sb curp -> + _length > sb endp -> )
  1498.                                                                  __strbuf_expandbuf ( sb , _length ) ;
  1499.                                                        strncpy ( sb curp -> , unit , _length ) ;
  1500.                                                        sb curp -> += _length ;
  1501.                                                   }
  1502.                                        
  1503.                                         } while ( 0 );
  1504.                                    do {
  1505.                                              unsigned int _length = strlen ( " /@@\" " ) ;
  1506.                                              if ( ! sb alloc_failed -> ){
  1507.                                                        if ( sb curp -> + _length > sb endp -> )
  1508.                                                                  __strbuf_expandbuf ( sb , _length ) ;
  1509.                                                        strncpy ( sb curp -> , " /@@\" " , _length ) ;
  1510.                                                        sb curp -> += _length ;
  1511.                                                   }
  1512.                                        
  1513.                                         } while ( 0 );
  1514.                                    if ( * c == 0 )
  1515.                                              break ;
  1516.                                    p = unit ;
  1517.                               }
  1518.                               else
  1519.                                    * p ++ = * c ;
  1520.                     }
  1521.           }
  1522. }




  1523. void printtag (op, bp)
  1524.      FILE * op ;
  1525.      char * bp ;
  1526. {
  1527.      if ( tflag ){
  1528.                char buf [ 1024 + 1 ] ;
  1529.                char lno [ 20 ] , * l = lno ;
  1530.                char * p = bp ;
  1531.                char * q = buf ;
  1532.                while ( * p && ! ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) )
  1533.                          * q ++ = * p ++ ;
  1534.                * q ++ = '\t' ;
  1535.                for ( ; * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) ; p ++ )
  1536.                          ;
  1537.                while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 4 ) )
  1538.                          * l ++ = * p ++ ;
  1539.                * l = 0 ;
  1540.                for ( ; * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) ; p ++ )
  1541.                          ;
  1542.                while ( * p && ! ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) )
  1543.                          * q ++ = * p ++ ;
  1544.                * q ++ = '\t' ;
  1545.                l = lno ;
  1546.                while ( * l )
  1547.                          * q ++ = * l ++ ;
  1548.                * q = 0 ;
  1549.                fprintf ( op , " %s\n " , buf ) ;
  1550.           }
  1551.      else if ( ! xflag ){
  1552.                char * p = locatestring ( bp , " ./ " , 0 ) ;
  1553.                if ( p == ( ( void * ) 0 ) )
  1554.                          die ( " illegal tag format (path not found). " ) ;
  1555.                fputs ( strmake ( p , " \t " ) , op ) ;
  1556.                ( 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 -> ++ ) ) ;
  1557.           }
  1558.           else
  1559.                fprintf ( op , " %s\n " , bp ) ;
  1560. }




  1561. void idutils (pattern, dbpath)
  1562.      char * pattern ;
  1563.      char * dbpath ;
  1564. {
  1565.      FILE * ip , * op ;
  1566.      STRBUF * ib = strbuf_open ( 0 ) ;
  1567.      char edit [ 512 + 1 ] ;
  1568.      char * line , * p , * path , * lno ;
  1569.      int linenum , count , editlen ;
  1570.      ffformat ( edit , sizeof ( edit ) , pattern ) ;
  1571.      editlen = strlen ( edit ) ;
  1572.      do {
  1573.                unsigned int _length = strlen ( " gid " ) ;
  1574.                if ( ! ib alloc_failed -> ){
  1575.                          if ( ib curp -> + _length > ib endp -> )
  1576.                                    __strbuf_expandbuf ( ib , _length ) ;
  1577.                          strncpy ( ib curp -> , " gid " , _length ) ;
  1578.                          ib curp -> += _length ;
  1579.                     }
  1580.          
  1581.           } while ( 0 );
  1582.      do {
  1583.                unsigned int _length = strlen ( " --separator=newline " ) ;
  1584.                if ( ! ib alloc_failed -> ){
  1585.                          if ( ib curp -> + _length > ib endp -> )
  1586.                                    __strbuf_expandbuf ( ib , _length ) ;
  1587.                          strncpy ( ib curp -> , " --separator=newline " , _length ) ;
  1588.                          ib curp -> += _length ;
  1589.                     }
  1590.          
  1591.           } while ( 0 );
  1592.      if ( ! tflag && ! xflag )
  1593.                do {
  1594.                     unsigned int _length = strlen ( " --result=filenames --key=none " ) ;
  1595.                     if ( ! ib alloc_failed -> ){
  1596.                               if ( ib curp -> + _length > ib endp -> )
  1597.                                         __strbuf_expandbuf ( ib , _length ) ;
  1598.                               strncpy ( ib curp -> , " --result=filenames --key=none " , _length ) ;
  1599.                               ib curp -> += _length ;
  1600.                          }
  1601.               
  1602.                } while ( 0 );
  1603.      else
  1604.                do {
  1605.                     unsigned int _length = strlen ( " --result=grep " ) ;
  1606.                     if ( ! ib alloc_failed -> ){
  1607.                               if ( ib curp -> + _length > ib endp -> )
  1608.                                         __strbuf_expandbuf ( ib , _length ) ;
  1609.                               strncpy ( ib curp -> , " --result=grep " , _length ) ;
  1610.                               ib curp -> += _length ;
  1611.                          }
  1612.               
  1613.                } while ( 0 );
  1614.      if ( extra_options ){
  1615.                do {
  1616.                          unsigned int _length = strlen ( extra_options ) ;
  1617.                          if ( ! ib alloc_failed -> ){
  1618.                                    if ( ib curp -> + _length > ib endp -> )
  1619.                                              __strbuf_expandbuf ( ib , _length ) ;
  1620.                                    strncpy ( ib curp -> , extra_options , _length ) ;
  1621.                                    ib curp -> += _length ;
  1622.                               }
  1623.                    
  1624.                     } while ( 0 );
  1625.                do {
  1626.                          if ( ! ib alloc_failed -> ){
  1627.                                    if ( ib curp -> >= ib endp -> )
  1628.                                              __strbuf_expandbuf ( ib , 0 ) ;
  1629.                                    * ib curp -> ++ = '\' ;
  1630.                               }
  1631.                    
  1632.                     } while ( 0 );
  1633.           }
  1634.      do {
  1635.                if ( ! ib alloc_failed -> ){
  1636.                          if ( ib curp -> >= ib endp -> )
  1637.                                    __strbuf_expandbuf ( ib , 0 ) ;
  1638.                          * ib curp -> ++ = '\'' ;
  1639.                     }
  1640.          
  1641.           } while ( 0 );
  1642.      do {
  1643.                unsigned int _length = strlen ( pattern ) ;
  1644.                if ( ! ib alloc_failed -> ){
  1645.                          if ( ib curp -> + _length > ib endp -> )
  1646.                                    __strbuf_expandbuf ( ib , _length ) ;
  1647.                          strncpy ( ib curp -> , pattern , _length ) ;
  1648.                          ib curp -> += _length ;
  1649.                     }
  1650.          
  1651.           } while ( 0 );
  1652.      do {
  1653.                if ( ! ib alloc_failed -> ){
  1654.                          if ( ib curp -> >= ib endp -> )
  1655.                                    __strbuf_expandbuf ( ib , 0 ) ;
  1656.                          * ib curp -> ++ = '\'' ;
  1657.                     }
  1658.          
  1659.           } while ( 0 );
  1660.      if ( debug )
  1661.                fprintf ( ( _impure_ptr _stderr -> ) , " idutils: %s\n " , strbuf_value ( ib ) ) ;
  1662.      if ( ! ( ip = popen ( strbuf_value ( ib ) , " r " ) ) )
  1663.                die ( " cannot execute \'%s\'. " , strbuf_value ( ib ) ) ;
  1664.      if ( ! ( op = openfilter ( openfilter ) ) )
  1665.                die ( " cannot open output filter. " ) ;
  1666.      count = 0 ;
  1667.      while ( ( line = strbuf_fgets ( ib , ip , 2 ) ) != ( ( void * ) 0 ) ){
  1668.                p = line ;
  1669.                path = p ;
  1670.                while ( * p && * p != ':' )
  1671.                          p ++ ;
  1672.                if ( ( xflag || tflag ) && ! * p )
  1673.                          die ( " illegal gid(idutils) output format. \'%s\' " , line ) ;
  1674.                * p ++ = 0 ;
  1675.                if ( lflag ){
  1676.                          if ( ! locatestring ( path , localprefix + 2 , 1 ) )
  1677.                                    continue ;
  1678.                     }
  1679.                count ++ ;
  1680.                if ( ! xflag && ! tflag ){
  1681.                          fprintf ( op , " ./%s\n " , path ) ;
  1682.                          continue ;
  1683.                     }
  1684.                while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) )
  1685.                          p ++ ;
  1686.                lno = p ;
  1687.                while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 4 ) )
  1688.                          p ++ ;
  1689.                if ( * p != ':' )
  1690.                          die ( " illegal grep output format. \'%s\' " , line ) ;
  1691.                * p ++ = 0 ;
  1692.                linenum = atoi ( lno ) ;
  1693.                if ( linenum <= 0 )
  1694.                          die ( " illegal grep output format. \'%s\' " , line ) ;
  1695.                if ( tflag )
  1696.                          fprintf ( op , " %s\t./%s\t%d\n " , edit , path , linenum ) ;
  1697.                     else {
  1698.                          char buf [ ( 260 - 1 ) + 1 ] ;
  1699.                          snprintf ( buf , sizeof ( buf ) , " ./%s " , path ) ;
  1700.                          if ( editlen >= 16 && linenum >= 1000 )
  1701.                               fprintf ( op , " %-16s %4d %-16s %s\n " , edit , linenum , buf , p ) ;
  1702.                     else
  1703.                               fprintf ( op , " %-16s%4d %-16s %s\n " , edit , linenum , buf , p ) ;
  1704.                     }
  1705.           }
  1706.      pclose ( ip ) ;
  1707.      closefilter ( op ) ;
  1708.      strbuf_close ( ib ) ;
  1709.      if ( vflag ){
  1710.                if ( count == 0 )
  1711.                          fprintf ( ( _impure_ptr _stderr -> ) , " object not found " ) ;
  1712.                if ( count == 1 )
  1713.                          fprintf ( ( _impure_ptr _stderr -> ) , " %d object located " , count ) ;
  1714.                if ( count > 1 )
  1715.                          fprintf ( ( _impure_ptr _stderr -> ) , " %d objects located " , count ) ;
  1716.                fprintf ( ( _impure_ptr _stderr -> ) , " (using idutils index in \'%s\').\n " , dbpath ) ;
  1717.           }
  1718. }




  1719. void grep (pattern, dbpath)
  1720.      char * pattern ;
  1721.      char * dbpath ;
  1722. {
  1723.      FILE * ip , * op ;
  1724.      STRBUF * ib = strbuf_open ( 0 ) ;
  1725.      char edit [ 512 + 1 ] ;
  1726.      char * line , * p , * path , * lno ;
  1727.      int linenum , count , editlen ;
  1728.      ffformat ( edit , sizeof ( edit ) , pattern ) ;
  1729.      editlen = strlen ( edit ) ;
  1730.      do {
  1731.                unsigned int _length = strlen ( " gtags --find " ) ;
  1732.                if ( ! ib alloc_failed -> ){
  1733.                          if ( ib curp -> + _length > ib endp -> )
  1734.                                    __strbuf_expandbuf ( ib , _length ) ;
  1735.                          strncpy ( ib curp -> , " gtags --find " , _length ) ;
  1736.                          ib curp -> += _length ;
  1737.                     }
  1738.          
  1739.           } while ( 0 );
  1740.      if ( lflag )
  1741.                do {
  1742.                     unsigned int _length = strlen ( localprefix ) ;
  1743.                     if ( ! ib alloc_failed -> ){
  1744.                               if ( ib curp -> + _length > ib endp -> )
  1745.                                         __strbuf_expandbuf ( ib , _length ) ;
  1746.                               strncpy ( ib curp -> , localprefix , _length ) ;
  1747.                               ib curp -> += _length ;
  1748.                          }
  1749.               
  1750.                } while ( 0 );
  1751.      do {
  1752.                unsigned int _length = strlen ( " | xargs grep " ) ;
  1753.                if ( ! ib alloc_failed -> ){
  1754.                          if ( ib curp -> + _length > ib endp -> )
  1755.                                    __strbuf_expandbuf ( ib , _length ) ;
  1756.                          strncpy ( ib curp -> , " | xargs grep " , _length ) ;
  1757.                          ib curp -> += _length ;
  1758.                     }
  1759.          
  1760.           } while ( 0 );
  1761.      if ( ! tflag && ! xflag )
  1762.                do {
  1763.                     unsigned int _length = strlen ( " -l " ) ;
  1764.                     if ( ! ib alloc_failed -> ){
  1765.                               if ( ib curp -> + _length > ib endp -> )
  1766.                                         __strbuf_expandbuf ( ib , _length ) ;
  1767.                               strncpy ( ib curp -> , " -l " , _length ) ;
  1768.                               ib curp -> += _length ;
  1769.                          }
  1770.               
  1771.                } while ( 0 );
  1772.      else
  1773.                do {
  1774.                     unsigned int _length = strlen ( " -n " ) ;
  1775.                     if ( ! ib alloc_failed -> ){
  1776.                               if ( ib curp -> + _length > ib endp -> )
  1777.                                         __strbuf_expandbuf ( ib , _length ) ;
  1778.                               strncpy ( ib curp -> , " -n " , _length ) ;
  1779.                               ib curp -> += _length ;
  1780.                          }
  1781.               
  1782.                } while ( 0 );
  1783.      do {
  1784.                if ( ! ib alloc_failed -> ){
  1785.                          if ( ib curp -> >= ib endp -> )
  1786.                                    __strbuf_expandbuf ( ib , 0 ) ;
  1787.                          * ib curp -> ++ = '\'' ;
  1788.                     }
  1789.          
  1790.           } while ( 0 );
  1791.      do {
  1792.                unsigned int _length = strlen ( pattern ) ;
  1793.                if ( ! ib alloc_failed -> ){
  1794.                          if ( ib curp -> + _length > ib endp -> )
  1795.                                    __strbuf_expandbuf ( ib , _length ) ;
  1796.                          strncpy ( ib curp -> , pattern , _length ) ;
  1797.                          ib curp -> += _length ;
  1798.                     }
  1799.          
  1800.           } while ( 0 );
  1801.      do {
  1802.                if ( ! ib alloc_failed -> ){
  1803.                          if ( ib curp -> >= ib endp -> )
  1804.                                    __strbuf_expandbuf ( ib , 0 ) ;
  1805.                          * ib curp -> ++ = '\'' ;
  1806.                     }
  1807.          
  1808.           } while ( 0 );
  1809.      do {
  1810.                unsigned int _length = strlen ( " /dev/null " ) ;
  1811.                if ( ! ib alloc_failed -> ){
  1812.                          if ( ib curp -> + _length > ib endp -> )
  1813.                                    __strbuf_expandbuf ( ib , _length ) ;
  1814.                          strncpy ( ib curp -> , " /dev/null " , _length ) ;
  1815.                          ib curp -> += _length ;
  1816.                     }
  1817.          
  1818.           } while ( 0 );
  1819.      if ( debug )
  1820.                fprintf ( ( _impure_ptr _stderr -> ) , " grep: %s\n " , strbuf_value ( ib ) ) ;
  1821.      if ( ! ( ip = popen ( strbuf_value ( ib ) , " r " ) ) )
  1822.                die ( " cannot execute \'%s\'. " , strbuf_value ( ib ) ) ;
  1823.      if ( ! ( op = openfilter ( openfilter ) ) )
  1824.                die ( " cannot open output filter. " ) ;
  1825.      count = 0 ;
  1826.      while ( ( line = strbuf_fgets ( ib , ip , 2 ) ) != ( ( void * ) 0 ) ){
  1827.                p = line ;
  1828.                path = p ;
  1829.                while ( * p && * p != ':' )
  1830.                          p ++ ;
  1831.                if ( ( xflag || tflag ) && ! * p )
  1832.                          die ( " illegal grep output format. \'%s\' " , line ) ;
  1833.                * p ++ = 0 ;
  1834.                if ( ! xflag && ! tflag ){
  1835.                          fprintf ( op , " %s\n " , path ) ;
  1836.                          continue ;
  1837.                     }
  1838.                while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 8 ) )
  1839.                          p ++ ;
  1840.                lno = p ;
  1841.                while ( * p && ( ( _ctype_ + 1 ) [ ( unsigned ) ( * p ) ] & 4 ) )
  1842.                          p ++ ;
  1843.                if ( * p != ':' )
  1844.                          die ( " illegal grep output format. \'%s\' " , line ) ;
  1845.                * p ++ = 0 ;
  1846.                linenum = atoi ( lno ) ;
  1847.                if ( linenum <= 0 )
  1848.                          die ( " illegal grep output format. \'%s\' " , line ) ;
  1849.                count ++ ;
  1850.                if ( tflag )
  1851.                          fprintf ( op , " %s\t%s\t%d\n " , edit , path , linenum ) ;
  1852.                     else if ( ! xflag ){
  1853.                          fprintf ( op , " %s\n " , path ) ;
  1854.                     }
  1855.                else if ( editlen >= 16 && linenum >= 1000 )
  1856.                          fprintf ( op , " %-16s %4d %-16s %s\n " , edit , linenum , path , p ) ;
  1857.                else
  1858.                          fprintf ( op , " %-16s%4d %-16s %s\n " , edit , linenum , path , p ) ;
  1859.           }
  1860.      pclose ( ip ) ;
  1861.      closefilter ( op ) ;
  1862.      strbuf_close ( ib ) ;
  1863.      if ( vflag ){
  1864.                if ( count == 0 )
  1865.                          fprintf ( ( _impure_ptr _stderr -> ) , " object not found " ) ;
  1866.                if ( count == 1 )
  1867.                          fprintf ( ( _impure_ptr _stderr -> ) , " %d object located " , count ) ;
  1868.                if ( count > 1 )
  1869.                          fprintf ( ( _impure_ptr _stderr -> ) , " %d objects located " , count ) ;
  1870.                fprintf ( ( _impure_ptr _stderr -> ) , " (no index used).\n " ) ;
  1871.           }
  1872. }




  1873. void pathlist (dbpath, av)
  1874.      char * dbpath ;
  1875.      char * av ;
  1876. {
  1877.      FILE * op ;
  1878.      char * path , * p ;
  1879.      regex_t preg ;
  1880.      int count ;
  1881.      if ( av ){
  1882.                if ( regcomp ( & preg , av , 1 ) != 0 )
  1883.                          die ( " illegal regular expression. " ) ;
  1884.           }
  1885.      if ( ! localprefix )
  1886.                localprefix = " ./ " ;
  1887.      if ( ! ( op = openfilter ( openfilter ) ) )
  1888.                die ( " cannot open output filter. " ) ;
  1889.      count = 0 ;
  1890.      for ( gfindopen ( dbpath , localprefix ) ; ( path = gfindread ( gfindread ) ) != ( ( void * ) 0 ) ; ){
  1891.                p = path + strlen ( localprefix ) - 1 ;
  1892.                if ( av && regexec ( & preg , p , 0 , 0 , 0 ) != 0 )
  1893.                          continue ;
  1894.                if ( xflag )
  1895.                          fprintf ( op , " path\t1 %s \n " , path ) ;
  1896.                     else if ( tflag )
  1897.                          fprintf ( op , " path\t%s\t1\n " , path ) ;
  1898.                else
  1899.                          fprintf ( op , " %s\n " , path ) ;
  1900.                count ++ ;
  1901.           }
  1902.      gfindclose ( gfindclose ) ;
  1903.      closefilter ( op ) ;
  1904.      if ( av )
  1905.                regfree ( & preg ) ;
  1906.      if ( vflag ){
  1907.                if ( count == 0 )
  1908.                          fprintf ( ( _impure_ptr _stderr -> ) , " path not found " ) ;
  1909.                if ( count == 1 )
  1910.                          fprintf ( ( _impure_ptr _stderr -> ) , " %d path located " , count ) ;
  1911.                if ( count > 1 )
  1912.                          fprintf ( ( _impure_ptr _stderr -> ) , " %d paths located " , count ) ;
  1913.                fprintf ( ( _impure_ptr _stderr -> ) , " (using \'%s\').\n " , makepath ( dbpath , dbname ( 0 ) , ( ( void * ) 0 ) ) ) ;
  1914.           }
  1915. }




  1916. void parsefile (argc, argv, cwd, root, dbpath, db)
  1917.      int argc ;
  1918.      char * * argv ;
  1919.      char * cwd ;
  1920.      char * root ;
  1921.      char * dbpath ;
  1922.      int db ;
  1923. {
  1924.      char buf [ ( 260 - 1 ) + 1 ] , * path ;
  1925.      char env [ ( 260 - 1 ) + 1 ] ;
  1926.      char * p ;
  1927.      FILE * ip , * op ;
  1928.      char * parser , * av ;
  1929.      int count ;
  1930.      STRBUF * sb = strbuf_open ( 0 ) ;
  1931.      STRBUF * com = strbuf_open ( 0 ) ;
  1932.      STRBUF * ib = strbuf_open ( 1024 ) ;
  1933.      snprintf ( env , sizeof ( env ) , " GTAGSDBPATH=%s " , dbpath ) ;
  1934.      putenv ( env ) ;
  1935.      if ( ! getconfs ( dbname ( db ) , sb ) )
  1936.                die ( " cannot get parser for %s. " , dbname ( db ) ) ;
  1937.      parser = strbuf_value ( sb ) ;
  1938.      if ( ! ( op = openfilter ( openfilter ) ) )
  1939.                die ( " cannot open output filter. " ) ;
  1940.      if ( pathopen ( dbpath , 0 ) < 0 )
  1941.                die ( " GPATH not found. " ) ;
  1942.      count = 0 ;
  1943.      for ( ; argc > 0 ; argv ++ , argc -- ){
  1944.                av = argv [ 0 ] ;
  1945.                if ( test ( " d " , av ) ){
  1946.                          fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' is a directory.\n " , av ) ;
  1947.                          continue ;
  1948.                     }
  1949.                if ( ! test ( " f " , ( ( void * ) 0 ) ) ){
  1950.                          fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' not found.\n " , av ) ;
  1951.                          continue ;
  1952.                     }
  1953.                path = realpath ( av , buf ) ;
  1954.                if ( ! isabspath ( path ) )
  1955.                          die ( " realpath(3) is not compatible with BSD version. " ) ;
  1956.                if ( strncmp ( path , root , strlen ( root ) ) ){
  1957.                          fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' is out of source tree.\n " , path ) ;
  1958.                          continue ;
  1959.                     }
  1960.                path += strlen ( root ) - 1 ;
  1961.                * path = '.' ;
  1962.                if ( ! pathget ( path ) ){
  1963.                          fprintf ( ( _impure_ptr _stderr -> ) , " \'%s\' not found in GPATH.\n " , path ) ;
  1964.                          continue ;
  1965.                     }
  1966.                if ( chdir ( root ) < 0 )
  1967.                          die ( " cannot move to \'%s\' directory. " , root ) ;
  1968.                do {
  1969.                          com curp -> = com sbuf -> ;
  1970.                          com alloc_failed -> = 0 ;
  1971.                    
  1972.                     } while ( 0 );
  1973.                makecommand ( parser , path , com ) ;
  1974.                if ( debug )
  1975.                          fprintf ( ( _impure_ptr _stderr -> ) , " executing %s\n " , strbuf_value ( com ) ) ;
  1976.                if ( ! ( ip = popen ( strbuf_value ( com ) , " r " ) ) )
  1977.                          die ( " cannot execute \'%s\'. " , strbuf_value ( com ) ) ;
  1978.                while ( ( p = strbuf_fgets ( ib , ip , 2 ) ) != ( ( void * ) 0 ) ){
  1979.                          count ++ ;
  1980.                          printtag ( op , p ) ;
  1981.                     }
  1982.                pclose ( ip ) ;
  1983.                if ( chdir ( cwd ) < 0 )
  1984.                          die ( " cannot move to \'%s\' directory. " , cwd ) ;
  1985.           }
  1986.      pathclose ( pathclose ) ;
  1987.      closefilter ( op ) ;
  1988.      strbuf_close ( sb ) ;
  1989.      strbuf_close ( com ) ;
  1990.      strbuf_close ( ib ) ;
  1991.      if ( vflag ){
  1992.                if ( count == 0 )
  1993.                          fprintf ( ( _impure_ptr _stderr -> ) , " object not found " ) ;
  1994.                if ( count == 1 )
  1995.                          fprintf ( ( _impure_ptr _stderr -> ) , " %d object located " , count ) ;
  1996.                if ( count > 1 )
  1997.                          fprintf ( ( _impure_ptr _stderr -> ) , " %d objects located " , count ) ;
  1998.                fprintf ( ( _impure_ptr _stderr -> ) , " (no index used).\n " ) ;
  1999.           }
  2000. }




  2001. int search (pattern, root, dbpath, db)
  2002.      char * pattern ;
  2003.      char * root ;
  2004.      char * dbpath ;
  2005.      int db ;
  2006. {
  2007.      char * p ;
  2008.      int count = 0 ;
  2009.      FILE * op ;
  2010.      GTOP * gtop ;
  2011.      int flags = 0 ;
  2012.      gtop = gtagsopen ( dbpath , root , db , 0 , 0 ) ;
  2013.      if ( ! ( op = openfilter ( openfilter ) ) )
  2014.                die ( " cannot open output filter. " ) ;
  2015.      if ( nflag > 1 )
  2016.                flags |= 4 ;
  2017.      for ( p = gtagsfirst ( gtop , pattern , flags ) ; p ; p = gtagsnext ( gtop ) ){
  2018.                if ( lflag ){
  2019.                          char * q ;
  2020.                          q = locatestring ( p , " ./ " , 0 ) ;
  2021.                          if ( ! locatestring ( q , localprefix , 1 ) )
  2022.                                    continue ;
  2023.                     }
  2024.                printtag ( op , p ) ;
  2025.                count ++ ;
  2026.           }
  2027.      closefilter ( op ) ;
  2028.      gtagsclose ( gtop ) ;
  2029.      return count ;
  2030. }




  2031. int includepath (line, path)
  2032.      char * line ;
  2033.      char * path ;
  2034. {
  2035.      char * p ;
  2036.      int length ;
  2037.      if ( ! ( p = locatestring ( line , " ./ " , 0 ) ) )
  2038.                die ( " illegal tag format (path not found). " ) ;
  2039.      length = strlen ( path ) ;
  2040.      if ( strncmp ( p , path , length ) )
  2041.                return 0 ;
  2042.      p += length ;
  2043.      if ( * p == '\' || * p == '\t' )
  2044.                return 1 ;
  2045.      return 0 ;
  2046. }




  2047. void ffformat (to, size, from)
  2048.      char * to ;
  2049.      int size ;
  2050.      char * from ;
  2051. {
  2052.      char * p , * e = to ;
  2053.      for ( p = from ; * p ; p ++ ){
  2054.                if ( * p == '%' || * p == '\' || * p == '\t' ){
  2055.                          if ( size <= 3 )
  2056.                                    break ;
  2057.                          snprintf ( e , size , " %%%02x " , * p ) ;
  2058.                          e += 3 ;
  2059.                          size -= 3 ;
  2060.                     }
  2061.                     else {
  2062.                          if ( size <= 1 )
  2063.                                    break ;
  2064.                          * e ++ = * p ;
  2065.                          size -- ;
  2066.                     }
  2067.           }
  2068.      * e = 0 ;
  2069. }