kc3-lang/libxml2/testRegexp.c

Tag - branch -master- tag -v2.9.9-rc2v2.9.9-rc1v2.9.9v2.9.8-rc1v2.9.8v2.9.7-rc1v2.9.7v2.9.6-rc1v2.9.6v2.9.5-rc2v2.9.5-rc1v2.9.5v2.9.4-rc2v2.9.4-rc1v2.9.4v2.9.3v2.9.2-rc2v2.9.2-rc1v2.9.2v2.9.14v2.9.13v2.9.12v2.9.11v2.9.10-rc1v2.9.10v2.9.1v2.9.0-rc2v2.9.0v2.8.0-rc2v2.8.0-rc1v2.8.0v2.7.8v2.7.7v2.7.6v2.7.5v2.7.4v2.15.1v2.15.0v2.14.6v2.14.5v2.14.4v2.14.3v2.14.2v2.14.1v2.14.0v2.13.9v2.13.8v2.13.7v2.13.6v2.13.5v2.13.4v2.13.3v2.13.2v2.13.1v2.13.0v2.12.9v2.12.8v2.12.7v2.12.6v2.12.5v2.12.4v2.12.3v2.12.2v2.12.10v2.12.1v2.12.0v2.11.9v2.11.8v2.11.7v2.11.6v2.11.5v2.11.4v2.11.3v2.11.2v2.11.1v2.11.0v2.10.4v2.10.3v2.10.2v2.10.1v2.10.0helpPRE_MUCKUP3PRE_MUCKUP2PRE_MUCKUPLIB_XML_1_XLIB_XML_1_8_3LIB_XML_1_7_3LIB_XML_1_7_1LIB_XML_1_7_0LIB_XML_1_6_2LIB_XML_1_6_1LIB_XML_1_4LIB_XML_1_3LIB_XML_1_1LIBXML_TEST_2_0_0LIBXML_2_6_10LIBXML_2_5_6LIBXML_2_5_5LIBXML_2_5_4LIBXML_2_5_3LIBXML_2_5_2LIBXML_2_5_1LIBXML_2_4_7LIBXML_2_4_6LIBXML_2_4_4LIBXML_2_4_30LIBXML_2_4_3LIBXML_2_4_29LIBXML_2_4_27LIBXML_2_4_26LIBXML_2_4_25LIBXML_2_4_24LIBXML_2_4_23LIBXML_2_4_22LIBXML_2_4_20LIBXML_2_4_2LIBXML_2_4_18LIBXML_2_4_16LIBXML_2_4_14LIBXML_2_4_13LIBXML_2_4_12LIBXML_2_4_11LIBXML_2_4_0LIBXML_2_3_9LIBXML_2_3_8LIBXML_2_3_7LIBXML_2_3_6LIBXML_2_3_5LIBXML_2_3_4LIBXML_2_3_3LIBXML_2_3_2LIBXML_2_3_14LIBXML_2_3_13LIBXML_2_3_12LIBXML_2_3_11LIBXML_2_3_10LIBXML_2_3_0LIBXML_2_2_8LIBXML_2_2_7LIBXML_2_2_6LIBXML_2_2_4LIBXML_2_2_3LIBXML_2_2_1LIBXML_2_1_1LIBXML_2_1_0LIBXML_2_0_0LIBXML_1_8_9LIBXML_1_8_8LIBXML_1_8_6LIBXML_1_8_5LIBXML_1_8_17LIBXML_1_8_16LIBXML_1_8_14LIBXML_1_8_12LIBXML_1_8_10_REALLIBXML_1_8_10LIBXML_1_5_0LIBXML_0_99LIBXML2_6_0LIBXML2_2_6_9LIBXML2_2_6_8LIBXML2_2_6_7LIBXML2_2_6_6LIBXML2_2_6_5LIBXML2_2_6_4LIBXML2_2_6_3LIBXML2_2_6_28LIBXML2_2_6_27LIBXML2_2_6_26LIBXML2_2_6_24LIBXML2_2_6_23LIBXML2_2_6_22LIBXML2_2_6_21LIBXML2_2_6_20LIBXML2_2_6_2LIBXML2_2_6_19LIBXML2_2_6_18LIBXML2_2_6_16LIBXML2_2_6_15LIBXML2_2_6_14LIBXML2_2_6_13LIBXML2_2_6_12LIBXML2_2_6_11LIBXML2_2_6_1LIBXML2_2_5_xLIBXML2_2_5_9LIBXML2_2_5_8LIBXML2_2_5_7LIBXML2_2_5_11LIBXML2_2_5_10LIBXML2_2_5_0LIBXML2_2_4_21LIBXML2.7.3LIBXML2.7.2LIBXML2.7.1LIBXML2.7.0LIBXML2.6.32GNUMERIC_FIRST_PUBLIC_RELEASEGNOME_PRINT_0_24GNOME_0_30FOR_GNOME_0_99_1EAZEL-NAUTILUS-MS-AUG07ChangeLogCVE-2021-3541CVE-2016-4483CVE-2016-4449CVE-2016-3705CVE-2016-3627CVE-2016-1840CVE-2016-1839CVE-2016-1838CVE-2016-1837CVE-2016-1836CVE-2016-1835CVE-2016-1834CVE-2016-1833CVE-2016-1762CVE-2015-8317CVE-2015-8242CVE-2015-8035CVE-2015-7942-2CVE-2015-7942CVE-2015-7941_2CVE-2015-7941_1CVE-2015-7500CVE-2015-7499-2CVE-2015-7499-1CVE-2015-7498CVE-2015-7497CVE-2015-5312CVE-2015-1819CVE-2014-3660CVE-2014-0191CVE-2013-2877

• Show log

  Commit

• Hash : 30663512
  Author :
  Date : 2008-02-21T22:31:55
  

  made one of the changes suggested by Brian Krahmer allow to pass '--' on
  
  * debugXML.c: made one of the changes suggested by Brian Krahmer
  * testRegexp.c: allow to pass '--' on the command line to allow
    regexps starting with the character '-'
  Daniel
  
  svn path=/trunk/; revision=3697
  

Download

• testRegexp.c

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

Download