SceUInt8* boyer_moore (SceUInt8 *string, SceUInt32 stringlen, SceUInt8 *pat, SceUInt32 patlen) {
int i;
int delta1[ALPHABET_LEN];
int *delta2 = (int *)malloc(patlen * sizeof(int));
make_delta1(delta1, pat, patlen);
make_delta2(delta2, pat, patlen);
// The empty pattern must be considered specially
if (patlen == 0) return string;
i = patlen-1;
while (i < stringlen) {
int j = patlen-1;
while (j >= 0 && (string[i] == pat[j])) {
--i;
--j;
}
if (j < 0) {
free(delta2);
return (string + i+1);
}
i += max(delta1[string[i]], delta2[j]);
}
free(delta2);
return NULL;
}
char* memstr (char *string, SceUInt stringlen, char *pat, SceUInt patlen) {
SceUInt i;
int delta1[ALPHABET_LEN];
int delta2 [MAX_MEMSTR_PATH_LENGTH];
make_delta1(delta1, pat, patlen);
make_delta2(delta2, pat, patlen);
// The empty pattern must be considered specially
if (patlen == 0) return string;
i = patlen-1;
while (i < stringlen) {
int j = patlen-1;
while (j >= 0 && (string[i] == pat[j])) {
--i;
--j;
}
if (j < 0) {
return (string + i+1);
}
i += max(delta1[((unsigned char *)string)[i]], delta2[j]);
}
return NULL;
}
bool BoyerMooreSearch::PreProcess(const char *pattern, int patternLen, SearchOptions options) {
pattern_ = pattern;
patternLen_ = patternLen;
matchCase_ = (options & kMatchCase);
delta2_ = (int *)malloc(patternLen * sizeof(int));
if (delta2_ == NULL)
return false;
make_delta1(delta1_, kAlphabetLen, (const uint8_t*)pattern, patternLen, matchCase_);
make_delta2(delta2_, (const uint8_t*)pattern, patternLen, matchCase_);
return true;
}
void BoyerMooreSearch::StartSearchWorker(const char *pattern, int patternLen, SearchOptions options, SearchCreateResult& result) {
pattern_ = pattern;
patternLen_ = patternLen;
matchCase_ = (options & kMatchCase);
delta2_ = (int *)malloc(patternLen * sizeof(int));
if (delta2_ == NULL) {
result.SetError(E_OUTOFMEMORY, "Out of memory");
return;
}
make_delta1(delta1_, kAlphabetLen, (const uint8_t*)pattern, patternLen, matchCase_);
make_delta2(delta2_, (const uint8_t*)pattern, patternLen, matchCase_);
}
uint8_t boyer_moore (uint8_t *string, uint32_t stringlen, uint8_t *pat, uint32_t patlen) {
uint32_t i;
int delta1[ALPHABET_LEN];
int *delta2 = (int *)malloc(patlen * sizeof(int));
make_delta1(delta1, pat, patlen);
make_delta2(delta2, pat, patlen);
print_pre_table(delta1, delta2, pat, patlen);
i = patlen-1;
while (i < stringlen) {
int j = patlen-1;
while (j >= 0 && (string[i] == pat[j])) {
--i;
--j;
}
if (j < 0) {
free(delta2);
return i+1; //返回T中匹配的位置
}
i += max(delta1[string[i]], delta2[j]); //j失配（ [j+1, patlen)已匹配 ），i向右移动的距离取主串T中坏字符delta1[string[i]]与模式串P中好后缀delta2[j]的大者
}
free(delta2);
return -1;
}
uint8_t* boyer_moore (uint8_t *string, uint32_t stringlen, uint8_t *pat, uint32_t patlen) {
int i;
int delta1[ALPHABET_LEN];
int *delta2 = malloc(patlen * sizeof(int));
make_delta1(delta1, pat, patlen);
make_delta2(delta2, pat, patlen);
i = patlen-1;
while (i < stringlen) {
int j = patlen-1;
while (j >= 0 && (string[i] == pat[j])) {
--i;
--j;
}
if (j < 0) {
free(delta2);
return (string + i+1);
}
i += max(delta1[string[i]], delta2[j]);
}
free(delta2);
return NULL;
}
int main(int argc, char *const argv[])
{
size_t before = 16;
size_t after = 16;
int color = 0;
bool hexlify = true;
int ch;
long ia, ib;
while ((ch = getopt(argc, argv, "a:b:chH")) != -1)
{
switch(ch)
{
case 'a':
ia = strtol(optarg, NULL, 10);
if ((ia > 0) && (ia < 1024))
{
after = (size_t)ia;
}
break;
case 'b':
ib = strtol(optarg, NULL, 10);
if ((ib > 0) && (ib < 1024))
{
before = (size_t)ib;
}
break;
case 'c':
color++;
break;
case 'H':
hexlify = !hexlify;
break;
case 'h':
default:
usage();
break;
}
}
if (!isatty(STDOUT_FILENO) && color)
{
color--;
}
argc -= optind;
argv += optind;
if (argc < 2)
{
usage();
}
size_t pattern_size = 0;
uint8_t *pattern;
if (hexlify)
{
pattern = hex_decode(argv[0], &pattern_size);
}
else
{
pattern_size = strlen(argv[0]);
pattern = (uint8_t*)strndup(argv[0], pattern_size);
}
if (!pattern)
{
fprintf(stderr, "Invalid pattern\n");
}
// initialize boyer-moore patterns
int *delta1 = (int*)malloc(ALPHABET_LEN * sizeof(int));
int *delta2 = (int*)malloc(pattern_size * sizeof(int));
make_delta1(delta1, pattern, pattern_size);
make_delta2(delta2, pattern, pattern_size);
size_t count = 0;
size_t errors = 0;
for (int f=1; f<argc; f++)
{
int first = 1;
const char *file_name = argv[f];
int fd = open(file_name, O_RDONLY);
if (fd < 0)
{
fprintf(stderr, "Open error ");
perror(file_name);
errors++;
continue;
}
// Get the file size, to make mmap search the whole thing
struct stat file_stat;
if (fstat(fd, &file_stat) != 0)
{
fprintf(stderr, "Stat error ");
perror(file_name);
errors++;
close(fd); // ignore error
continue;
}
size_t file_size = (size_t)file_stat.st_size;
if ((file_size == 0) || !S_ISREG(file_stat.st_mode))
{
close(fd); // ignore error
continue;
}
const uint8_t *file = mmap(0, file_size, PROT_READ, MAP_SHARED, fd, 0);
if (file == MAP_FAILED)
{
fprintf(stderr, "Mmap error ");
perror(file_name);
errors++;
close(fd); // ignore error
continue;
}
// Find all matches, don't worry about overlaps
size_t last = 0;
size_t next = 0;
while ((next = bm_search(file + last,
file_size - last,
pattern, pattern_size,
delta1, delta2)) != NOT_FOUND)
{
if (first)
{
first = 0;
printf("---- %s ----\n", file_name);
}
print_match(file, last + next, pattern_size, before, after, color);
last += next + pattern_size;
count++;
}
if (munmap((void*)file, file_size) != 0)
{
fprintf(stderr, "Unmap error ");
perror(file_name);
errors++;
}
if (close(fd) != 0)
{
fprintf(stderr, "Close error ");
perror(file_name);
errors++;
}
}
free(delta2);
free(delta1);
free(pattern);
if (count > 0)
{
return 0;
}
if (errors > 0)
{
return 2;
}
return 1;
}
