/*

 * 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;

    xmlExpBuf = xmlBufferCreate();

    sub = xmlExpParse(ctxt, tst);

    if (sub == NULL) {

        printf("Subset %s failed to parse\n", tst);

	return;

    }

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

	return;

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

    }

    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 */