![[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|
Return to testRegexp.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2 |
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 */