static void
testRegexpFile(const char *filename) {
xmlRegexpPtr comp = NULL;
FILE *input;
char expression[5000];
int len;
input = fopen(filename, "r");
if (input == NULL) {
xmlGenericError(xmlGenericErrorContext,
"Cannot open %s for reading\n", filename);
return;
}
while (fgets(expression, 4500, input) != NULL) {
len = strlen(expression);
len--;
while ((len >= 0) &&
((expression[len] == '\n') || (expression[len] == '\t') ||
(expression[len] == '\r') || (expression[len] == ' '))) len--;
expression[len + 1] = 0;
if (len >= 0) {
if (expression[0] == '#')
continue;
if ((expression[0] == '=') && (expression[1] == '>')) {
char *pattern = &expression[2];
if (comp != NULL) {
xmlRegFreeRegexp(comp);
comp = NULL;
}
printf("Regexp: %s\n", pattern) ;
comp = xmlRegexpCompile((const xmlChar *) pattern);
if (comp == NULL) {
printf(" failed to compile\n");
break;
}
} else if (comp == NULL) {
printf("Regexp: %s\n", expression) ;
comp = xmlRegexpCompile((const xmlChar *) expression);
if (comp == NULL) {
printf(" failed to compile\n");
break;
}
} else if (comp != NULL) {
testRegexp(comp, expression);
}
}
}
fclose(input);
if (comp != NULL)
xmlRegFreeRegexp(comp);
}
static ERL_NIF_TERM compile(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
ErlNifBinary patternbin;
if (enif_inspect_iolist_as_binary(env, argv[0], &patternbin)) {
ERL_NIF_TERM ret;
xmlRegexpPtr xre;
char *patternstr = enif_alloc(patternbin.size + 1);
patternstr[patternbin.size] = 0;
memcpy(patternstr, patternbin.data, patternbin.size);
if ((xre = xmlRegexpCompile((xmlChar *)patternstr)) != NULL) {
struct regexp *r;
r = enif_alloc_resource(regexp_type, sizeof(struct regexp));
memset(r, 0, sizeof(*r));
r->xre = xre;
r->string = patternstr;
/* transfer ownership to calling process */
ret = enif_make_tuple2(env, am_ok(env),
enif_make_resource(env, r));
enif_release_resource(r);
} else {
enif_free(patternstr);
ret = last_error(env, "Bad Pattern");
}
return ret;
}
return enif_make_badarg(env);
}
bool
checkRegExp (const char *regexp)
{
xmlRegexpPtr x = xmlRegexpCompile ((const xmlChar *) regexp);
if (!x)
return 0;
xmlRegFreeRegexp (x);
return 1;
}
bool
validateString (const char *regexp, const char *str)
{
xmlRegexpPtr x = xmlRegexpCompile ((const xmlChar *) regexp);
if (!x)
return 0;
int r = xmlRegexpExec (x, (const xmlChar *) str);
xmlRegFreeRegexp (x);
return r == 1;
}
static ERL_NIF_TERM run(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[])
{
struct regexp *rp = NULL;
struct regexp r;
ErlNifBinary strbin;
ERL_NIF_TERM ret;
if (!enif_get_resource(env, argv[1], regexp_type, (void **)&rp)) {
ErlNifBinary patternbin;
if (enif_inspect_iolist_as_binary(env, argv[1], &patternbin)) {
char patternstr[patternbin.size + 1];
xmlRegexpPtr xre;
patternstr[patternbin.size] = 0;
memcpy(patternstr, patternbin.data, patternbin.size);
if ((xre = xmlRegexpCompile((xmlChar *)patternstr)) != NULL) {
r.xre = xre;
r.string = NULL;
rp = &r;
} else {
return last_error(env, "Bad Pattern");
}
} else {
return enif_make_badarg(env);
}
}
if (enif_inspect_iolist_as_binary(env, argv[0], &strbin)) {
char string[strbin.size + 1];
string[strbin.size] = 0;
memcpy(string, strbin.data, strbin.size);
switch (xmlRegexpExec(rp->xre, (xmlChar *)string)) {
case 1:
/* FIXME NYI */
ret = enif_make_tuple2(env, am_match(env),
enif_make_list(env, 0));
break;
case 0:
ret = am_nomatch(env);
break;
default:
ret = last_error(env, NULL);
}
} else {
ret = enif_make_badarg(env);
}
if (rp == &r) {
xmlRegFreeRegexp(r.xre);
}
return ret;
}
int main(int argc, char **argv) {
xmlRegexpPtr comp = NULL;
#ifdef LIBXML_EXPR_ENABLED
xmlExpNodePtr expr = NULL;
int use_exp = 0;
xmlExpCtxtPtr ctxt = NULL;
#endif
const char *pattern = NULL;
char *filename = NULL;
int i;
xmlInitMemory();
if (argc <= 1) {
usage(argv[0]);
return(1);
}
for (i = 1; i < argc ; i++) {
if (!strcmp(argv[i], "-"))
break;
if (argv[i][0] != '-')
continue;
if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug"))) {
debug++;
} else if ((!strcmp(argv[i], "-repeat")) ||
(!strcmp(argv[i], "--repeat"))) {
repeat++;
#ifdef LIBXML_EXPR_ENABLED
} else if ((!strcmp(argv[i], "-expr")) ||
(!strcmp(argv[i], "--expr"))) {
use_exp++;
#endif
} else if ((!strcmp(argv[i], "-i")) || (!strcmp(argv[i], "-f")) ||
(!strcmp(argv[i], "--input")))
filename = argv[++i];
else {
fprintf(stderr, "Unknown option %s\n", argv[i]);
usage(argv[0]);
}
}
#ifdef LIBXML_EXPR_ENABLED
if (use_exp)
ctxt = xmlExpNewCtxt(0, NULL);
#endif
if (filename != NULL) {
#ifdef LIBXML_EXPR_ENABLED
if (use_exp)
runFileTest(ctxt, filename);
else
#endif
testRegexpFile(filename);
} else {
#ifdef LIBXML_EXPR_ENABLED
if (use_exp) {
for (i = 1; i < argc ; i++) {
if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
if (pattern == NULL) {
pattern = argv[i];
printf("Testing expr %s:\n", pattern);
expr = xmlExpParse(ctxt, pattern);
if (expr == NULL) {
printf(" failed to compile\n");
break;
}
if (debug) {
exprDebug(ctxt, expr);
}
} else {
testReduce(ctxt, expr, argv[i]);
}
}
}
if (expr != NULL)
xmlExpFree(ctxt, expr);
} else
#endif
{
for (i = 1; i < argc ; i++) {
if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0)) {
if (pattern == NULL) {
pattern = argv[i];
printf("Testing %s:\n", pattern);
comp = xmlRegexpCompile((const xmlChar *) pattern);
if (comp == NULL) {
printf(" failed to compile\n");
break;
}
if (debug)
xmlRegexpPrint(stdout, comp);
} else {
testRegexp(comp, argv[i]);
}
}
}
if (comp != NULL)
xmlRegFreeRegexp(comp);
}
}
#ifdef LIBXML_EXPR_ENABLED
if (ctxt != NULL) {
printf("Ops: %d nodes, %d cons\n",
xmlExpCtxtNbNodes(ctxt), xmlExpCtxtNbCons(ctxt));
xmlExpFreeCtxt(ctxt);
}
#endif
xmlCleanupParser();
xmlMemoryDump();
return(0);
}
