mirror of
https://github.com/freebsd/freebsd-src
synced 2024-09-06 17:18:32 +00:00
344 lines
8.1 KiB
C
344 lines
8.1 KiB
C
/*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*
|
|
* Copyright (c) 1995-2022 Wolfram Schneider <wosch@FreeBSD.org>
|
|
* Copyright (c) 1989, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* James A. Woods.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
|
|
#ifndef _LOCATE_STATISTIC_
|
|
#define _LOCATE_STATISTIC_
|
|
|
|
void
|
|
statistic (FILE *fp, char *path_fcodes)
|
|
{
|
|
long lines, chars, size, size_nbg, big, zwerg, umlaut;
|
|
u_char *p, *s;
|
|
int c;
|
|
int count, longest_path;
|
|
int error = 0;
|
|
u_char bigram1[NBG], bigram2[NBG], path[LOCATE_PATH_MAX];
|
|
|
|
for (c = 0, p = bigram1, s = bigram2; c < NBG; c++) {
|
|
p[c] = check_bigram_char(getc(fp));
|
|
s[c] = check_bigram_char(getc(fp));
|
|
}
|
|
|
|
lines = chars = big = zwerg = umlaut = longest_path = 0;
|
|
size = NBG + NBG;
|
|
|
|
for (c = getc(fp), count = 0; c != EOF; size++) {
|
|
if (c == SWITCH) {
|
|
count += getwf(fp) - OFFSET;
|
|
size += sizeof(int);
|
|
zwerg++;
|
|
} else
|
|
count += c - OFFSET;
|
|
|
|
if (count < 0 || count >= LOCATE_PATH_MAX) {
|
|
/* stop on error and display the statstics anyway */
|
|
warnx("corrupted database: %s %d", path_fcodes, count);
|
|
error = 1;
|
|
break;
|
|
}
|
|
|
|
for (p = path + count; (c = getc(fp)) > SWITCH; size++)
|
|
if (c < PARITY) {
|
|
if (c == UMLAUT) {
|
|
c = getc(fp);
|
|
size++;
|
|
umlaut++;
|
|
}
|
|
p++;
|
|
} else {
|
|
/* bigram char */
|
|
big++;
|
|
p += 2;
|
|
}
|
|
|
|
p++;
|
|
lines++;
|
|
chars += (p - path);
|
|
if ((p - path) > longest_path)
|
|
longest_path = p - path;
|
|
}
|
|
|
|
/* size without bigram db */
|
|
size_nbg = size - (2 * NBG);
|
|
|
|
(void)printf("\nDatabase: %s\n", path_fcodes);
|
|
(void)printf("Compression: Front: %2.2f%%, ", chars > 0 ? (size_nbg + big) / (chars / (float)100) : 0);
|
|
(void)printf("Bigram: %2.2f%%, ", big > 0 ? (size_nbg - big) / (size_nbg / (float)100) : 0);
|
|
/* incl. bigram db overhead */
|
|
(void)printf("Total: %2.2f%%\n", chars > 0 ? size / (chars / (float)100) : 0);
|
|
(void)printf("Filenames: %ld, ", lines);
|
|
(void)printf("Characters: %ld, ", chars);
|
|
(void)printf("Database size: %ld\n", size);
|
|
(void)printf("Bigram characters: %ld, ", big);
|
|
(void)printf("Integers: %ld, ", zwerg);
|
|
(void)printf("8-Bit characters: %ld\n", umlaut);
|
|
printf("Longest path: %d\n", longest_path > 0 ? longest_path - 1 : 0);
|
|
|
|
/* non zero exit on corrupt database */
|
|
if (error)
|
|
exit(error);
|
|
}
|
|
#endif /* _LOCATE_STATISTIC_ */
|
|
|
|
extern char separator;
|
|
|
|
void
|
|
#ifdef FF_MMAP
|
|
|
|
|
|
#ifdef FF_ICASE
|
|
fastfind_mmap_icase
|
|
#else
|
|
fastfind_mmap
|
|
#endif /* FF_ICASE */
|
|
(char *pathpart, caddr_t paddr, off_t len, char *database)
|
|
|
|
|
|
#else /* MMAP */
|
|
|
|
|
|
#ifdef FF_ICASE
|
|
fastfind_icase
|
|
#else
|
|
fastfind
|
|
#endif /* FF_ICASE */
|
|
|
|
(FILE *fp, char *pathpart, char *database)
|
|
|
|
|
|
#endif /* MMAP */
|
|
|
|
{
|
|
u_char *p, *s, *patend, *q, *foundchar;
|
|
int c, cc;
|
|
int count, found, globflag;
|
|
u_char *cutoff;
|
|
u_char bigram1[NBG], bigram2[NBG], path[LOCATE_PATH_MAX + 2];
|
|
|
|
#ifdef FF_ICASE
|
|
/* use a lookup table for case insensitive search */
|
|
u_char table[UCHAR_MAX + 1];
|
|
|
|
tolower_word(pathpart);
|
|
#endif /* FF_ICASE*/
|
|
|
|
/* init bigram table */
|
|
#ifdef FF_MMAP
|
|
for (c = 0, p = bigram1, s = bigram2; c < NBG; c++, len-= 2) {
|
|
p[c] = check_bigram_char(*paddr++);
|
|
s[c] = check_bigram_char(*paddr++);
|
|
}
|
|
#else
|
|
for (c = 0, p = bigram1, s = bigram2; c < NBG; c++) {
|
|
p[c] = check_bigram_char(getc(fp));
|
|
s[c] = check_bigram_char(getc(fp));
|
|
}
|
|
#endif /* FF_MMAP */
|
|
|
|
/* find optimal (last) char for searching */
|
|
for (p = pathpart; *p != '\0'; p++)
|
|
if (strchr(LOCATE_REG, *p) != NULL)
|
|
break;
|
|
|
|
if (*p == '\0')
|
|
globflag = 0;
|
|
else
|
|
globflag = 1;
|
|
|
|
p = pathpart;
|
|
patend = patprep(p);
|
|
cc = *patend;
|
|
|
|
#ifdef FF_ICASE
|
|
/* set patend char to true */
|
|
for (c = 0; c < UCHAR_MAX + 1; c++)
|
|
table[c] = 0;
|
|
|
|
table[TOLOWER(*patend)] = 1;
|
|
table[toupper(*patend)] = 1;
|
|
#endif /* FF_ICASE */
|
|
|
|
|
|
/* main loop */
|
|
found = count = 0;
|
|
foundchar = 0;
|
|
|
|
#ifdef FF_MMAP
|
|
c = (u_char)*paddr++;
|
|
len--;
|
|
|
|
for (; len > 0; ) {
|
|
#else
|
|
c = getc(fp);
|
|
for (; c != EOF; ) {
|
|
#endif /* FF_MMAP */
|
|
|
|
/* go forward or backward */
|
|
if (c == SWITCH) { /* big step, an integer */
|
|
#ifdef FF_MMAP
|
|
if (len < sizeof(int))
|
|
errx(1, "corrupted database: %s", database);
|
|
|
|
count += getwm(paddr) - OFFSET;
|
|
len -= INTSIZE;
|
|
paddr += INTSIZE;
|
|
#else
|
|
count += getwf(fp) - OFFSET;
|
|
#endif /* FF_MMAP */
|
|
} else { /* slow step, =< 14 chars */
|
|
count += c - OFFSET;
|
|
}
|
|
|
|
if (count < 0 || count >= LOCATE_PATH_MAX)
|
|
errx(1, "corrupted database: %s %d", database, count);
|
|
|
|
/* overlay old path */
|
|
p = path + count;
|
|
foundchar = p - 1;
|
|
|
|
#ifdef FF_MMAP
|
|
for (; len > 0;) {
|
|
c = (u_char)*paddr++;
|
|
len--;
|
|
#else
|
|
for (;;) {
|
|
c = getc(fp);
|
|
#endif /* FF_MMAP */
|
|
/*
|
|
* == UMLAUT: 8 bit char followed
|
|
* <= SWITCH: offset
|
|
* >= PARITY: bigram
|
|
* rest: single ascii char
|
|
*
|
|
* offset < SWITCH < UMLAUT < ascii < PARITY < bigram
|
|
*/
|
|
if (c < PARITY) {
|
|
if (c <= UMLAUT) {
|
|
if (c == UMLAUT) {
|
|
#ifdef FF_MMAP
|
|
c = (u_char)*paddr++;
|
|
len--;
|
|
#else
|
|
c = getc(fp);
|
|
#endif /* FF_MMAP */
|
|
|
|
} else
|
|
break; /* SWITCH */
|
|
}
|
|
#ifdef FF_ICASE
|
|
if (table[c])
|
|
#else
|
|
if (c == cc)
|
|
#endif /* FF_ICASE */
|
|
foundchar = p;
|
|
*p++ = c;
|
|
}
|
|
else {
|
|
/* bigrams are parity-marked */
|
|
TO7BIT(c);
|
|
|
|
#ifndef FF_ICASE
|
|
if (bigram1[c] == cc ||
|
|
bigram2[c] == cc)
|
|
#else
|
|
|
|
if (table[bigram1[c]] ||
|
|
table[bigram2[c]])
|
|
#endif /* FF_ICASE */
|
|
foundchar = p + 1;
|
|
|
|
*p++ = bigram1[c];
|
|
*p++ = bigram2[c];
|
|
}
|
|
|
|
if (p - path >= LOCATE_PATH_MAX)
|
|
errx(1, "corrupted database: %s %td", database, p - path);
|
|
|
|
}
|
|
|
|
if (found) { /* previous line matched */
|
|
cutoff = path;
|
|
*p-- = '\0';
|
|
foundchar = p;
|
|
} else if (foundchar >= path + count) { /* a char matched */
|
|
*p-- = '\0';
|
|
cutoff = path + count;
|
|
} else /* nothing to do */
|
|
continue;
|
|
|
|
found = 0;
|
|
for (s = foundchar; s >= cutoff; s--) {
|
|
if (*s == cc
|
|
#ifdef FF_ICASE
|
|
|| TOLOWER(*s) == cc
|
|
#endif /* FF_ICASE */
|
|
) { /* fast first char check */
|
|
for (p = patend - 1, q = s - 1; *p != '\0';
|
|
p--, q--)
|
|
if (*q != *p
|
|
#ifdef FF_ICASE
|
|
&& TOLOWER(*q) != *p
|
|
#endif /* FF_ICASE */
|
|
)
|
|
break;
|
|
if (*p == '\0') { /* fast match success */
|
|
found = 1;
|
|
if (!globflag ||
|
|
#ifndef FF_ICASE
|
|
!fnmatch(pathpart, path, 0))
|
|
#else
|
|
!fnmatch(pathpart, path,
|
|
FNM_CASEFOLD))
|
|
#endif /* !FF_ICASE */
|
|
{
|
|
if (f_silent)
|
|
counter++;
|
|
else if (f_limit) {
|
|
counter++;
|
|
if (f_limit >= counter)
|
|
(void)printf("%s%c",path,separator);
|
|
else
|
|
errx(0, "[show only %ld lines]", counter - 1);
|
|
} else
|
|
(void)printf("%s%c",path,separator);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|