/*******************************************************************************
Name: MatchDialogReturnD
Description: Called when pressing return key in match dialog widget
Arguments: w - Widget that caused action to be called
event - Not used
params - Dialog widget
num_params - Not used
Returns: None
*******************************************************************************/
void MatchDialogReturnD(
Widget w,
XEvent *event,
String *params,
Cardinal *num_params)
{
printMatch(w,(XtPointer)completionString,NULL);
}
static really_inline
hwlmcb_rv_t roseCallback_i(size_t start, size_t end, u32 id, void *ctxt) {
struct hs_scratch *scratch = ctxt;
struct RoseContext *tctx = &scratch->tctxt;
const struct RoseEngine *t = scratch->core_info.rose;
u64a real_end = end + tctx->lit_offset_adjust;
#if defined(DEBUG)
DEBUG_PRINTF("MATCH id=%u offsets=[%llu,%llu]: ", id,
start + tctx->lit_offset_adjust, real_end);
printMatch(&scratch->core_info, start + tctx->lit_offset_adjust, real_end);
printf("\n");
#endif
DEBUG_PRINTF("last end %llu\n", tctx->lastEndOffset);
DEBUG_PRINTF("STATE groups=0x%016llx\n", tctx->groups);
if (can_stop_matching(scratch)) {
DEBUG_PRINTF("received a match when we're already dead!\n");
return HWLM_TERMINATE_MATCHING;
}
hwlmcb_rv_t rv = flushQueuedLiterals(t, scratch, real_end);
/* flushDelayed may have advanced tctx->lastEndOffset */
if (real_end >= t->floatingMinLiteralMatchOffset) {
roseFlushLastByteHistory(t, scratch, real_end);
tctx->lastEndOffset = real_end;
}
if (rv == HWLM_TERMINATE_MATCHING) {
return HWLM_TERMINATE_MATCHING;
}
size_t match_len = end - start + 1;
rv = roseProcessMatchInline(t, scratch, real_end, match_len, id);
DEBUG_PRINTF("DONE groups=0x%016llx\n", tctx->groups);
if (rv != HWLM_TERMINATE_MATCHING) {
return tctx->groups;
}
assert(can_stop_matching(scratch));
DEBUG_PRINTF("user requested halt\n");
return HWLM_TERMINATE_MATCHING;
}
hwlmcb_rv_t roseDelayRebuildCallback(size_t start, size_t end, u32 id,
void *ctx) {
struct hs_scratch *scratch = ctx;
struct RoseContext *tctx = &scratch->tctxt;
struct core_info *ci = &scratch->core_info;
const struct RoseEngine *t = ci->rose;
size_t rb_len = MIN(ci->hlen, t->delayRebuildLength);
u64a real_end = ci->buf_offset - rb_len + end + 1; // index after last byte
#ifdef DEBUG
DEBUG_PRINTF("REBUILD MATCH id=%u offsets=[%llu,%llu]: ", id,
start + ci->buf_offset - rb_len, real_end);
printMatch(ci, start + ci->buf_offset - rb_len, real_end);
printf("\n");
#endif
DEBUG_PRINTF("STATE groups=0x%016llx\n", tctx->groups);
const u32 *delayRebuildPrograms =
getByOffset(t, t->litDelayRebuildProgramOffset);
assert(id < t->literalCount);
const u32 program = delayRebuildPrograms[id];
if (program) {
const u64a som = 0;
const size_t match_len = end - start + 1;
const u8 flags = 0;
UNUSED hwlmcb_rv_t rv = roseRunProgram(t, scratch, program, som,
real_end, match_len, flags);
assert(rv != HWLM_TERMINATE_MATCHING);
}
/* we are just repopulating the delay queue, groups should be
* already set from the original scan. */
return tctx->groups;
}
//------------------------------------------------------------------------------------------
//
// main for ugrep
//
// Structurally, all use of the ICU Regular Expression API is in main(),
// and all of the supporting stuff necessary to make a running program, but
// not directly related to regular expressions, is factored out into these other
// functions.
//
//------------------------------------------------------------------------------------------
int main(int argc, const char** argv) {
UBool matchFound = FALSE;
//
// Process the commmand line options.
//
processOptions(argc, argv);
//
// Create a RegexPattern object from the user supplied pattern string.
//
UErrorCode status = U_ZERO_ERROR; // All ICU operations report success or failure
// in a status variable.
UParseError parseErr; // In the event of a syntax error in the regex pattern,
// this struct will contain the position of the
// error.
RegexPattern *rePat = RegexPattern::compile(pattern, parseErr, status);
// Note that C++ is doing an automatic conversion
// of the (char *) pattern to a temporary
// UnicodeString object.
if (U_FAILURE(status)) {
fprintf(stderr, "ugrep: error in pattern: \"%s\" at position %d\n",
u_errorName(status), parseErr.offset);
exit(-1);
}
//
// Create a RegexMatcher from the newly created pattern.
//
UnicodeString empty;
RegexMatcher *matcher = rePat->matcher(empty, status);
if (U_FAILURE(status)) {
fprintf(stderr, "ugrep: error in creating RegexMatcher: \"%s\"\n",
u_errorName(status));
exit(-1);
}
//
// Loop, processing each of the input files.
//
for (int fileNum=firstFileNum; fileNum < argc; fileNum++) {
readFile(argv[fileNum]);
//
// Loop through the lines of a file, trying to match the regex pattern on each.
//
for (nextLine(0); lineStart<fileLen; nextLine(lineEnd)) {
UnicodeString s(FALSE, ucharBuf+lineStart, lineEnd-lineStart);
matcher->reset(s);
if (matcher->find()) {
matchFound = TRUE;
printMatch();
}
}
}
//
// Clean up
//
delete matcher;
delete rePat;
free(ucharBuf);
free(charBuf);
ucnv_close(outConverter);
u_cleanup(); // shut down ICU, release any cached data it owns.
return matchFound? 0: 1;
}
