|
|
// FINDSTR (used to be QGREP), June 1992
//
// Modification History:
//
// Aug 1990 PeteS Created.
// 1990 DaveGi Ported to Cruiser
// 31-Oct-1990 W-Barry Removed the #ifdef M_I386 'cause this
// code will never see 16bit again.
// June 1992 t-petes Added recursive file search in subdirs.
// Used file mapping instead of multi-thread.
// Disabled internal switches.
// Internatioanlized display messages.
// Made switches case-insensitive.
// 05/08/93 v-junm Added Japanese search support.
// 06/03/93 v-junm Added Bilingual Message support>
/* About FILEMAP support:
* The file mapping object is used to speed up string searches. The new * file mapping method is coded as #ifdef-#else-#endif to show the * changes needed to be made. The old code(non-filemapping) has a read * buffer like this: * * filbuf[] = {.....................................} * ^ ^ * BegPtr EndPtr * * This means there are some spare space before BegPtr and after EndPtr * for the search algorithm to work its way. The old code also * occasionally modifies filbuf[](like filbuf[i] = '\n';). * * The new code(filemapping) must avoid doing all of the above because * there are no spare space before BegPtr or after EndPtr when mapping * view of the file which is opened as read-only. */
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <io.h>
#include <windows.h>
#include <ctype.h>
#include <assert.h>
#include <locale.h>
#include <stdarg.h>
#include "fsmsg.h"
#define FILBUFLEN (SECTORLEN*2)
#define ISCOT 0x0002 // Handle is console output
#define LG2SECLEN 10 // Log base two of sector length
#define LNOLEN 12 // Maximum line number length
#define MAXSTRLEN 128 // Maximum search string length
#define OUTBUFLEN (SECTORLEN*2) // Output buffer length
#define PATHLEN (MAX_PATH+2) // Path buffer length
#define SECTORLEN (1 << LG2SECLEN) // Sector length
#define STKLEN 512 // Stack length in bytes
#define TRTABLEN 256 // Translation table length
#define s_text(x) (((char *)(x)) - ((x)->s_must)) // Text field access macro
#define EOS ('\r') // End of string
#define CURRENT_DIRECTORY_MAX_LENGTH 512
#define MAX_SLASH_C_OPTION 100
// Bit flag definitions
#define SHOWNAME 0x01 // Print filename
#define NAMEONLY 0x02 // Print filename only
#define LINENOS 0x04 // Print line numbers
#define BEGLINE 0x08 // Match at beginning of line
#define ENDLINE 0x10 // Match at end of line
#define DEBUG 0x20 // Print debugging output
#define TIMER 0x40 // Time execution
#define SEEKOFF 0x80 // Print seek offsets
#define PRINTABLE_ONLY 0x100 // Skip files with non-printable characters
#define OFFLINE_FILES 0x200 // Do not skip offline files
#define DISPLAYBUFFER_SIZE 4096
// Type definitions
typedef struct stringnode { struct stringnode *s_alt; // List of alternates
struct stringnode *s_suf; // List of suffixes
int s_must; // Length of portion that must match
} STRINGNODE; // String node
typedef ULONG CBIO; // I/O byte count
typedef ULONG PARM; // Generic parameter
typedef CBIO *PCBIO; // Pointer to I/O byte count
typedef PARM *PPARM; // Pointer to generic parameter
// Global data
char *BaseByteAddress = NULL; // File mapping base address
BOOL bStdIn = FALSE; // Std-input file flag
BOOL bLargeFile = FALSE; // Dealing with non-memory mapped file
#ifdef FE_SB
BOOL IsDBCSCodePage = TRUE;#endif
char filbuf[FILBUFLEN*2L + 12];char outbuf[OUTBUFLEN*2];char td1[TRTABLEN] = { 0 };unsigned cchmin = (unsigned)-1; // Minimum string length
unsigned chmax = 0; // Maximum character
unsigned chmin = (unsigned)-1; // Minimum character
char transtab[TRTABLEN] = { 0 };STRINGNODE *stringlist[TRTABLEN/2];int casesen = 1; // Assume case-sensitivity
long cbfile; // Number of bytes in file
static int clists = 1; // One is first available index
int flags; // Flags
unsigned lineno; // Current line number
char *program; // Program name
int status = 1; // Assume failure
int strcnt = 0; // String count
char target[MAXSTRLEN]; // Last string added
int targetlen; // Length of last string added
unsigned waste; // Wasted storage in heap
int arrc; // I/O return code for DOSREAD
char asyncio; // Asynchronous I/O flag
int awrc = TRUE; // I/O return code for DOSWRITE
char *bufptr[] = { filbuf + 4, filbuf + FILBUFLEN + 8 };CBIO cbread; // Bytes read by DOSREAD
CBIO cbwrite; // Bytes written by DOSWRITE
char *obuf[] = { outbuf, outbuf + OUTBUFLEN };int ocnt[] = { OUTBUFLEN, OUTBUFLEN };int oi = 0; // Output buffer index
char *optr[] = { outbuf, outbuf + OUTBUFLEN };char pmode; // Protected mode flag
WORD wAttrib = 0; // filename color
CONSOLE_SCREEN_BUFFER_INFO csbi = {0}; // Our default screen info
CRITICAL_SECTION critSection;BOOLEAN fExiting = FALSE;
BOOLEAN fOfflineSkipped = FALSE; // Whether offline files were skipped
// External functions and forward references
void printmessage(FILE *fp, DWORD messagegID, ...); // Message display function for internationalization
int filematch(char *pszfile, char **ppszpat, int cpat, int fsubdirs);
#ifdef FE_SB
// Function to check if a certain location in a string is the second byte
// of a DBCS character.
int IsTailByte( unsigned const char *, const int );int _mbsnicmp( const unsigned char *, const unsigned char *, int, BOOL * );unsigned char *_mbslwr( unsigned char * );char *_mbsrchr( const char *, int );#endif
void addexpr( char *, int ); // See QMATCH.C
void addstring( char *, int ); // See below
int countlines( char *, char * );char *findexpr( unsigned char *, char *); // See QMATCH.C
char *findlist( unsigned char *, char * );char *findone( unsigned char *buffer, char *bufend );void flush1buf( void ); // See below
void flush1nobuf( void ); // See below
int grepbuffer( char *, char *, char * ); // See below
int isexpr( unsigned char *, int ); // See QMATCH.C
void matchstrings( char *, char *, int, int *, int * );int preveol( char * );int strncspn( char *, char *, int );int strnspn( char *, char *, int );char *strnupr( char *pch, int cch );void write1buf( char *, int, WORD ); // See below
void (*addstr)( char *, int ) = NULL;char *(*find)( unsigned char *, char * ) = NULL;void (*flush1)( void ) = flush1buf;int (*grep)( char *, char *, char * ) = grepbuffer;void (*write1)( char *, int, WORD ) = write1buf;void write1nobuf( char *, int, WORD );
inthas_wild_cards( char* p ){ if (!p) return 0;
for (; *p; p++) { if (*p == '?' || *p == '*') { return 1; } }
return 0;}
voiderror( DWORD messageID ){ printmessage(stderr, messageID, program); // Print message
exit(2); // Die
}
char *alloc( unsigned size ){ char *cp; // Char pointer
if ((cp = (char *) malloc(size)) == NULL) { // If allocation fails
printmessage(stderr, MSG_FINDSTR_OUT_OF_MEMORY, program); // Write error message
exit(2); // Die
} return(cp); // Return pointer to buffer
}
voidfreenode( STRINGNODE *x ){ register STRINGNODE *y; // Pointer to next node in list
while(x != NULL) { // While not at end of list
if (x->s_suf != NULL) freenode(x->s_suf); // Free suffix list if not end
else --strcnt; // Else decrement string count
y = x; // Save pointer
x = x->s_alt; // Move down the list
free((char *)((INT_PTR) s_text(y) & ~(sizeof(void *) - 1))); // Free the node
}}
STRINGNODE *newnode( char *s, int n ){ register STRINGNODE *newNode; // Pointer to new node
char *t; // String pointer
int d; // rounds to a dword boundary
d = n & (sizeof(void *) - 1) ? sizeof(void *) - (n & (sizeof(void *) - 1)) : 0; // offset to next dword past n
t = alloc(sizeof(STRINGNODE) + n + d); // Allocate string node
t += d; // END of string word-aligned
strncpy(t, s, n); // Copy string text
newNode = (STRINGNODE *)(t + n); // Set pointer to node
newNode->s_alt = NULL; // No alternates yet
newNode->s_suf = NULL; // No suffixes yet
newNode->s_must = n; // Set string length
return(newNode); // Return pointer to new node
}
STRINGNODE *reallocnode( STRINGNODE *node, char *s, int n ){ register char *cp; // Char pointer
assert(n <= node->s_must); // Node must not grow
waste += (unsigned)(node->s_must - n); // Add in wasted space
assert(sizeof(char *) == sizeof(int)); // Optimizer should eliminate this
cp = (char *)((INT_PTR) s_text(node) & ~(sizeof(void *) - 1)); // Point to start of text
node->s_must = n; // Set new length
if (n & (sizeof(void *) - 1)) cp += sizeof(void *) - (n & (sizeof(void *) - 1)); // Adjust non dword-aligned string
memmove(cp, s, n); // Copy new text
cp += n; // Skip over new text
memmove(cp, node, sizeof(STRINGNODE));// Copy the node
return((STRINGNODE *) cp); // Return pointer to moved node
}
/*** maketd1 - add entry for TD1 shift table
* * This function fills in the TD1 table for the given * search string. The idea is adapted from Daniel M. * Sunday's QuickSearch algorithm as described in an * article in the August 1990 issue of "Communications * of the ACM". As described, the algorithm is suitable * for single-string searches. The idea to extend it for * multiple search strings is mine and is described below. * * Think of searching for a match as shifting the search * pattern p of length n over the source text s until the * search pattern is aligned with matching text or until * the end of the source text is reached. * * At any point when we find a mismatch, we know * we will shift our pattern to the right in the * source text at least one position. Thus, * whenever we find a mismatch, we know the character * s[n] will figure in our next attempt to match. * * For some character c, TD1[c] is the 1-based index * from right to left of the first occurrence of c * in p. Put another way, it is the count of places * to shift p to the right on s so that the rightmost * c in p is aligned with s[n]. If p does not contain * c, then TD1[c] = n + 1, meaning we shift p to align * p[0] with s[n + 1] and try our next match there. * * Computing TD1 for a single string is easy: * * memset(TD1, n + 1, sizeof TD1); * for (i = 0; i < n; ++i) { * TD1[p[i]] = n - i; * } * * Generalizing this computation to a case where there * are multiple strings of differing lengths is trickier. * The key is to generate a TD1 that is as conservative * as necessary, meaning that no shift value can be larger * than one plus the length of the shortest string for * which you are looking. The other key is to realize * that you must treat each string as though it were only * as long as the shortest string. This is best illustrated * with an example. Consider the following two strings: * * DYNAMIC PROCEDURE * 7654321 927614321 * * The numbers under each letter indicate the values of the * TD1 entries if we computed the array for each string * separately. Taking the union of these two sets, and taking * the smallest value where there are conflicts would yield * the following TD1: * * DYNAMICPODURE * 7654321974321 * * Note that TD1['P'] equals 9; since n, the length of our * shortest string is 7, we know we should not have any * shift value larger than 8. If we clamp our shift values * to this value, then we get * * DYNAMICPODURE * 7654321874321 * * Already, this looks fishy, but let's try it out on * s = "DYNAMPROCEDURE". We know we should match on * the trailing procedure, but watch: * * DYNAMPROCEDURE * ^^^^^^^| * * Since DYNAMPR doesn't match one of our search strings, * we look at TD1[s[n]] == TD1['O'] == 7. Applying this * shift, we get * * DYNAMPROCEDURE * ^^^^^^^ * * As you can see, by shifting 7, we have gone too far, and * we miss our match. When computing TD1 for "PROCEDURE", * we must take only the first 7 characters, "PROCEDU". * Any trailing characters can be ignored (!) since they * have no effect on matching the first 7 characters of * the string. Our modified TD1 then becomes * * DYNAMICPODURE * 7654321752163 * * When applied to s, we get TD1[s[n]] == TD1['O'] == 5, * leaving us with * * DYNAMPROCEDURE * ^^^^^^^ * which is just where we need to be to match on "PROCEDURE". * * Going to this algorithm has speeded qgrep up on multi-string * searches from 20-30%. The all-C version with this algorithm * became as fast or faster than the C+ASM version of the old * algorithm. Thank you, Daniel Sunday, for your inspiration! * * Note: if we are case-insensitive, then we expect the input * string to be upper-cased on entry to this routine. * * Pete Stewart, August 14, 1990. */
voidmaketd1( unsigned char *pch, unsigned cch, unsigned cchstart ){ unsigned ch, ch1; // Character
unsigned i; // String index
unsigned char s[2];
s[1] = 0; if ((cch += cchstart) > cchmin) cch = cchmin; // Use smaller count
for (i = cchstart; i < cch; ++i) { // Examine each char left to right
ch = *pch++; // Get the character
for (;;) { // Loop to set up entries
if (ch < chmin) chmin = ch; // Remember if smallest
if (ch > chmax) chmax = ch; // Remember if largest
if (cchmin - i < (unsigned) td1[ch]) td1[ch] = (unsigned char)(cchmin - i); // Set value if smaller than previous
if (casesen || !isalpha(ch) || islower(ch)) break; // Exit loop if done
ch1 = ch; s[0] = (char)ch; ch = (unsigned char)(_strlwr((char*)s))[0]; // Force to lower case
if (ch1 == s[0]) // Lower case is the same to previous.
break; // Exit loop if done
} }}
static intnewstring( unsigned char *s, int n ){ register STRINGNODE *cur; // Current string
register STRINGNODE **pprev; // Pointer to previous link
STRINGNODE *newNode; // New string
int i; // Index
int j; // Count
int k; // Count
unsigned char c[2];
c[1] = 0;
if ( (unsigned)n < cchmin) cchmin = n; // Remember length of shortest string
if ((i = (UCHAR)transtab[*s]) == 0) { // If no existing list
// We have to start a new list
if ((i = clists++) >= TRTABLEN/2) error(MSG_FINDSTR_TOO_MANY_STRING_LISTS); //"Too many string lists");
// Die if too many string lists
stringlist[i] = NULL; // Initialize
transtab[*s] = (char) i; // Set pointer to new list
if (!casesen && isalpha(*s)) { c[0] = *s; if ((unsigned char)(_strlwr((char*)c))[0] != *s || (unsigned char)(_strupr((char*)c))[0] != *s) transtab[c[0]] = (char) i; // Set pointer for other case
} } else if (stringlist[i] == NULL) return(0); // Check for existing 1-byte string
if (--n == 0) { // If 1-byte string
freenode(stringlist[i]); // Free any existing stuff
stringlist[i] = NULL; // No record here
++strcnt; // We have a new string
return(1); // String added
} ++s; // Skip first char
pprev = stringlist + i; // Get pointer to link
cur = *pprev; // Get pointer to node
while(cur != NULL) { // Loop to traverse match tree
i = (n > cur->s_must)? cur->s_must: n; // Find minimum of string lengths
matchstrings((char *)s, s_text(cur), i, &j, &k); // Compare the strings
if (j == 0) { // If complete mismatch
if (k < 0) break; // Break if insertion point found
pprev = &(cur->s_alt); // Get pointer to alternate link
cur = *pprev; // Follow the link
} else if (i == j) { // Else if strings matched
if (i == n) { // If new is prefix of current
cur = *pprev = reallocnode(cur, s_text(cur), n); // Shorten text of node
if (cur->s_suf != NULL) { // If there are suffixes
freenode(cur->s_suf); // Suffixes no longer needed
cur->s_suf = NULL; ++strcnt; // Account for this string
} return(1); // String added
} pprev = &(cur->s_suf); // Get pointer to suffix link
if ((cur = *pprev) == NULL) return(0); // Done if current is prefix of new
s += i; // Skip matched portion
n -= i; } else { // Else partial match
// We must split an existing node.
// This is the trickiest case.
newNode = newnode(s_text(cur) + j, cur->s_must - j); // Unmatched part of current string
cur = *pprev = reallocnode(cur, s_text(cur), j); // Set length to matched portion
newNode->s_suf = cur->s_suf; // Current string's suffixes
if (k < 0) { // If new preceded current
cur->s_suf = newnode((char *)s + j, n - j); // FIrst suffix is new string
cur->s_suf->s_alt = newNode;// Alternate is part of current
} else { // Else new followed current
newNode->s_alt = newnode((char *)(s + j), n - j); // Unmatched new string is alternate
cur->s_suf = newNode; // New suffix list
} ++strcnt; // One more string
return(1); // String added
} } *pprev = newnode((char *)s, n); // Set pointer to new node
(*pprev)->s_alt = cur; // Attach alternates
++strcnt; // One more string
return(1); // String added
}
voidaddstring( char *s, int n ){ int endline; // Match-at-end-of-line flag
register char *pch; // Char pointer
endline = flags & ENDLINE; // Initialize flag
pch = target; // Initialize pointer
while(n-- > 0) { // While not at end of string
switch(*pch = *s++) { // Switch on character
case '\\': // Escape
if (n > 0 && !isalnum(*s)) { // If next character "special"
--n; // Decrement counter
*pch = *s++; // Copy next character
} ++pch; // Increment pointer
break;
default: // All others
if (IsDBCSLeadByte(*pch)) { --n; ++pch; // Increment pointer
*pch = *s++; } ++pch; // Increment pointer
break; } } if (endline) *pch++ = EOS; // Add end character if needed
targetlen = (int)(pch - target); // Compute target string length
if (!casesen) strnupr(target, targetlen); // Force to upper case if necessary
newstring((unsigned char *)target, targetlen); // Add string
}
intaddstrings( char *buffer, char *bufend, char *seplist ){ int len; // String length
char tmpbuf[MAXSTRLEN+2];
while(buffer < bufend) { // While buffer not empty
len = strnspn(buffer, seplist, (int)(bufend - buffer)); // Count leading separators
if ((buffer += len) >= bufend) { break; // Skip leading separators
} len = strncspn(buffer, seplist, (int)(bufend - buffer)); // Get length of search string
//
// We need to verify the length of the string before we call
// isexpr since the size of the buffer used is BUFLEN = 256
//
if (len >= MAXSTRLEN) error(MSG_FINDSTR_SEARCH_STRING_TOO_LONG);
if (addstr == NULL) { addstr = isexpr( (unsigned char *) buffer, len ) ? addexpr : addstring; // Select search string type
}
memcpy(tmpbuf, buffer, len); tmpbuf[len] = '\n'; tmpbuf[len+1] = 0;
if ( addstr == addexpr || (flags & BEGLINE) || findlist((unsigned char *)tmpbuf, tmpbuf + len + 1) == NULL) { // If no match within string
(*addstr)(buffer, len); // Add string to list
}
buffer += len; // Skip the string
} return(0); // Keep looking
}
intenumlist( STRINGNODE *node, int cchprev ){ int strcnt; // String count
strcnt = 0; // Initialize
while(node != NULL) { // While not at end of list
maketd1((unsigned char *)s_text(node), node->s_must, cchprev); // Make TD1 entries
#if DBG
if (flags & DEBUG) { // If verbose output wanted
int i; // Counter
for(i = 0; i < cchprev; ++i) fputc(' ', stderr); // Indent line
fwrite(s_text(node), sizeof(char), node->s_must, stderr); // Write this portion
fprintf(stderr, "\n"); // Newline
}#endif
strcnt += (node->s_suf != NULL) ? enumlist(node->s_suf, cchprev + node->s_must): 1; // Recurse to do suffixes
node = node->s_alt; // Do next alternate in list
} return (strcnt ? strcnt: 1); // Return string count
}
intenumstrings(){ unsigned char ch; // Character
unsigned i; // Index
int strcnt; // String count
strcnt = 0; // Initialize
for(i = 0; i < TRTABLEN; ++i) { // Loop through translation table
if (casesen || !isalpha(i) || !islower(i)) { // If case sensitive or not lower
if (transtab[i] == 0) continue; // Skip null entries
ch = (char) i; // Get character
maketd1((unsigned char *)&ch, 1, 0); // Make TD1 entry
#if DBG
if (flags & DEBUG) fprintf(stderr, "%c\n", i); // Print the first byte
#endif
strcnt += enumlist(stringlist[transtab[i]], 1); // Enumerate the list
} } return (strcnt); // Return string count
}
HANDLEopenfile( char *name ){ HANDLE fd; DWORD attr;
attr = GetFileAttributes(name);
if (attr != (DWORD) -1 && (attr & FILE_ATTRIBUTE_DIRECTORY)) return (HANDLE)-1;
// Skip offline files unless instructed otherwise
if (attr != (DWORD) -1 && (attr & FILE_ATTRIBUTE_OFFLINE) && !(flags & OFFLINE_FILES)) { fOfflineSkipped = TRUE; return (HANDLE)-1; }
if ((fd = CreateFile(name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_OPEN_NO_RECALL, NULL)) == (HANDLE)-1) {
printmessage(stderr, MSG_FINDSTR_CANNOT_OPEN_FILE, program, name); } return( fd ); // Return file descriptor
}
voidstartread( HANDLE fd, char *buffer, int buflen ){ if (bStdIn || bLargeFile) { arrc = ReadFile(fd,(PVOID)buffer, buflen, &cbread, NULL); }}
intfinishread(){ return(arrc ? cbread : -1); // Return number of bytes read
}
voidstartwrite( HANDLE fd, char *buffer, int buflen){ awrc = WriteFile(fd,(PVOID)buffer, buflen, &cbwrite, NULL); return;}
intfinishwrite(){ return(awrc ? cbwrite : -1); // Return number of bytes written
}
BOOLCtrlHandler(DWORD CtrlType){ // We'll handle Ctrl-C events
switch(CtrlType) { case CTRL_C_EVENT: case CTRL_BREAK_EVENT: if (csbi.wAttributes) { EnterCriticalSection(&critSection); fExiting = TRUE; SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), csbi.wAttributes); LeaveCriticalSection(&critSection); } break; }
// Deal with all other events as normal
return (FALSE);}
voidwrite1nobuf( char *buffer, int buflen, WORD wAttributes ){ int nT; CBIO cb; // Count of bytes written
BOOL fCR; BOOL fLF; char buf[STKLEN]; char *szT; static HANDLE hConOut = INVALID_HANDLE_VALUE; int remaining_length;
// Get the console screen buffer info if we haven't yet.
if (hConOut == INVALID_HANDLE_VALUE) { hConOut = GetStdHandle(STD_OUTPUT_HANDLE); InitializeCriticalSection(&critSection); SetConsoleCtrlHandler((PHANDLER_ROUTINE)CtrlHandler, TRUE); }
if (wAttributes) { EnterCriticalSection(&critSection); // if not exiting, highlight the output
if (!fExiting) SetConsoleTextAttribute(hConOut, wAttributes); LeaveCriticalSection(&critSection); if (fExiting) ExitProcess(2); }
remaining_length = buflen;
while (remaining_length) {
buflen = (int)min(sizeof(buf) / sizeof(buf[0]), remaining_length); szT = buf;
if (IsDBCSCodePage) { memcpy(buf, buffer, buflen); } else { for(nT = 0; nT < buflen; nT++) { *(szT++) = ((isprint((unsigned char)buffer[nT]) || isspace((unsigned char)buffer[nT])) ? buffer[nT] : '.'); } }
if (!WriteFile(hConOut, (PVOID)buf, buflen, &cb, NULL) || (cb != (CBIO)(buflen))) { SetConsoleTextAttribute(hConOut, csbi.wAttributes); error(MSG_FINDSTR_WRITE_ERROR); // Die if write fails
} remaining_length -= buflen; buffer += buflen; }
if (wAttributes) SetConsoleTextAttribute(hConOut, csbi.wAttributes);}
voidwrite1buf( char *buffer, int buflen, WORD wAttributes ){ register int cb; // Byte count
while(buflen > 0) { // While bytes remain
if (!awrc) { // If previous write failed
printmessage(stderr, MSG_FINDSTR_WRITE_ERROR, program); // Print error message
exit(2); // Die
} if ((cb = ocnt[oi]) == 0) { // If buffer full
startwrite( GetStdHandle( STD_OUTPUT_HANDLE ), obuf[oi], OUTBUFLEN ); // Write the buffer
ocnt[oi] = OUTBUFLEN; // Reset count and pointer
optr[oi] = obuf[oi]; oi ^= 1; // Switch buffers
cb = ocnt[oi]; // Get space remaining
} if (cb > buflen) cb = buflen; // Get minimum
memmove(optr[oi], buffer, cb); // Copy bytes to buffer
ocnt[oi] -= cb; // Update buffer length and pointers
optr[oi] += cb; buflen -= cb; buffer += cb; }}
voidflush1nobuf( void ){ ;}
voidflush1buf( void ){ register int cb; // Byte count
if ((cb = OUTBUFLEN - ocnt[oi]) > 0) { // If buffer not empty
startwrite( GetStdHandle( STD_OUTPUT_HANDLE ), obuf[oi], cb ); // Start write
if (finishwrite() != cb) { // If write failed
printmessage(stderr, MSG_FINDSTR_WRITE_ERROR, program); // Print error message
exit(2); // Die
} }}
intgrepbuffer( char *startbuf, char *endbuf, char *name ){ char *cp; // Buffer pointer
char *lastmatch; // Last matching line
int linelen; // Line length
int namlen = 0; // Length of name
char lnobuf[LNOLEN]; // Line number buffer
char nambuf[PATHLEN]; // Name buffer
cp = startbuf; // Initialize to start of buffer
lastmatch = cp; // No previous match yet
while((cp = (*find)((unsigned char *)cp, endbuf)) != NULL) { // While matches are found
--cp; // Back up to previous character
// Take care of '\n' as an artificial newline before line 1.
if ((flags & BEGLINE) && (bStdIn || bLargeFile || cp >= BaseByteAddress) && *cp != '\n' ) { // If begin line conditions not met
cp += strncspn(cp, "\n", (int)(endbuf - cp)) + 1; // Skip line
continue; // Keep looking
} status = 0; // Match found
if (flags & NAMEONLY) return(1); // Return if filename only wanted
cp -= preveol(cp) - 1; // Point at start of line
if (flags & SHOWNAME) { // If name wanted
if (namlen == 0) { // If name not formatted yet
namlen = sprintf(nambuf, "%s:", name); // Format name if not done already
} (*write1)(nambuf, namlen, wAttrib); // Show name
} if (flags & LINENOS) { // If line number wanted
lineno += countlines(lastmatch, cp); // Count lines since last match
(*write1)(lnobuf, sprintf(lnobuf, "%u:", lineno), wAttrib); // Print line number
lastmatch = cp; // New last match
} if (flags & SEEKOFF) { // If seek offset wanted
(*write1)(lnobuf, sprintf(lnobuf, "%lu:", cbfile + (long)(cp - startbuf)), wAttrib); // Print seek offset
} linelen = strncspn(cp, "\n", (int)(endbuf - cp)) + 1; // Calculate line length
if (linelen > endbuf - cp) { linelen = (int)(endbuf - cp); } (*write1)(cp, linelen, 0); // Print the line
cp += linelen; // Skip the line
} lineno += countlines(lastmatch, endbuf); // Count remaining lines in buffer
return(0); // Keep searching
}
voidshowv( char *name, char *startbuf, char *lastmatch, char *thismatch ){ register int linelen; int namlen = 0; // Length of name
char lnobuf[LNOLEN]; // Line number buffer
char nambuf[PATHLEN];// Name buffer
if (flags & (SHOWNAME | LINENOS | SEEKOFF)) { while(lastmatch < thismatch) { if (flags & SHOWNAME) { // If name wanted
if (namlen == 0) { // If name not formatted yet
namlen = sprintf(nambuf, "%s:", name); // Format name if not done already
} (*write1)(nambuf, namlen, wAttrib); // Write the name
} if (flags & LINENOS) // If line numbers wanted
{ (*write1)(lnobuf, sprintf(lnobuf, "%u:", lineno++), wAttrib); // Print the line number
} if (flags & SEEKOFF) { // If seek offsets wanted
(*write1)(lnobuf, sprintf(lnobuf, "%lu:", cbfile + (long)(lastmatch - startbuf)), wAttrib); // Print the line number
} linelen = strncspn(lastmatch, "\n", (int)(thismatch - lastmatch)); // If there's room for the '\n' then pull it in. Otherwise
// the buffer doesn't have a '\n' within the range here.
if (linelen < thismatch - lastmatch) { linelen++; } (*write1)(lastmatch, linelen, 0); lastmatch += linelen; } } else (*write1)(lastmatch, (int)(thismatch - lastmatch), 0);}
intgrepvbuffer( char *startbuf, char *endbuf, char *name ){ char *cp; // Buffer pointer
char *lastmatch; // Pointer to line after last match
cp = startbuf; // Initialize to start of buffer
lastmatch = cp; while((cp = (*find)((unsigned char *)cp, endbuf)) != NULL) { --cp; // Back up to previous character
// Take care of '\n' as an artificial newline before line 1.
if ((flags & BEGLINE) && (bStdIn || bLargeFile || cp >= BaseByteAddress) && *cp != '\n') { // If begin line conditions not met
cp += strncspn(cp, "\n", (int)(endbuf - cp)) + 1; // Skip line
continue; // Keep looking
} cp -= preveol(cp) - 1; // Point at start of line
if (cp > lastmatch) { // If we have lines without matches
status = 0; // Lines without matches found
if (flags & NAMEONLY) return(1); // Skip rest of file if NAMEONLY
showv(name, startbuf, lastmatch, cp); // Show from last match to this
} cp += strncspn(cp, "\n", (int)(endbuf - cp)) + 1; // Skip over line with match
lastmatch = cp; // New "last" match
++lineno; // Increment line count
} if (endbuf > lastmatch) { // If we have lines without matches
status = 0; // Lines without matches found
if (flags & NAMEONLY) return(1); // Skip rest of file if NAMEONLY
showv(name, startbuf, lastmatch, endbuf); // Show buffer tail
} return(0); // Keep searching file
}
voidqgrep( int (*grep)( char *, char *, char * ), char *name, HANDLE fd ){ register int cb; // Byte count
char *cp; // Buffer pointer
char *endbuf; // End of buffer
int taillen; // Length of buffer tail
int bufi; // Buffer index
HANDLE MapHandle; // File mapping handle
BOOL grep_result;
cbfile = 0L; // File empty so far
lineno = 1; // File starts on line 1
taillen = 0; // No buffer tail yet
bufi = 0; // Initialize buffer index
cp = bufptr[0]; // Initialize to start of buffer
bStdIn = (fd == GetStdHandle(STD_INPUT_HANDLE));
// If fd is not std-input, use file mapping object method.
if (!bStdIn) { DWORD cbread_high;
if ((((cbread = (CBIO)GetFileSize(fd, &cbread_high)) == -1) && (GetLastError() != NO_ERROR)) || (cbread == 0 && cbread_high == 0)) { return; // skip the file
}
if (cbread_high) { bLargeFile = TRUE; // too large to map and even if it succeed in mapping like under ia64, it
// will probably fail in pointer arithmetics
} else { MapHandle = CreateFileMapping(fd, NULL, PAGE_READONLY, 0L, 0L, NULL); if (MapHandle == NULL) { printmessage(stderr, MSG_FINDSTR_CANNOT_CREATE_FILE_MAPPING, program); return; }
BaseByteAddress = (char *) MapViewOfFile(MapHandle, FILE_MAP_READ, 0L, 0L, 0); CloseHandle(MapHandle); if (BaseByteAddress == NULL) { bLargeFile = TRUE; // use alternate method
} else { cp = bufptr[0] = BaseByteAddress; arrc = TRUE; } }
}
if (bStdIn || bLargeFile) { // Reset buffer pointers since they might have been changed.
cp = bufptr[0] = filbuf + 4;
arrc = ReadFile(fd, (PVOID)cp, FILBUFLEN, &cbread, NULL); }
if (flags & PRINTABLE_ONLY) { unsigned char *s; unsigned long n;
s = (unsigned char *)cp; n = cbread; while (--n) { if (*s < ' ') {
// If not backspace, tab, CR, LF, FF or Ctrl-Z then not a printable character.
if (strchr("\b\t\v\r\n\f\032", *s) == NULL) { goto skipfile; } }
s += 1; } }
// Note: if FILEMAP && !bStdIn, 'while' is executed once(taillen is 0).
while((cb = finishread()) + taillen > 0) { // While search incomplete
if (bStdIn || bLargeFile) { if (cb == -1) { // If buffer tail is all that's left
*cp++ = '\r'; // Add end of line sequence
*cp++ = '\n'; endbuf = cp; // Note end of buffer
taillen = 0; // Set tail length to zero
} else { // Else start next read
taillen = preveol(cp + cb - 1); // Find length of partial line
endbuf = cp + cb - taillen; // Get pointer to end of buffer
cp = bufptr[bufi ^ 1]; // Pointer to other buffer
memmove(cp, endbuf, taillen); // Copy tail to head of other buffer
cp += taillen; // Skip over tail
if (taillen > (FILBUFLEN/2)) { if (taillen >= FILBUFLEN) {
char tmp[15];
cbfile += taillen; taillen = 0; cp = bufptr[bufi^1]; startread(fd, cp, FILBUFLEN); _ultoa((unsigned long)lineno, tmp, 10); printmessage(stderr, MSG_FINDSTR_LINE_TOO_LONG, program, tmp); } else startread(fd, cp, (FILBUFLEN - taillen)); } else startread(fd, cp, (FILBUFLEN - taillen) & (~0 << LG2SECLEN)); // Start next read
} } else { endbuf = cp + cb - taillen; // Get pointer to end of buffer
// Cause 'while' to terminate(since no next read is needed.)
cbread = 0; arrc = TRUE; }
__try { grep_result = (*grep)(bufptr[bufi], endbuf, name); } __except( GetExceptionCode() == EXCEPTION_IN_PAGE_ERROR ) { printmessage(stderr, MSG_FINDSTR_READ_ERROR, program, name); break; }
if (grep_result) { // If rest of file can be skipped
(*write1)(name, strlen(name), 0); // Write file name
(*write1)("\r\n", 2, 0); // Write newline sequence
if (!bStdIn && !bLargeFile) { if (BaseByteAddress != NULL) UnmapViewOfFile(BaseByteAddress); }
return; // Skip rest of file
}
cbfile += (long)(endbuf - bufptr[bufi]); // Increment count of bytes in file
bufi ^= 1; // Switch buffers
}
skipfile: if (!bStdIn && !bLargeFile) { if (BaseByteAddress != NULL) UnmapViewOfFile(BaseByteAddress); }}
char *rmpath( char *name ){ char *cp; // Char pointer
if (name[0] != '\0' && name[1] == ':') name += 2; // Skip drive spec if any
cp = name; // Point to start
while(*name != '\0') { // While not at end
++name; // Skip to next character
if (name[-1] == '/' || name[-1] == '\\') cp = name; // Point past path separator
} return(cp); // Return pointer to name
}
voidprepend_path( char* file_name, char* path ){ int path_len; char* last;
// First figure out how much of the path to take.
// Check for the last occurance of '\' if there is one.
#ifdef FE_SB
// DBCS tailbytes can contain '\' character. Use MBCS function.
last = _mbsrchr(path, '\\');#else
last = strrchr(path, '\\');#endif
if (last) { path_len = (int)(last - path) + 1; } else if (path[1] == ':') { path_len = 2; } else { path_len = 0; }
memmove(file_name + path_len, file_name, strlen(file_name) + 1); memmove(file_name, path, path_len);}
voidConvertAppToOem( unsigned argc, char* argv[] )/*++
Routine Description:
Converts the command line from ANSI to OEM, and force the app to use OEM APIs
Arguments:
argc - Standard C argument count.
argv - Standard C argument strings.
Return Value:
None.
--*/
{ unsigned i;
for( i=0; i<argc; i++ ) { CharToOem( argv[i], argv[i] ); } SetFileApisToOEM();}
int __cdeclmain( int argc, char **argv ){ char *cp; char *cpaddstrings[MAX_SLASH_C_OPTION]; int add_string_count = 0; char *dirlist = NULL;
HANDLE fd;
FILE *fi; int fsubdirs; // Search subdirectories
int i; int j; char *inpfile = NULL; char *strfile = NULL; unsigned long tstart; // Start time
char filnam[MAX_PATH+1]; WIN32_FIND_DATA find_data; HANDLE find_handle;#ifdef FE_SB
LANGID LangId;#endif
char *locale; BOOLEAN option_L_specified = FALSE; BOOLEAN option_R_specified = FALSE;
ConvertAppToOem( argc, argv ); tstart = clock(); // Get start time
GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi); // Default color: just add intensity
wAttrib = csbi.wAttributes | FOREGROUND_INTENSITY;
memset(cpaddstrings, 0, sizeof(cpaddstrings));
#ifdef FE_SB
//
// Set TEB's language ID to correspond to the console output code page. This
// will ensure the correct language message is displayed when FormatMessage is
// called.
//
switch (GetConsoleOutputCP()) { case 932: LangId = MAKELANGID( LANG_JAPANESE, SUBLANG_DEFAULT ); break; case 949: LangId = MAKELANGID( LANG_KOREAN, SUBLANG_KOREAN ); break; case 936: LangId = MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED ); break; case 950: LangId = MAKELANGID( LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL ); break; default: LangId = PRIMARYLANGID(LANGIDFROMLCID( GetUserDefaultLCID() )); if (LangId == LANG_JAPANESE || LangId == LANG_KOREAN || LangId == LANG_CHINESE ) { LangId = MAKELANGID( LANG_ENGLISH, SUBLANG_ENGLISH_US ); } else { LangId = MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ); } IsDBCSCodePage = FALSE; break; }
SetThreadLocale( MAKELCID(LangId, SORT_DEFAULT) );
if ((locale = setlocale(LC_ALL, ".OCP")) == NULL) {
UINT Codepage;
if (Codepage = GetConsoleOutputCP()) {
char achCodepage[10];
wsprintfA(achCodepage, ".%3.4d", Codepage); if ((locale = setlocale(LC_ALL, achCodepage)) == NULL) { error(MSG_FINDSTR_UNABLE_TO_SET_LOCALE); } } else error(MSG_FINDSTR_UNABLE_TO_SET_LOCALE); }#endif
asyncio = pmode = 1; // Do asynchronous I/O
// program = rmpath(argv[0]); // Set program name
program ="FINDSTR";
memset(td1, 1, TRTABLEN); // Set up TD1 for startup
flags = 0;
_setmode(_fileno(stdout), O_BINARY); // No linefeed translation on output
_setmode(_fileno(stderr), O_BINARY); // No linefeed translation on output
fsubdirs = 0;
for(i = 1; i < argc && (argv[i][0] == '/' || argv[i][0] == '-'); ++i) { for(cp = &argv[i][1]; *cp != '\0'; ++cp) { switch(*cp) { case '?': printmessage(stdout, MSG_FINDSTR_USAGE, NULL); // Verbose usage message
exit(0);
case 'b': case 'B': flags |= BEGLINE; break;
case 'e': case 'E': flags |= ENDLINE; break;
case 'i': case 'I': casesen = 0; // case-insensitive search
break;
case 'l': case 'L': addstr = addstring; // Treat strings literally
option_L_specified = TRUE; break;
case 'm': case 'M': flags |= NAMEONLY; break;
case 'n': case 'N': flags |= LINENOS; break;
case 'o': case 'O': // Check whether this is an /o or /offline switch
if (0 == _stricmp(cp, "OFFLINE")) { flags |= OFFLINE_FILES; cp += (lstrlen( "OFFLINE" ) - 1); } else if (0 == _stricmp(cp, "OFF")) { flags |= OFFLINE_FILES; cp += (lstrlen( "OFF" ) - 1); } else { flags |= SEEKOFF; } break;
case 'p': case 'P': flags |= PRINTABLE_ONLY; break;
case 'r': case 'R': addstr = addexpr; // Add expression to list
option_R_specified = TRUE; break;
case 's': case 'S': fsubdirs = 1; break;
case 'v': case 'V': grep = grepvbuffer; break;
case 'x': case 'X': flags |= BEGLINE | ENDLINE; break;
#if DBG
case 'd': // This is kinda cheezy, but I didn't want to change the
// debug flag as it's been here a while and I couldn't come
// up with a different flag for the dirlist, so...
if (*(cp + 1) == ':') { *cp-- = 'D'; break; } flags |= DEBUG; break;
case 't': flags |= TIMER; break;#endif
default: { int cch; char chSwitch; char tmp[3];
chSwitch = *cp;
if (*(cp + 1) == ':') { if (!*(cp + 2)) { tmp[0]=chSwitch; tmp[1]='\0'; printmessage(stderr, MSG_FINDSTR_ARGUMENT_MISSING, program, tmp); exit(2); }
cp += 2; // Point to string
cch = lstrlen(cp); switch(chSwitch) { case 'd': case 'D': dirlist = cp; cp += cch - 1; continue;
case 'c': case 'C': // Add it after we've gone through all the flags
// don't add it now as things may change with
// later flags
addstr = addstring; // Treat strings literally
if (add_string_count >= MAX_SLASH_C_OPTION) { error(MSG_FINDSTR_TOO_MANY_SLASH_C_OPTION); } cpaddstrings[add_string_count++] = cp; cp += cch - 1; continue;
case 'g': case 'G': // Patterns in file
case 'f': case 'F': // Names of files to search in file
if (chSwitch == 'f' || chSwitch == 'F') inpfile = cp; else strfile = cp; cp += cch - 1; continue;
case 'a': case 'A': wAttrib = 0; for(; *cp && isxdigit(*cp); ++cp) {
int digit = (int) (*cp <= TEXT('9')) ? (int)*cp - (int)'0' : (int)tolower(*cp)-(int)'W';
wAttrib = (wAttrib << 4) + digit; } cp--; continue;
default: cp += cch - 1; // break out and spit out the switch ignored msg
break; } }
tmp[0]='/'; tmp[1]=chSwitch; tmp[2]='\0'; printmessage(stderr, MSG_FINDSTR_SWITCH_IGNORED, program, tmp); break; } } } } // for( i=1; )
if (option_L_specified && option_R_specified) error(MSG_FINDSTR_CONFLICTING_OPTIONS_LR); else if (option_L_specified) addstr = addstring; else if (option_R_specified) addstr = addexpr;
// Explicit string (no separators). Add string "as is"
if (add_string_count) { for (j=0; j<add_string_count && cpaddstrings[j]; j++) addstrings( cpaddstrings[j], cpaddstrings[j] + lstrlen(cpaddstrings[j]), "" ); }
if (i == argc && strcnt == 0 && strfile == NULL) error(MSG_FINDSTR_BAD_COMMAND_LINE);
bufptr[0][-1] = bufptr[1][-1] = '\n'; // Mark beginnings with newline
// Note: 4-Dec-90 w-barry Since there currently exists no method to query a
// handle with the Win32 api (no equivalent to
// DosQueryHType() ), the following piece of code
// replaces the commented section.
if (_isatty(_fileno(stdout))) { // If stdout is a device
write1 = write1nobuf; // Use unbuffered output
flush1 = flush1nobuf; }
// /*
// * Check type of handle for std. out.
// */
// if (DosQueryHType(fileno(stdout),(PPARM) &j,(PPARM) &fd) != NO_ERROR)
// {
// error("Standard output bad handle");
// }
// // Die if error
// if (j != 0 && (fd & ISCOT)) // If handle is console output
//#else
// filbuf[3] = '\n'; // Mark beginning with newline
// if (isatty(fileno(stdout))) // If stdout is a device
//#endif
// {
// write1 = write1nobuf; // Use unbuffered output
// flush1 = flush1nobuf;
// }
if (strfile != NULL) { // If strings from file
if ((strcmp(strfile, "/") != 0) && (strcmp(strfile, "-") != 0)) { // If strings not from std. input
if ( ( fd = CreateFile( strfile, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL ) ) == (HANDLE)-1 ) { // If open fails
printmessage(stderr, MSG_FINDSTR_CANNOT_READ_STRINGS, program, strfile); exit(2); // Die
} }else { fd = GetStdHandle( STD_INPUT_HANDLE ); // Else use std. input
} qgrep( addstrings, "\r\n", fd );// Do the work
if ( fd != GetStdHandle( STD_INPUT_HANDLE ) ) { CloseHandle( fd ); // Close strings file
} } else if (strcnt == 0) { // Else if strings on command line
cp = argv[i++]; // Set pointer to strings
addstrings(cp, cp + strlen(cp), " \t"); // Add strings to list
}
if (strcnt == 0) error(MSG_FINDSTR_NO_SEARCH_STRINGS); // Die if no strings
if (addstr != addexpr) { // If not using expressions
memset(td1, cchmin + 1, TRTABLEN);// Initialize table
find = findlist; // Assume finding many
if ((j = enumstrings()) != strcnt) {
char t1[15], t2[15];
_itoa(j, t1, 10); _itoa(strcnt, t2, 10); printmessage(stderr, MSG_FINDSTR_STRING_COUNT_ERROR, t1, t2); }
// Enumerate strings and verify count
#if DBG
if (flags & DEBUG) { // If debugging output wanted
fprintf(stderr, "%u bytes wasted in heap\n", waste); // Print storage waste
assert(chmin <= chmax); // Must have some entries
fprintf(stderr, "chmin = %u, chmax = %u, cchmin = %u\n", chmin, chmax, cchmin); // Print range info
for (j = (int)chmin; j <= (int)chmax; ++j) { // Loop to print TD1 table
if ( td1[j] <= (char)cchmin ) { // If not maximum shift
if (isascii(j) && isprint(j)) fprintf(stderr, "'%c'=%2u ", j, td1[j]); // Show literally if printable
else fprintf(stderr, "\\%02x=%2u ", j, td1[j]); // Else show hex value
} } fprintf(stderr, "\n"); }#endif
if (strcnt == 1 && casesen) find = findone; // Find one case-sensitive string
} else if (find == NULL) { find = findexpr; // Else find expressions
}
if (inpfile != NULL) { // If file list from file
flags |= SHOWNAME; // Always show name of file
if ((strcmp(inpfile, "/") != 0) && (strcmp(inpfile, "-") != 0)) { if ((fi = fopen(inpfile, "r")) == NULL) { // If open fails
printmessage(stderr, MSG_FINDSTR_CANNOT_READ_FILE_LIST, program, inpfile); exit(2); // Error exit
} } else fi = stdin; // Else read file list from stdin
while(fgets(filnam, MAX_PATH+1, fi) != NULL) { // While there are names
filnam[strcspn(filnam, "\r\n")] = '\0'; // Null-terminate the name
if ((fd = openfile(filnam)) == (HANDLE)-1) { continue; // Skip file if it cannot be opened
} qgrep(grep, filnam, fd); // Do the work
CloseHandle( fd ); }
if (fi != stdin) fclose(fi); // Close the list file
} else if (i == argc) { flags &= ~(NAMEONLY | SHOWNAME); qgrep( grep, NULL, GetStdHandle( STD_INPUT_HANDLE ) ); }
if (argc > i + 1 || fsubdirs || has_wild_cards(argv[i])) flags |= SHOWNAME;
if (dirlist && *dirlist) { char *dir; char *dirend = (char *)-1; char *original_current_directory = NULL; DWORD size;
size = GetCurrentDirectory(0, NULL); if (size) { original_current_directory = (PCHAR)malloc(size); if (original_current_directory == NULL) { printmessage(stderr, MSG_FINDSTR_OUT_OF_MEMORY, program); exit(2); } size = GetCurrentDirectory(size, original_current_directory); }
if (!size) { free(original_current_directory); printmessage(stderr, MSG_FINDSTR_UNABLE_TO_GET_CURRENT_DIRECTORY, program); exit(2); }
for(dir = dirlist; dirend; dir = dirend + 1) {
if (dirend = strchr(dir, ';')) *dirend = 0;
if (*dir) { (*write1)(" ", 2, wAttrib); // Indent a couple of spaces
(*write1)(dir, lstrlen(dir), wAttrib); // Show name
(*write1)(":\r\n", 3, wAttrib); // Write newline sequence
if (!SetCurrentDirectory(original_current_directory)) { free(original_current_directory); printmessage(stderr, MSG_FINDSTR_CANNOT_OPEN_FILE, program, original_current_directory); exit(2); } if (!SetCurrentDirectory(dir)) { printmessage(stderr, MSG_FINDSTR_CANNOT_OPEN_FILE, program, dir); } else { while (filematch(filnam, argv + i, argc - i, fsubdirs) >= 0) {#ifdef FE_SB
// _mbslwr((unsigned char *)filnam);
#else
// _strlwr(filnam);
#endif
if ((fd = openfile(filnam)) != (HANDLE)-1) { qgrep(grep, filnam, fd); CloseHandle( fd ); } } } } } free(original_current_directory); } else if (fsubdirs && argc > i) { // If directory search wanted
while (filematch(filnam, argv + i, argc - i, fsubdirs) >= 0) {#ifdef FE_SB
// _mbslwr((unsigned char *)filnam);
#else
// _strlwr(filnam);
#endif
if ((fd = openfile(filnam)) == (HANDLE)-1) { continue; }
qgrep(grep, filnam, fd); CloseHandle( fd ); } } else { // Else search files specified
for(; i < argc; ++i) {#ifdef FE_SB
// _mbslwr((unsigned char *) argv[i]);
#else
// _strlwr(argv[i]);
#endif
find_handle = FindFirstFile(argv[i], &find_data); if (find_handle == INVALID_HANDLE_VALUE) { printmessage(stderr, MSG_FINDSTR_CANNOT_OPEN_FILE, program, argv[i]); continue; }
do {
#ifdef FE_SB
// _mbslwr((unsigned char *)find_data.cFileName);
#else
// _strlwr(find_data.cFileName);
#endif
prepend_path(find_data.cFileName, argv[i]); fd = openfile(find_data.cFileName);
if (fd != INVALID_HANDLE_VALUE) { qgrep(grep, find_data.cFileName, fd); CloseHandle( fd ); } } while (FindNextFile(find_handle, &find_data)); } }
(*flush1)();
#if DBG
if ( flags & TIMER ) { // If timing wanted
unsigned long tend;
tend = clock(); tstart = tend - tstart; // Get time in milliseconds
fprintf(stderr, "%lu.%03lu seconds\n", ( tstart / CLK_TCK ), ( tstart % CLK_TCK ) ); // Print total elapsed time
}#endif
// Print warning in case that offline files were skipped
if (fOfflineSkipped) { printmessage(stderr, MSG_FINDSTR_OFFLINE_FILE_SKIPPED, program); }
return( status );} // main
char * findsub( unsigned char *, char * );char * findsubi( unsigned char *, char * );
char * (*flworker[])(unsigned char *, char *) = { // Table of workers
findsubi, findsub};
char *strnupr( char *pch, int cch ){ char c[2];
#ifdef FE_SB
int max = cch; c[1] = 0; for ( cch = 0; cch < max; cch++ ) {#else
c[1] = 0; while (cch-- > 0) { // Convert string to upper case
#endif
if (isalpha((unsigned char)pch[cch])) { c[0] = pch[cch]; pch[cch] = (_strupr(c))[0]; }#ifdef FE_SB
else if (IsDBCSCodePage && IsDBCSLeadByte(pch[cch])) cch++;#endif
} return(pch);}
/*
* This is an implementation of the QuickSearch algorith described * by Daniel M. Sunday in the August 1990 issue of CACM. The TD1 * table is computed before this routine is called. */
char *findone( unsigned char *buffer, char *bufend ){#ifdef FE_SB // Starting position of string for checking 2nd bytes of DBCS characters.
unsigned char *bufferhead = buffer;#endif
if ((bufend -= targetlen - 1) <= (char *) buffer) return((char *) 0); // Fail if buffer too small
while (buffer < (unsigned char *) bufend) { // While space remains
int cch; // Character count
register char *pch1; // Char pointer
register char *pch2; // Char pointer
pch1 = target; // Point at pattern
pch2 = (char *) buffer; // Point at buffer
#ifdef FE_SB
// If buffer points to the 2nd byte of a DBCS character,
// skip to next compare position.
if ( !IsTailByte( bufferhead, (int)(buffer - bufferhead) ) ) {#endif
for (cch = targetlen; cch > 0; --cch) { // Loop to try match
if (*pch1++ != *pch2++) break; // Exit loop on mismatch
} if (cch == 0) return((char *)buffer); // Return pointer to match
#ifdef FE_SB
}#endif
if (buffer + 1 < (unsigned char *) bufend) // Make sure buffer[targetlen] is valid.
buffer += ((unsigned char)td1[buffer[targetlen]]); // Skip ahead
else break; } return((char *) 0); // No match
}
intpreveol( char *s ){ register char *cp; // Char pointer
cp = s + 1; // Initialize pointer
if (!bStdIn && !bLargeFile) { while((--cp >= BaseByteAddress) && (*cp != '\n')) ; // Find previous end-of-line
} else { while(*--cp != '\n') ; // Find previous end-of-line
}
return (int)(s - cp); // Return distance to match
}
intcountlines( char *start, char *finish ){ register int count; // Line count
for(count = 0; start < finish; ) { // Loop to count lines
if (*start++ == '\n') ++count; // Increment count if linefeed found
} return(count); // Return count
}
char *findlist( unsigned char *buffer, char *bufend ){ char *match; // Pointer to matching string
// Avoid writting to bufend. bufend[-1] is something(such as '\n') that is not
// part of search and will cause the search to stop.
match = (*flworker[casesen])(buffer, bufend); // Call worker
return(match); // Return matching string
}
char *findsub( unsigned char *buffer, char *bufend ){ register char *cp; // Char pointer
STRINGNODE *s; // String node pointer
int i; // Index
#ifdef FE_SB // Head of buffer for checking if a certain offset is the 2nd byte of a DBCS character.
unsigned char *bufhead = buffer;#endif
char *real_bufend = bufend;
if (cchmin != (unsigned)-1 && cchmin != 0 && (bufend -= cchmin - 1) < (char *) buffer) return((char *) 0); // Compute effective buffer length
while(buffer < (unsigned char *) bufend) { // Loop to find match
#ifdef FE_SB
// Search cannot start at the second byte of a DBCS character,
// so check for it and skip it if it is a second byte.
if ((i = (UCHAR)transtab[*buffer]) != 0 && !IsTailByte( bufhead, (int)(buffer-bufhead) ) ) {#else
if ((i = (UCHAR)transtab[*buffer]) != 0) {#endif
// If valid first character
if ((s = stringlist[i]) == 0) { return((char *)buffer); // Check for 1-byte match
}
for(cp = (char *) buffer + 1; (real_bufend - cp) >= s->s_must; ) { // Loop to search list
if ((i = _strncoll(cp, s_text(s), s->s_must)) == 0) { // If portions match
cp += s->s_must; // Skip matching portion
if ((s = s->s_suf) == 0) return((char *)buffer); // Return match if end of list
continue; // Else continue
}
if (i < 0 || (s = s->s_alt) == 0) { break; // Break if not in this list
} } }
if (buffer + 1 < (unsigned char *) bufend) // Make sure buffer[cchmin] is valid.
if (cchmin == (unsigned)-1) buffer++; else buffer += ((unsigned char)td1[buffer[cchmin]]); // Shift as much as possible
else break; } return((char *) 0); // No match
}
char *findsubi( unsigned char *buffer, char *bufend ){ register char *cp; // Char pointer
STRINGNODE *s; // String node pointer
int i; // Index
#ifdef FE_SB
// Keep head of buffer for checking if a certain offset is the 2nd byte of
// a DBCS character.
unsigned char *bufhead = buffer;#endif
if (cchmin != (unsigned)-1 && cchmin != 0 && (bufend -= cchmin - 1) < (char *) buffer) return((char *) 0); // Compute effective buffer length
while(buffer < (unsigned char *) bufend) { // Loop to find match
#ifdef FE_SB
// Search cannot start at the second byte of a DBCS character, so check for it
// and skip it if it is a second byte.
if ((i = (UCHAR)transtab[*buffer]) != 0 && !IsTailByte( bufhead, (int)(buffer-bufhead) ) ) { // If valid first character
BOOL TailByte; // Flag to check if 1st char is leadbyte.
#else
if ((i = (UCHAR)transtab[*buffer]) != 0) { // If valid first character
#endif
if ((s = stringlist[i]) == 0) return((char *) buffer); // Check for 1-byte match
#ifdef FE_SB
// Same leadbytes with tailbytes such as 0x41 and 0x61 will become the same
// character, so become aware of it and use the multibyte function.
//
// Check if buffer+1 is a tailbyte character.
//
TailByte = IsTailByte(buffer, 1);
for(cp = (char *) buffer + 1; ; ) { // Loop to search list
if ((i = _mbsnicmp((unsigned char *)cp, (unsigned char *) s_text(s), s->s_must, &TailByte)) == 0) {#else
for(cp = (char *) buffer + 1; ; ) { // Loop to search list
if ((i = memicmp(cp, s_text(s), s->s_must)) == 0) {#endif
// If portions match
cp += s->s_must; // Skip matching portion
if ((s = s->s_suf) == 0) return((char *) buffer); // Return match if end of list
continue; // And continue
} if (i < 0 || (s = s->s_alt) == 0) break; // Break if not in this list
} }
if (buffer + 1 < (unsigned char *) bufend) // Make sure buffer[cchmin] is valid.
if (cchmin == (unsigned)-1) buffer++; else buffer += ((unsigned char)td1[buffer[cchmin]]); // Shift as much as possible
else break; } return((char *) 0); // No match
}
intstrnspn( char *s, char *t, int n )/*
Description:
Finds the position of the first character in s of length n that is not in the character set t.
Argument:
s - string to search from. t - character set to search for n - length of s
Returns:
Returns the offset of the first character in s that is not in t*/{ register char *s1; // String pointer
register char *t1; // String pointer
for(s1 = s; n-- != 0; ++s1) { // While not at end of s
for(t1 = t; *t1 != '\0'; ++t1) { // While not at end of t
if (*s1 == *t1) break; // Break if match found
} if (*t1 == '\0') break; // Break if no match found
} return (int)(s1 - s); // Return length
}
intstrncspn( char *s, char *t, int n )/*
Description:
Finds the position of the first occurence of characters in t in string s of length n.
Argument:
s - string to search from. t - character set to search for n - length of s
Returns:
Returns first offset position in s that consists of characters in t Returns length of s if not found.*/{ register char *s1; // String pointer
register char *t1; // String pointer
for(s1 = s; n-- != 0; ++s1) { // While not at end of s
for(t1 = t; *t1 != '\0'; ++t1) { // While not at end of t
if (*s1 == *t1) return (int)(s1 - s); // Return if match found
} } return (int)(s1 - s); // Return length
}
voidmatchstrings( char *s1, char *s2, int len, int *nmatched, int *leg ){ register char *cp; // Char pointer
register int (__cdecl *cmp)(const char*, const char*, size_t); // Comparison function pointer
cmp = casesen ? _strncoll: _strnicoll; // Set pointer
if ((*leg = (*cmp)(s1, s2, len)) != 0) { // If strings don't match
for(cp = s1; (*cmp)(cp, s2++, 1) == 0; ++cp) ; // Find mismatch
*nmatched = (int)(cp - s1); // Return number matched
} else *nmatched = len; // Else all matched
}
voidprintmessage ( FILE* fp, DWORD messageID, ... ){ char messagebuffer[DISPLAYBUFFER_SIZE]; WCHAR widemessagebuffer[DISPLAYBUFFER_SIZE]; ULONG len; NTSTATUS status;
va_list ap;
va_start(ap, messageID);
if (len = FormatMessage(FORMAT_MESSAGE_FROM_HMODULE, NULL, messageID, 0, messagebuffer, DISPLAYBUFFER_SIZE, &ap)) { // the messagebuffer should be null terminated
status = RtlMultiByteToUnicodeN(widemessagebuffer, DISPLAYBUFFER_SIZE*sizeof(WCHAR), &len, messagebuffer, len); // the widemessagebuffer is not null terminated but len tells us how long
if (NT_SUCCESS(status)) { status = RtlUnicodeToOemN(messagebuffer, DISPLAYBUFFER_SIZE-1, &len, widemessagebuffer, len); // the messagebuffer is not null terminated but len tells us how long
if (NT_SUCCESS(status)) { messagebuffer[len] = 0; fprintf(fp, "%s", messagebuffer); } else { DbgPrint("Failure to convert Unicode to Oem: %d\n", GetLastError()); } } else { DbgPrint("Failure to convert MultiByte to Unicode: %d\n", GetLastError()); } } else { DbgPrint("FormatMessage failed: %d\n", GetLastError()); }
va_end(ap);}
#ifdef FE_SB
intIsTailByte( unsigned const char *text, const int offset )
/*
Description:
This routine checks to see if the byte at the offset location is a tail byte of a DBCS character. The offset is calculated such that the first location has a value of 0.
Argument:
text - Points to a MBCS text string.
offset - zero base offset to check character is a tailbyte of a DBCS character.
Returns:
TRUE - offset position is a tailbyte character.
FALSE - otherwise.
Modifications:
v-junm: 05/06/93 - Original.*/
{ int i = offset;
if ( !IsDBCSCodePage ) return( FALSE );
for ( ; i; i-- ) if ( !IsDBCSLeadByte ( text[i-1] ) ) break;
return( ( offset - i ) % 2 );}
char *_mbsrchr( const char *string, int c )
/*
Description:
This function is a DBCS enabled version of the STRRCHR function included in the MS C/C++ library. What DBCS enabled means is that the SBCS character 'c' is found in a MBCS string 'string'. 'c' is a SBCS character that cannot be contained in the tailbyte of a DBCS character.
Argument:
string - Points to a MBCS text string.
offset - Character to find in string.
Returns:
Returns a pointer to the last occurance of c in string, or a NULL pointer if c is not found.
Modifications:
v-junm: 05/06/93 - Original.*/
{ register int i = strlen( string );
for (; i >= 0; i-- ) { if ( ( *(string + i) == (char)c ) && !IsTailByte( (unsigned char *) string, i ) ) return( (char*)(string + i) ); } return ( NULL );}
unsigned char *_mbslwr( unsigned char *s )
/*
Description:
This function is a DBCS aware version of the strlwr function included in the MS C/C++ library. SBCS alphabets contained in the tailbyte of a DBCS character is not affected in the conversion.
Argument:
s - String to converted to lower case.
Returns:
Returns a string that was converted to lower case.
Modifications:
v-junm: 05/06/93 - Original.*/
{ //
// If NonJP code page, use original routine.
//
if ( !IsDBCSCodePage ) return( (unsigned char *) _strlwr( (char *) s ) );
//
// While not end of string convert to lower case.
//
for( ; *s; s++ ) {
//
// if Leadbyte and next character is not NULL
// skip tailbyte
// else if uppercase character
// convert it to lowercase
//
if ( IsDBCSLeadByte( *s ) && *(s+1) ) s++; else if ( *s >= 0x41 && *s <= 0x5a ) *s = *s + 0x20; } return( s );}
int_mbsnicmp( const unsigned char *s1, const unsigned char *s2, int n, BOOL *TailByte )
/*
Description:
This is similar to a DBCS aware version of the memicmp function contained in the MS C/C++ library. The only difference is that an additional parameter is passed which indicates if the first character is a tailbyte of a DBCS character.
Argument:
s1 - string 1 to compare.
s2 - string 2 to compare.
n - maximum number of bytes to compare.
TailByte - flag to indicate first character in s1 and s2 is a tailbyte of a DBCS character.
Returns:
RetVal < 0 - s1 < s2
RetVal = 0 - s1 == s2
RetVal > 0 - s1 > s2
Modifications:
v-junm: 05/06/93 - Original.*/
{ BOOL tail = *TailByte; int i;
*TailByte = FALSE;
for( ; n; n--, s1++, s2++ ) {
if ( *s1 == *s2 ) {
if ( tail == FALSE && IsDBCSLeadByte( *s1 ) ) tail = TRUE; else tail = FALSE;
continue;
} else if ( !tail ) {
i = _strnicoll((char *)s1, (char *)s2, 1); if (i == 0) continue; return i; }
return( *s1 - *s2 ); }
*TailByte = tail;
return( 0 );}
#endif
|
