testRegexp.c - platform/external/libxml2 - Gitiles

 /*
  * testRegexp.c: simple module for testing regular expressions
  *
  * See Copyright for the status of this software.
  *
  * Daniel Veillard <veillard@redhat.com>
  */

 #include "libxml.h"
 #ifdef LIBXML_REGEXP_ENABLED
 #include <string.h>

 #include <libxml/tree.h>
 #include <libxml/xmlregexp.h>

 static int repeat = 0;
 static int debug = 0;

 static void testRegexp(xmlRegexpPtr comp, const char *value) {
     int ret;

     ret = xmlRegexpExec(comp, (const xmlChar *) value);
     if (ret == 1)
 	printf("%s: Ok\n", value);
     else if (ret == 0)
 	printf("%s: Fail\n", value);
     else
 	printf("%s: Error: %d\n", value, ret);
     if (repeat) {
 	int j;
 	for (j = 0;j < 999999;j++)
 	    xmlRegexpExec(comp, (const xmlChar *) value);
     }
 }

 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);
 }

 #ifdef LIBXML_EXPR_ENABLED
 static void
 runFileTest(xmlExpCtxtPtr ctxt, const char *filename) {
     xmlExpNodePtr expr = NULL, sub;
     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 *str = &expression[2];

 		if (expr != NULL) {
 		    xmlExpFree(ctxt, expr);
 		    if (xmlExpCtxtNbNodes(ctxt) != 0)
 		        printf(" Parse/free of Expression leaked %d\n",
 			       xmlExpCtxtNbNodes(ctxt));
 		    expr = NULL;
 		}
 		printf("Expression: %s\n", str) ;
 		expr = xmlExpParse(ctxt, str);
 		if (expr == NULL) {
 		    printf("   parsing Failed\n");
 		    break;
 		}
 	    } else if (expr != NULL) {
 	        int expect = -1;
 		int nodes1, nodes2;

 		if (expression[0] == '0')
 		    expect = 0;
 		if (expression[0] == '1')
 		    expect = 1;
 		printf("Subexp: %s", expression + 2) ;
 		nodes1 = xmlExpCtxtNbNodes(ctxt);
 		sub = xmlExpParse(ctxt, expression + 2);
 		if (sub == NULL) {
 		    printf("   parsing Failed\n");
 		    break;
 		} else {
 		    int ret;

 		    nodes2 = xmlExpCtxtNbNodes(ctxt);
 		    ret = xmlExpSubsume(ctxt, expr, sub);

 		    if ((expect == 1) && (ret == 1)) {
 			printf(" => accept, Ok\n");
 		    } else if ((expect == 0) && (ret == 0)) {
 		        printf(" => reject, Ok\n");
 		    } else if ((expect == 1) && (ret == 0)) {
 			printf(" => reject, Failed\n");
 		    } else if ((expect == 0) && (ret == 1)) {
 			printf(" => accept, Failed\n");
 		    } else {
 		        printf(" => fail internally\n");
 		    }
 		    if (xmlExpCtxtNbNodes(ctxt) > nodes2) {
 		        printf(" Subsume leaked %d\n",
 			       xmlExpCtxtNbNodes(ctxt) - nodes2);
 			nodes1 += xmlExpCtxtNbNodes(ctxt) - nodes2;
 		    }
 		    xmlExpFree(ctxt, sub);
 		    if (xmlExpCtxtNbNodes(ctxt) > nodes1) {
 		        printf(" Parse/free leaked %d\n",
 			       xmlExpCtxtNbNodes(ctxt) - nodes1);
 		    }
 		}

 	    }
 	}
     }
     if (expr != NULL) {
 	xmlExpFree(ctxt, expr);
 	if (xmlExpCtxtNbNodes(ctxt) != 0)
 	    printf(" Parse/free of Expression leaked %d\n",
 		   xmlExpCtxtNbNodes(ctxt));
     }
     fclose(input);
 }

 static void
 testReduce(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr, const char *tst) {
     xmlBufferPtr xmlExpBuf;
     xmlExpNodePtr sub, deriv;

     sub = xmlExpParse(ctxt, tst);
     if (sub == NULL) {
         printf("Subset %s failed to parse\n", tst);
 	return;
     }
     xmlExpBuf = xmlBufferCreate();
     xmlExpDump(xmlExpBuf, sub);
     printf("Subset parsed as: %s\n",
            (const char *) xmlBufferContent(xmlExpBuf));
     deriv = xmlExpExpDerive(ctxt, expr, sub);
     if (deriv == NULL) {
         printf("Derivation led to an internal error, report this !\n");
     } else {
         xmlBufferEmpty(xmlExpBuf);
 	xmlExpDump(xmlExpBuf, deriv);
 	if (xmlExpIsNillable(deriv))
 	    printf("Resulting nillable derivation: %s\n",
 	           (const char *) xmlBufferContent(xmlExpBuf));
 	else
 	    printf("Resulting derivation: %s\n",
 	           (const char *) xmlBufferContent(xmlExpBuf));
 	xmlExpFree(ctxt, deriv);
     }
     xmlBufferFree(xmlExpBuf);
     xmlExpFree(ctxt, sub);
 }

 static void
 exprDebug(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr) {
     xmlBufferPtr xmlExpBuf;
     xmlExpNodePtr deriv;
     const char *list[40];
     int ret;

     xmlExpBuf = xmlBufferCreate();

     if (expr == NULL) {
         printf("Failed to parse\n");
 	return;
     }
     xmlExpDump(xmlExpBuf, expr);
     printf("Parsed as: %s\n", (const char *) xmlBufferContent(xmlExpBuf));
     printf("Max token input = %d\n", xmlExpMaxToken(expr));
     if (xmlExpIsNillable(expr) == 1)
 	printf("Is nillable\n");
     ret = xmlExpGetLanguage(ctxt, expr, (const xmlChar **) &list[0], 40);
     if (ret < 0)
 	printf("Failed to get list: %d\n", ret);
     else {
 	int i;

 	printf("Language has %d strings, testing string derivations\n", ret);
 	for (i = 0;i < ret;i++) {
 	    deriv = xmlExpStringDerive(ctxt, expr, BAD_CAST list[i], -1);
 	    if (deriv == NULL) {
 		printf("  %s -> derivation failed\n", list[i]);
 	    } else {
 		xmlBufferEmpty(xmlExpBuf);
 		xmlExpDump(xmlExpBuf, deriv);
 		printf("  %s -> %s\n", list[i],
 		       (const char *) xmlBufferContent(xmlExpBuf));
 	    }
 	    xmlExpFree(ctxt, deriv);
 	}
     }
     xmlBufferFree(xmlExpBuf);
 }
 #endif

 static void usage(const char *name) {
     fprintf(stderr, "Usage: %s [flags]\n", name);
     fprintf(stderr, "Testing tool for libxml2 string and pattern regexps\n");
     fprintf(stderr, "   --debug: switch on debugging\n");
     fprintf(stderr, "   --repeat: loop on the operation\n");
 #ifdef LIBXML_EXPR_ENABLED
     fprintf(stderr, "   --expr: test xmlExp and not xmlRegexp\n");
 #endif
     fprintf(stderr, "   --input filename: use the given filename for regexp\n");
     fprintf(stderr, "   --input filename: use the given filename for exp\n");
 }

 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], "--"))
 	    break;

 	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 {
         int  data = 0;
 #ifdef LIBXML_EXPR_ENABLED

         if (use_exp) {
 	    for (i = 1; i < argc ; i++) {
 	        if (strcmp(argv[i], "--") == 0)
 		    data = 1;
 		else if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0) ||
 		    (data == 1)) {
 		    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);
 		expr = NULL;
 	    }
 	} else
 #endif
         {
 	    for (i = 1; i < argc ; i++) {
 	        if (strcmp(argv[i], "--") == 0)
 		    data = 1;
 		else if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0) ||
 		         (data == 1)) {
 		    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);
 }

 #else
 #include <stdio.h>
 int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
     printf("%s : Regexp support not compiled in\n", argv[0]);
     return(0);
 }
 #endif /* LIBXML_REGEXP_ENABLED */
	/*
	* testRegexp.c: simple module for testing regular expressions
	*
	* See Copyright for the status of this software.
	*
	* Daniel Veillard <veillard@redhat.com>
	*/

	#include "libxml.h"
	#ifdef LIBXML_REGEXP_ENABLED
	#include <string.h>

	#include <libxml/tree.h>
	#include <libxml/xmlregexp.h>

	static int repeat = 0;
	static int debug = 0;

	static void testRegexp(xmlRegexpPtr comp, const char *value) {
	int ret;

	ret = xmlRegexpExec(comp, (const xmlChar *) value);
	if (ret == 1)
	printf("%s: Ok\n", value);
	else if (ret == 0)
	printf("%s: Fail\n", value);
	else
	printf("%s: Error: %d\n", value, ret);
	if (repeat) {
	int j;
	for (j = 0;j < 999999;j++)
	xmlRegexpExec(comp, (const xmlChar *) value);
	}
	}

	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);
	}

	#ifdef LIBXML_EXPR_ENABLED
	static void
	runFileTest(xmlExpCtxtPtr ctxt, const char *filename) {
	xmlExpNodePtr expr = NULL, sub;
	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 *str = &expression[2];

	if (expr != NULL) {
	xmlExpFree(ctxt, expr);
	if (xmlExpCtxtNbNodes(ctxt) != 0)
	printf(" Parse/free of Expression leaked %d\n",
	xmlExpCtxtNbNodes(ctxt));
	expr = NULL;
	}
	printf("Expression: %s\n", str) ;
	expr = xmlExpParse(ctxt, str);
	if (expr == NULL) {
	printf(" parsing Failed\n");
	break;
	}
	} else if (expr != NULL) {
	int expect = -1;
	int nodes1, nodes2;

	if (expression[0] == '0')
	expect = 0;
	if (expression[0] == '1')
	expect = 1;
	printf("Subexp: %s", expression + 2) ;
	nodes1 = xmlExpCtxtNbNodes(ctxt);
	sub = xmlExpParse(ctxt, expression + 2);
	if (sub == NULL) {
	printf(" parsing Failed\n");
	break;
	} else {
	int ret;

	nodes2 = xmlExpCtxtNbNodes(ctxt);
	ret = xmlExpSubsume(ctxt, expr, sub);

	if ((expect == 1) && (ret == 1)) {
	printf(" => accept, Ok\n");
	} else if ((expect == 0) && (ret == 0)) {
	printf(" => reject, Ok\n");
	} else if ((expect == 1) && (ret == 0)) {
	printf(" => reject, Failed\n");
	} else if ((expect == 0) && (ret == 1)) {
	printf(" => accept, Failed\n");
	} else {
	printf(" => fail internally\n");
	}
	if (xmlExpCtxtNbNodes(ctxt) > nodes2) {
	printf(" Subsume leaked %d\n",
	xmlExpCtxtNbNodes(ctxt) - nodes2);
	nodes1 += xmlExpCtxtNbNodes(ctxt) - nodes2;
	}
	xmlExpFree(ctxt, sub);
	if (xmlExpCtxtNbNodes(ctxt) > nodes1) {
	printf(" Parse/free leaked %d\n",
	xmlExpCtxtNbNodes(ctxt) - nodes1);
	}
	}

	}
	}
	}
	if (expr != NULL) {
	xmlExpFree(ctxt, expr);
	if (xmlExpCtxtNbNodes(ctxt) != 0)
	printf(" Parse/free of Expression leaked %d\n",
	xmlExpCtxtNbNodes(ctxt));
	}
	fclose(input);
	}

	static void
	testReduce(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr, const char *tst) {
	xmlBufferPtr xmlExpBuf;
	xmlExpNodePtr sub, deriv;

	sub = xmlExpParse(ctxt, tst);
	if (sub == NULL) {
	printf("Subset %s failed to parse\n", tst);
	return;
	}
	xmlExpBuf = xmlBufferCreate();
	xmlExpDump(xmlExpBuf, sub);
	printf("Subset parsed as: %s\n",
	(const char *) xmlBufferContent(xmlExpBuf));
	deriv = xmlExpExpDerive(ctxt, expr, sub);
	if (deriv == NULL) {
	printf("Derivation led to an internal error, report this !\n");
	} else {
	xmlBufferEmpty(xmlExpBuf);
	xmlExpDump(xmlExpBuf, deriv);
	if (xmlExpIsNillable(deriv))
	printf("Resulting nillable derivation: %s\n",
	(const char *) xmlBufferContent(xmlExpBuf));
	else
	printf("Resulting derivation: %s\n",
	(const char *) xmlBufferContent(xmlExpBuf));
	xmlExpFree(ctxt, deriv);
	}
	xmlBufferFree(xmlExpBuf);
	xmlExpFree(ctxt, sub);
	}

	static void
	exprDebug(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr) {
	xmlBufferPtr xmlExpBuf;
	xmlExpNodePtr deriv;
	const char *list[40];
	int ret;

	xmlExpBuf = xmlBufferCreate();

	if (expr == NULL) {
	printf("Failed to parse\n");
	return;
	}
	xmlExpDump(xmlExpBuf, expr);
	printf("Parsed as: %s\n", (const char *) xmlBufferContent(xmlExpBuf));
	printf("Max token input = %d\n", xmlExpMaxToken(expr));
	if (xmlExpIsNillable(expr) == 1)
	printf("Is nillable\n");
	ret = xmlExpGetLanguage(ctxt, expr, (const xmlChar **) &list[0], 40);
	if (ret < 0)
	printf("Failed to get list: %d\n", ret);
	else {
	int i;

	printf("Language has %d strings, testing string derivations\n", ret);
	for (i = 0;i < ret;i++) {
	deriv = xmlExpStringDerive(ctxt, expr, BAD_CAST list[i], -1);
	if (deriv == NULL) {
	printf(" %s -> derivation failed\n", list[i]);
	} else {
	xmlBufferEmpty(xmlExpBuf);
	xmlExpDump(xmlExpBuf, deriv);
	printf(" %s -> %s\n", list[i],
	(const char *) xmlBufferContent(xmlExpBuf));
	}
	xmlExpFree(ctxt, deriv);
	}
	}
	xmlBufferFree(xmlExpBuf);
	}
	#endif

	static void usage(const char *name) {
	fprintf(stderr, "Usage: %s [flags]\n", name);
	fprintf(stderr, "Testing tool for libxml2 string and pattern regexps\n");
	fprintf(stderr, " --debug: switch on debugging\n");
	fprintf(stderr, " --repeat: loop on the operation\n");
	#ifdef LIBXML_EXPR_ENABLED
	fprintf(stderr, " --expr: test xmlExp and not xmlRegexp\n");
	#endif
	fprintf(stderr, " --input filename: use the given filename for regexp\n");
	fprintf(stderr, " --input filename: use the given filename for exp\n");
	}

	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], "--"))
	break;

	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 {
	int data = 0;
	#ifdef LIBXML_EXPR_ENABLED

	if (use_exp) {
	for (i = 1; i < argc ; i++) {
	if (strcmp(argv[i], "--") == 0)
	data = 1;
	else if ((argv[i][0] != '-') \|\| (strcmp(argv[i], "-") == 0) \|\|
	(data == 1)) {
	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);
	expr = NULL;
	}
	} else
	#endif
	{
	for (i = 1; i < argc ; i++) {
	if (strcmp(argv[i], "--") == 0)
	data = 1;
	else if ((argv[i][0] != '-') \|\| (strcmp(argv[i], "-") == 0) \|\|
	(data == 1)) {
	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);
	}

	#else
	#include <stdio.h>
	int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
	printf("%s : Regexp support not compiled in\n", argv[0]);
	return(0);
	}
	#endif /* LIBXML_REGEXP_ENABLED */