ReactOS Development > Doxygen

00001 /*
00002  * testRegexp.c: simple module for testing regular expressions
00003  *
00004  * See Copyright for the status of this software.
00005  *
00006  * Daniel Veillard <veillard@redhat.com>
00007  */
00008 
00009 #include "libxml.h"
00010 #ifdef LIBXML_REGEXP_ENABLED
00011 #include <string.h>
00012 
00013 #include <libxml/tree.h>
00014 #include <libxml/xmlregexp.h>
00015 
00016 static int repeat = 0;
00017 static int debug = 0;
00018 
00019 static void testRegexp(xmlRegexpPtr comp, const char *value) {
00020     int ret;
00021 
00022     ret = xmlRegexpExec(comp, (const xmlChar *) value);
00023     if (ret == 1)
00024     printf("%s: Ok\n", value);
00025     else if (ret == 0)
00026     printf("%s: Fail\n", value);
00027     else
00028     printf("%s: Error: %d\n", value, ret);
00029     if (repeat) {
00030     int j;
00031     for (j = 0;j < 999999;j++)
00032         xmlRegexpExec(comp, (const xmlChar *) value);
00033     }
00034 }
00035 
00036 static void
00037 testRegexpFile(const char *filename) {
00038     xmlRegexpPtr comp = NULL;
00039     FILE *input;
00040     char expression[5000];
00041     int len;
00042 
00043     input = fopen(filename, "r");
00044     if (input == NULL) {
00045         xmlGenericError(xmlGenericErrorContext,
00046         "Cannot open %s for reading\n", filename);
00047     return;
00048     }
00049     while (fgets(expression, 4500, input) != NULL) {
00050     len = strlen(expression);
00051     len--;
00052     while ((len >= 0) && 
00053            ((expression[len] == '\n') || (expression[len] == '\t') ||
00054         (expression[len] == '\r') || (expression[len] == ' '))) len--;
00055     expression[len + 1] = 0;      
00056     if (len >= 0) {
00057         if (expression[0] == '#')
00058         continue;
00059         if ((expression[0] == '=') && (expression[1] == '>')) {
00060         char *pattern = &expression[2];
00061 
00062         if (comp != NULL) {
00063             xmlRegFreeRegexp(comp);
00064             comp = NULL;
00065         }
00066         printf("Regexp: %s\n", pattern) ;
00067         comp = xmlRegexpCompile((const xmlChar *) pattern);
00068         if (comp == NULL) {
00069             printf("   failed to compile\n");
00070             break;
00071         }
00072         } else if (comp == NULL) {
00073         printf("Regexp: %s\n", expression) ;
00074         comp = xmlRegexpCompile((const xmlChar *) expression);
00075         if (comp == NULL) {
00076             printf("   failed to compile\n");
00077             break;
00078         }
00079         } else if (comp != NULL) {
00080         testRegexp(comp, expression);
00081         }
00082     }
00083     }
00084     fclose(input);
00085     if (comp != NULL)
00086     xmlRegFreeRegexp(comp);
00087 }
00088 
00089 #ifdef LIBXML_EXPR_ENABLED
00090 static void
00091 runFileTest(xmlExpCtxtPtr ctxt, const char *filename) {
00092     xmlExpNodePtr expr = NULL, sub;
00093     FILE *input;
00094     char expression[5000];
00095     int len;
00096 
00097     input = fopen(filename, "r");
00098     if (input == NULL) {
00099         xmlGenericError(xmlGenericErrorContext,
00100         "Cannot open %s for reading\n", filename);
00101     return;
00102     }
00103     while (fgets(expression, 4500, input) != NULL) {
00104     len = strlen(expression);
00105     len--;
00106     while ((len >= 0) && 
00107            ((expression[len] == '\n') || (expression[len] == '\t') ||
00108         (expression[len] == '\r') || (expression[len] == ' '))) len--;
00109     expression[len + 1] = 0;      
00110     if (len >= 0) {
00111         if (expression[0] == '#')
00112         continue;
00113         if ((expression[0] == '=') && (expression[1] == '>')) {
00114         char *str = &expression[2];
00115 
00116         if (expr != NULL) {
00117             xmlExpFree(ctxt, expr);
00118             if (xmlExpCtxtNbNodes(ctxt) != 0) 
00119                 printf(" Parse/free of Expression leaked %d\n",
00120                    xmlExpCtxtNbNodes(ctxt));
00121             expr = NULL;
00122         }
00123         printf("Expression: %s\n", str) ;
00124         expr = xmlExpParse(ctxt, str);
00125         if (expr == NULL) {
00126             printf("   parsing Failed\n");
00127             break;
00128         }
00129         } else if (expr != NULL) {
00130             int expect = -1;
00131         int nodes1, nodes2;
00132 
00133         if (expression[0] == '0')
00134             expect = 0;
00135         if (expression[0] == '1')
00136             expect = 1;
00137         printf("Subexp: %s", expression + 2) ;
00138         nodes1 = xmlExpCtxtNbNodes(ctxt);
00139         sub = xmlExpParse(ctxt, expression + 2);
00140         if (sub == NULL) {
00141             printf("   parsing Failed\n");
00142             break;
00143         } else {
00144             int ret;
00145             
00146             nodes2 = xmlExpCtxtNbNodes(ctxt);
00147             ret = xmlExpSubsume(ctxt, expr, sub);
00148 
00149             if ((expect == 1) && (ret == 1)) {
00150             printf(" => accept, Ok\n");
00151             } else if ((expect == 0) && (ret == 0)) {
00152                 printf(" => reject, Ok\n");
00153             } else if ((expect == 1) && (ret == 0)) {
00154             printf(" => reject, Failed\n");
00155             } else if ((expect == 0) && (ret == 1)) {
00156             printf(" => accept, Failed\n");
00157             } else {
00158                 printf(" => fail internally\n");
00159             }
00160             if (xmlExpCtxtNbNodes(ctxt) > nodes2) {
00161                 printf(" Subsume leaked %d\n",
00162                    xmlExpCtxtNbNodes(ctxt) - nodes2);
00163             nodes1 += xmlExpCtxtNbNodes(ctxt) - nodes2;
00164             }
00165             xmlExpFree(ctxt, sub);
00166             if (xmlExpCtxtNbNodes(ctxt) > nodes1) {
00167                 printf(" Parse/free leaked %d\n",
00168                    xmlExpCtxtNbNodes(ctxt) - nodes1);
00169             }
00170         }
00171 
00172         }
00173     }
00174     }
00175     if (expr != NULL) {
00176     xmlExpFree(ctxt, expr);
00177     if (xmlExpCtxtNbNodes(ctxt) != 0) 
00178         printf(" Parse/free of Expression leaked %d\n",
00179            xmlExpCtxtNbNodes(ctxt));
00180     }
00181     fclose(input);
00182 }
00183 
00184 static void 
00185 testReduce(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr, const char *tst) {
00186     xmlBufferPtr xmlExpBuf;
00187     xmlExpNodePtr sub, deriv;
00188     xmlExpBuf = xmlBufferCreate();
00189 
00190     sub = xmlExpParse(ctxt, tst);
00191     if (sub == NULL) {
00192         printf("Subset %s failed to parse\n", tst);
00193     return;
00194     }
00195     xmlExpDump(xmlExpBuf, sub);
00196     printf("Subset parsed as: %s\n",
00197            (const char *) xmlBufferContent(xmlExpBuf));
00198     deriv = xmlExpExpDerive(ctxt, expr, sub);
00199     if (deriv == NULL) {
00200         printf("Derivation led to an internal error, report this !\n");
00201     return;
00202     } else {
00203         xmlBufferEmpty(xmlExpBuf);
00204     xmlExpDump(xmlExpBuf, deriv);
00205     if (xmlExpIsNillable(deriv))
00206         printf("Resulting nillable derivation: %s\n",
00207                (const char *) xmlBufferContent(xmlExpBuf));
00208     else
00209         printf("Resulting derivation: %s\n",
00210                (const char *) xmlBufferContent(xmlExpBuf));
00211     xmlExpFree(ctxt, deriv);
00212     }
00213     xmlExpFree(ctxt, sub);
00214 }
00215 
00216 static void 
00217 exprDebug(xmlExpCtxtPtr ctxt, xmlExpNodePtr expr) {
00218     xmlBufferPtr xmlExpBuf;
00219     xmlExpNodePtr deriv;
00220     const char *list[40];
00221     int ret;
00222 
00223     xmlExpBuf = xmlBufferCreate();
00224 
00225     if (expr == NULL) {
00226         printf("Failed to parse\n");
00227     return;
00228     }
00229     xmlExpDump(xmlExpBuf, expr);
00230     printf("Parsed as: %s\n", (const char *) xmlBufferContent(xmlExpBuf));
00231     printf("Max token input = %d\n", xmlExpMaxToken(expr));
00232     if (xmlExpIsNillable(expr) == 1)
00233     printf("Is nillable\n");
00234     ret = xmlExpGetLanguage(ctxt, expr, (const xmlChar **) &list[0], 40);
00235     if (ret < 0)
00236     printf("Failed to get list: %d\n", ret);
00237     else {
00238     int i;
00239 
00240     printf("Language has %d strings, testing string derivations\n", ret);
00241     for (i = 0;i < ret;i++) {
00242         deriv = xmlExpStringDerive(ctxt, expr, BAD_CAST list[i], -1);
00243         if (deriv == NULL) {
00244         printf("  %s -> derivation failed\n", list[i]);
00245         } else {
00246         xmlBufferEmpty(xmlExpBuf);
00247         xmlExpDump(xmlExpBuf, deriv);
00248         printf("  %s -> %s\n", list[i],
00249                (const char *) xmlBufferContent(xmlExpBuf));
00250         }
00251         xmlExpFree(ctxt, deriv);
00252     }
00253     }
00254     xmlBufferFree(xmlExpBuf);
00255 }
00256 #endif
00257 
00258 static void usage(const char *name) {
00259     fprintf(stderr, "Usage: %s [flags]\n", name);
00260     fprintf(stderr, "Testing tool for libxml2 string and pattern regexps\n");
00261     fprintf(stderr, "   --debug: switch on debugging\n");
00262     fprintf(stderr, "   --repeat: loop on the operation\n");
00263 #ifdef LIBXML_EXPR_ENABLED
00264     fprintf(stderr, "   --expr: test xmlExp and not xmlRegexp\n");
00265 #endif
00266     fprintf(stderr, "   --input filename: use the given filename for regexp\n");
00267     fprintf(stderr, "   --input filename: use the given filename for exp\n");
00268 }
00269 
00270 int main(int argc, char **argv) {
00271     xmlRegexpPtr comp = NULL;
00272 #ifdef LIBXML_EXPR_ENABLED
00273     xmlExpNodePtr expr = NULL;
00274     int use_exp = 0;
00275     xmlExpCtxtPtr ctxt = NULL;
00276 #endif
00277     const char *pattern = NULL;
00278     char *filename = NULL;
00279     int i;
00280 
00281     xmlInitMemory();
00282 
00283     if (argc <= 1) {
00284     usage(argv[0]);
00285     return(1);
00286     }
00287     for (i = 1; i < argc ; i++) {
00288     if (!strcmp(argv[i], "-"))
00289         break;
00290 
00291     if (argv[i][0] != '-')
00292         continue;
00293     if (!strcmp(argv[i], "--"))
00294         break;
00295 
00296     if ((!strcmp(argv[i], "-debug")) || (!strcmp(argv[i], "--debug"))) {
00297         debug++;
00298     } else if ((!strcmp(argv[i], "-repeat")) ||
00299              (!strcmp(argv[i], "--repeat"))) {
00300         repeat++;
00301 #ifdef LIBXML_EXPR_ENABLED
00302     } else if ((!strcmp(argv[i], "-expr")) ||
00303              (!strcmp(argv[i], "--expr"))) {
00304         use_exp++;
00305 #endif
00306     } else if ((!strcmp(argv[i], "-i")) || (!strcmp(argv[i], "-f")) ||
00307            (!strcmp(argv[i], "--input")))
00308         filename = argv[++i];
00309         else {
00310         fprintf(stderr, "Unknown option %s\n", argv[i]);
00311         usage(argv[0]);
00312     }
00313     }
00314 
00315 #ifdef LIBXML_EXPR_ENABLED
00316     if (use_exp)
00317     ctxt = xmlExpNewCtxt(0, NULL);
00318 #endif
00319 
00320     if (filename != NULL) {
00321 #ifdef LIBXML_EXPR_ENABLED
00322         if (use_exp)
00323         runFileTest(ctxt, filename);
00324     else
00325 #endif
00326         testRegexpFile(filename);
00327     } else {
00328         int  data = 0;
00329 #ifdef LIBXML_EXPR_ENABLED
00330 
00331         if (use_exp) {
00332         for (i = 1; i < argc ; i++) {
00333             if (strcmp(argv[i], "--") == 0)
00334             data = 1;
00335         else if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0) ||
00336             (data == 1)) {
00337             if (pattern == NULL) {
00338             pattern = argv[i];
00339             printf("Testing expr %s:\n", pattern);
00340             expr = xmlExpParse(ctxt, pattern);
00341             if (expr == NULL) {
00342                 printf("   failed to compile\n");
00343                 break;
00344             }
00345             if (debug) {
00346                 exprDebug(ctxt, expr);
00347             }
00348             } else {
00349             testReduce(ctxt, expr, argv[i]);
00350             }
00351         }
00352         }
00353         if (expr != NULL) {
00354         xmlExpFree(ctxt, expr);
00355         expr = NULL;
00356         }
00357     } else
00358 #endif
00359         {
00360         for (i = 1; i < argc ; i++) {
00361             if (strcmp(argv[i], "--") == 0)
00362             data = 1;
00363         else if ((argv[i][0] != '-') || (strcmp(argv[i], "-") == 0) ||
00364                  (data == 1)) {
00365             if (pattern == NULL) {
00366             pattern = argv[i];
00367             printf("Testing %s:\n", pattern);
00368             comp = xmlRegexpCompile((const xmlChar *) pattern);
00369             if (comp == NULL) {
00370                 printf("   failed to compile\n");
00371                 break;
00372             }
00373             if (debug)
00374                 xmlRegexpPrint(stdout, comp);
00375             } else {
00376             testRegexp(comp, argv[i]);
00377             }
00378         }
00379         }
00380         if (comp != NULL)
00381         xmlRegFreeRegexp(comp);
00382         }
00383     }
00384 #ifdef LIBXML_EXPR_ENABLED
00385     if (ctxt != NULL) {
00386     printf("Ops: %d nodes, %d cons\n",
00387            xmlExpCtxtNbNodes(ctxt), xmlExpCtxtNbCons(ctxt));
00388     xmlExpFreeCtxt(ctxt);
00389     }
00390 #endif
00391     xmlCleanupParser();
00392     xmlMemoryDump();
00393     return(0);
00394 }
00395 
00396 #else
00397 #include <stdio.h>
00398 int main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) {
00399     printf("%s : Regexp support not compiled in\n", argv[0]);
00400     return(0);
00401 }
00402 #endif /* LIBXML_REGEXP_ENABLED */
Generated on Sat May 26 2012 04:33:32 for ReactOS by
1.7.6.1