Annotation of embedaddon/libxml2/testRegexp.c, revision 1.1
1.1 ! misho 1: /*
! 2: * testRegexp.c: simple module for testing regular expressions
! 3: *
! 4: * See Copyright for the status of this software.
! 5: *
! 6: * Daniel Veillard <veillard@redhat.com>
! 7: */
! 8:
! 9: #include "libxml.h"
! 10: #ifdef LIBXML_REGEXP_ENABLED
! 11: #include <string.h>
! 12:
! 13: #include <libxml/tree.h>
! 14: #include <libxml/xmlregexp.h>
! 15:
! 16: static int repeat = 0;
! 17: static int debug = 0;
! 18:
! 19: static void testRegexp(xmlRegexpPtr comp, const char *value) {
! 20: int ret;
! 21:
! 22: ret = xmlRegexpExec(comp, (const xmlChar *) value);
! 23: if (ret == 1)
! 24: printf("%s: Ok\n", value);
! 25: else if (ret == 0)
! 26: printf("%s: Fail\n", value);
! 27: else
! 28: printf("%s: Error: %d\n", value, ret);
! 29: if (repeat) {
! 30: int j;
! 31: for (j = 0;j < 999999;j++)
! 32: xmlRegexpExec(comp, (const xmlChar *) value);
! 33: }
! 34: }
! 35:
! 36: static void
! 37: testRegexpFile(const char *filename) {
! 38: xmlRegexpPtr comp = NULL;
! 39: FILE *input;
! 40: char expression[5000];
! 41: int len;
! 42:
! 43: input = fopen(filename, "r");
! 44: if (input == NULL) {
! 45: xmlGenericError(xmlGenericErrorContext,
! 46: "Cannot open %s for reading\n", filename);
! 47: return;
! 48: }
! 49: while (fgets(expression, 4500, input) != NULL) {
! 50: len = strlen(expression);
! 51: len--;
! 52: while ((len >= 0) &&
! 53: ((expression[len] == '\n') || (expression[len] == '\t') ||
! 54: (expression[len] == '\r') || (expression[len] == ' '))) len--;
! 55: expression[len + 1] = 0;
! 56: if (len >= 0) {
! 57: if (expression[0] == '#')
! 58: continue;
! 59: if ((expression[0] == '=') && (expression[1] == '>')) {
! 60: char *pattern = &expression[2];
! 61:
! 62: if (comp != NULL) {
! 63: xmlRegFreeRegexp(comp);
! 64: comp = NULL;
! 65: }
! 66: printf("Regexp: %s\n", pattern) ;
! 67: comp = xmlRegexpCompile((const xmlChar *) pattern);
! 68: if (comp == NULL) {
! 69: printf(" failed to compile\n");
! 70: break;
! 71: }
! 72: } else if (comp == NULL) {
! 73: printf("Regexp: %s\n", expression) ;
! 74: comp = xmlRegexpCompile((const xmlChar *) expression);
! 75: if (comp == NULL) {
! 76: printf(" failed to compile\n");
! 77: break;
! 78: }
! 79: } else if (comp != NULL) {
! 80: testRegexp(comp, expression);
! 81: }
! 82: }
! 83: }
! 84: fclose(input);
! 85: if (comp != NULL)
! 86: xmlRegFreeRegexp(comp);
! 87: }
! 88:
! 89: #ifdef LIBXML_EXPR_ENABLED
! 90: static void
! 91: runFileTest(xmlExpCtxtPtr ctxt, const char *filename) {
! 92: xmlExpNodePtr expr = NULL, sub;
! 93: FILE *input;
! 94: char expression[5000];
! 95: int len;
! 96:
! 97: input = fopen(filename, "r");
! 98: if (input == NULL) {
! 99: xmlGenericError(xmlGenericErrorContext,
! 100: "Cannot open %s for reading\n", filename);
! 101: return;
! 102: }
! 103: while (fgets(expression, 4500, input) != NULL) {
! 104: len = strlen(expression);
! 105: len--;
! 106: while ((len >= 0) &&
! 107: ((expression[len] == '\n') || (expression[len] == '\t') ||
! 108: (expression[len] == '\r') || (expression[len] == ' '))) len--;
! 109: expression[len + 1] = 0;
! 110: if (len >= 0) {
! 111: if (expression[0] == '#')
! 112: continue;
! 113: if ((expression[0] == '=') && (expression[1] == '>')) {
! 114: char *str = &expression[2];
! 115:
! 116: if (expr != NULL) {
! 117: xmlExpFree(ctxt, expr);
! 118: if (xmlExpCtxtNbNodes(ctxt) != 0)
! 119: printf(" Parse/free of Expression leaked %d\n",
! 120: xmlExpCtxtNbNodes(ctxt));
! 121: expr = NULL;
! 122: }
! 123: printf("Expression: %s\n", str) ;
! 124: expr = xmlExpParse(ctxt, str);
! 125: if (expr == NULL) {
! 126: printf(" parsing Failed\n");
! 127: break;
! 128: }
! 129: } else if (expr != NULL) {
! 130: int expect = -1;
! 131: int nodes1, nodes2;
! 132:
! 133: if (expression[0] == '0')
! 134: expect = 0;
! 135: if (expression[0] == '1')
! 136: expect = 1;
! 137: printf("Subexp: %s", expression + 2) ;
! 138: nodes1 = xmlExpCtxtNbNodes(ctxt);
! 139: sub = xmlExpParse(ctxt, expression + 2);
! 140: if (sub == NULL) {
! 141: printf(" parsing Failed\n");
! 142: break;
! 143: } else {
! 144: int ret;
! 145:
! 146: nodes2 = xmlExpCtxtNbNodes(ctxt);
! 147: ret = xmlExpSubsume(ctxt, expr, sub);
! 148:
! 149: if ((expect == 1) && (ret == 1)) {
! 150: printf(" => accept, Ok\n");
! 151: } else if ((expect == 0) && (ret == 0)) {
! 152: printf(" => reject, Ok\n");
! 153: } else if ((expect == 1) && (ret == 0)) {
! 154: printf(" => reject, Failed\n");
! 155: } else if ((expect == 0) && (ret == 1)) {
! 156: printf(" => accept, Failed\n");
! 157: } else {
! 158: printf(" => fail internally\n");
! 159: }
! 160: if (xmlExpCtxtNbNodes(ctxt) > nodes2) {
! 161: printf(" Subsume leaked %d\n",
! 162: xmlExpCtxtNbNodes(ctxt) - nodes2);
! 163: nodes1 += xmlExpCtxtNbNodes(ctxt) - nodes2;
! 164: }
! 165: xmlExpFree(ctxt, sub);
! 166: if (xmlExpCtxtNbNodes(ctxt) > nodes1) {
! 167: printf(" Parse/free leaked %d\n",
! 168: xmlExpCtxtNbNodes(ctxt) - nodes1);
! 169: }
! 170: }
! 171:
! 172: }
! 173: }
! 174: }
! 175: if (expr != NULL) {
! 176: xmlExpFree(ctxt, expr);
! 177: if (xmlExpCtxtNbNodes(ctxt) != 0)
! 178: printf(" Parse/free of Expression leaked %d\n",
! 179: xmlExpCtxtNbNodes(ctxt));
! 180: }
! 181: fclose(input);
! 182: }
! 183:
! 184: static void
! 185: testReduce(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr, const char *tst) {
! 186: xmlBufferPtr xmlExpBuf;
! 187: xmlExpNodePtr sub, deriv;
! 188: xmlExpBuf = xmlBufferCreate();
! 189:
! 190: sub = xmlExpParse(ctxt, tst);
! 191: if (sub == NULL) {
! 192: printf("Subset %s failed to parse\n", tst);
! 193: return;
! 194: }
! 195: xmlExpDump(xmlExpBuf, sub);
! 196: printf("Subset parsed as: %s\n",
! 197: (const char *) xmlBufferContent(xmlExpBuf));
! 198: deriv = xmlExpExpDerive(ctxt, expr, sub);
! 199: if (deriv == NULL) {
! 200: printf("Derivation led to an internal error, report this !\n");
! 201: return;
! 202: } else {
! 203: xmlBufferEmpty(xmlExpBuf);
! 204: xmlExpDump(xmlExpBuf, deriv);
! 205: if (xmlExpIsNillable(deriv))
! 206: printf("Resulting nillable derivation: %s\n",
! 207: (const char *) xmlBufferContent(xmlExpBuf));
! 208: else
! 209: printf("Resulting derivation: %s\n",
! 210: (const char *) xmlBufferContent(xmlExpBuf));
! 211: xmlExpFree(ctxt, deriv);
! 212: }
! 213: xmlExpFree(ctxt, sub);
! 214: }
! 215:
! 216: static void
! 217: exprDebug(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr) {
! 218: xmlBufferPtr xmlExpBuf;
! 219: xmlExpNodePtr deriv;
! 220: const char *list[40];
! 221: int ret;
! 222:
! 223: xmlExpBuf = xmlBufferCreate();
! 224:
! 225: if (expr == NULL) {
! 226: printf("Failed to parse\n");
! 227: return;
! 228: }
! 229: xmlExpDump(xmlExpBuf, expr);
! 230: printf("Parsed as: %s\n", (const char *) xmlBufferContent(xmlExpBuf));
! 231: printf("Max token input = %d\n", xmlExpMaxToken(expr));
! 232: if (xmlExpIsNillable(expr) == 1)
! 233: printf("Is nillable\n");
! 234: ret = xmlExpGetLanguage(ctxt, expr, (const xmlChar **) &list[0], 40);
! 235: if (ret < 0)
! 236: printf("Failed to get list: %d\n", ret);
! 237: else {
! 238: int i;
! 239:
! 240: printf("Language has %d strings, testing string derivations\n", ret);
! 241: for (i = 0;i < ret;i++) {
! 242: deriv = xmlExpStringDerive(ctxt, expr, BAD_CAST list[i], -1);
! 243: if (deriv == NULL) {
! 244: printf(" %s -> derivation failed\n", list[i]);
! 245: } else {
! 246: xmlBufferEmpty(xmlExpBuf);
! 247: xmlExpDump(xmlExpBuf, deriv);
! 248: printf(" %s -> %s\n", list[i],
! 249: (const char *) xmlBufferContent(xmlExpBuf));
! 250: }
! 251: xmlExpFree(ctxt, deriv);
! 252: }
! 253: }
! 254: xmlBufferFree(xmlExpBuf);
! 255: }
! 256: #endif
! 257:
! 258: static void usage(const char *name) {
! 259: fprintf(stderr, "Usage: %s [flags]\n", name);
! 260: fprintf(stderr, "Testing tool for libxml2 string and pattern regexps\n");
! 261: fprintf(stderr, " --debug: switch on debugging\n");
! 262: fprintf(stderr, " --repeat: loop on the operation\n");
! 263: #ifdef LIBXML_EXPR_ENABLED
! 264: fprintf(stderr, " --expr: test xmlExp and not xmlRegexp\n");
! 265: #endif
! 266: fprintf(stderr, " --input filename: use the given filename for regexp\n");
! 267: fprintf(stderr, " --input filename: use the given filename for exp\n");
! 268: }
! 269:
! 270: int main(int argc, char **argv) {
! 271: xmlRegexpPtr comp = NULL;
! 272: #ifdef LIBXML_EXPR_ENABLED
! 273: xmlExpNodePtr expr = NULL;
! 274: int use_exp = 0;
! 275: xmlExpCtxtPtr ctxt = NULL;
! 276: #endif
! 277: const char *pattern = NULL;
! 278: char *filename = NULL;
! 279: int i;
! 280:
! 281: xmlInitMemory();
! 282:
! 283: if (argc <= 1) {
! 284: usage(argv[0]);
! 285: return(1);
! 286: }
! 287: for (i = 1; i < argc ; i++) {
! 288: if (!strcmp(argv[i], "-"))
! 289: break;
! 290:
! 291: if (argv[i][0] != '-')
! 292: continue;
! 293: if (!strcmp(argv[i], "--"))
! 294: break;
! 295:
! 296: if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug"))) {
! 297: debug++;
! 298: } else if ((!strcmp(argv[i], "-repeat")) ||
! 299: (!strcmp(argv[i], "--repeat"))) {
! 300: repeat++;
! 301: #ifdef LIBXML_EXPR_ENABLED
! 302: } else if ((!strcmp(argv[i], "-expr")) ||
! 303: (!strcmp(argv[i], "--expr"))) {
! 304: use_exp++;
! 305: #endif
! 306: } else if ((!strcmp(argv[i], "-i")) || (!strcmp(argv[i], "-f")) ||
! 307: (!strcmp(argv[i], "--input")))
! 308: filename = argv[++i];
! 309: else {
! 310: fprintf(stderr, "Unknown option %s\n", argv[i]);
! 311: usage(argv[0]);
! 312: }
! 313: }
! 314:
! 315: #ifdef LIBXML_EXPR_ENABLED
! 316: if (use_exp)
! 317: ctxt = xmlExpNewCtxt(0, NULL);
! 318: #endif
! 319:
! 320: if (filename != NULL) {
! 321: #ifdef LIBXML_EXPR_ENABLED
! 322: if (use_exp)
! 323: runFileTest(ctxt, filename);
! 324: else
! 325: #endif
! 326: testRegexpFile(filename);
! 327: } else {
! 328: int data = 0;
! 329: #ifdef LIBXML_EXPR_ENABLED
! 330:
! 331: if (use_exp) {
! 332: for (i = 1; i < argc ; i++) {
! 333: if (strcmp(argv[i], "--") == 0)
! 334: data = 1;
! 335: else if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0) ||
! 336: (data == 1)) {
! 337: if (pattern == NULL) {
! 338: pattern = argv[i];
! 339: printf("Testing expr %s:\n", pattern);
! 340: expr = xmlExpParse(ctxt, pattern);
! 341: if (expr == NULL) {
! 342: printf(" failed to compile\n");
! 343: break;
! 344: }
! 345: if (debug) {
! 346: exprDebug(ctxt, expr);
! 347: }
! 348: } else {
! 349: testReduce(ctxt, expr, argv[i]);
! 350: }
! 351: }
! 352: }
! 353: if (expr != NULL) {
! 354: xmlExpFree(ctxt, expr);
! 355: expr = NULL;
! 356: }
! 357: } else
! 358: #endif
! 359: {
! 360: for (i = 1; i < argc ; i++) {
! 361: if (strcmp(argv[i], "--") == 0)
! 362: data = 1;
! 363: else if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0) ||
! 364: (data == 1)) {
! 365: if (pattern == NULL) {
! 366: pattern = argv[i];
! 367: printf("Testing %s:\n", pattern);
! 368: comp = xmlRegexpCompile((const xmlChar *) pattern);
! 369: if (comp == NULL) {
! 370: printf(" failed to compile\n");
! 371: break;
! 372: }
! 373: if (debug)
! 374: xmlRegexpPrint(stdout, comp);
! 375: } else {
! 376: testRegexp(comp, argv[i]);
! 377: }
! 378: }
! 379: }
! 380: if (comp != NULL)
! 381: xmlRegFreeRegexp(comp);
! 382: }
! 383: }
! 384: #ifdef LIBXML_EXPR_ENABLED
! 385: if (ctxt != NULL) {
! 386: printf("Ops: %d nodes, %d cons\n",
! 387: xmlExpCtxtNbNodes(ctxt), xmlExpCtxtNbCons(ctxt));
! 388: xmlExpFreeCtxt(ctxt);
! 389: }
! 390: #endif
! 391: xmlCleanupParser();
! 392: xmlMemoryDump();
! 393: return(0);
! 394: }
! 395:
! 396: #else
! 397: #include <stdio.h>
! 398: int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
! 399: printf("%s : Regexp support not compiled in\n", argv[0]);
! 400: return(0);
! 401: }
! 402: #endif /* LIBXML_REGEXP_ENABLED */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to testRegexp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2