1 #ifndef __XPATHTOKEN_H__\r
2 #define __XPATHTOKEN_H__\r
3 \r
4 /**\r
5 * Phoebe DOM Implementation.\r
6 *\r
7 * This is a C++ approximation of the W3C DOM model, which follows\r
8 * fairly closely the specifications in the various .idl files, copies of\r
9 * which are provided for reference. Most important is this one:\r
10 *\r
11 * http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/idl-definitions.html\r
12 *\r
13 * Authors:\r
14 * Bob Jamison\r
15 *\r
16 * Copyright (C) 2006 Bob Jamison\r
17 *\r
18 * This library is free software; you can redistribute it and/or\r
19 * modify it under the terms of the GNU Lesser General Public\r
20 * License as published by the Free Software Foundation; either\r
21 * version 2.1 of the License, or (at your option) any later version.\r
22 *\r
23 * This library is distributed in the hope that it will be useful,\r
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r
26 * Lesser General Public License for more details.\r
27 *\r
28 * You should have received a copy of the GNU Lesser General Public\r
29 * License along with this library; if not, write to the Free Software\r
30 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\r
31 */\r
32 \r
33 \r
34 #include "dom.h"\r
35 \r
36 #include <math.h>\r
37 \r
38 #include <vector>\r
39 \r
40 namespace org\r
41 {\r
42 namespace w3c\r
43 {\r
44 namespace dom\r
45 {\r
46 namespace xpath\r
47 {\r
48 \r
49 typedef org::w3c::dom::DOMString DOMString;\r
50 \r
51 class Axis\r
52 {\r
53 public:\r
54 /**\r
55 * Constructor\r
56 */\r
57 Axis();\r
58 \r
59 /**\r
60 * Constructor\r
61 */\r
62 Axis(int tokPos);\r
63 \r
64 /**\r
65 * Copy constructor\r
66 */\r
67 Axis(const Axis &other);\r
68 \r
69 /**\r
70 * Destructor\r
71 */\r
72 virtual ~Axis();\r
73 \r
74 /**\r
75 *\r
76 */\r
77 Axis &operator=(const Axis &other);\r
78 \r
79 /**\r
80 *\r
81 */\r
82 void init();\r
83 \r
84 /**\r
85 *\r
86 */\r
87 void assign(const Axis &other);\r
88 \r
89 /**\r
90 *\r
91 */\r
92 void setPosition(unsigned int val);\r
93 \r
94 /**\r
95 *\r
96 */\r
97 unsigned int getPosition();\r
98 \r
99 /**\r
100 *\r
101 */\r
102 void setNode(const Node *node);\r
103 \r
104 /**\r
105 *\r
106 */\r
107 Node *getNode();\r
108 \r
109 private:\r
110 \r
111 int tokenPosition;\r
112 \r
113 Node *node;\r
114 };\r
115 \r
116 \r
117 /**\r
118 * This represents a single value on the evaluation stack\r
119 */\r
120 class StackItem\r
121 {\r
122 public:\r
123 \r
124 /**\r
125 * Constructor\r
126 */\r
127 StackItem();\r
128 \r
129 /**\r
130 * Copy constructor\r
131 */\r
132 StackItem(const StackItem &other);\r
133 \r
134 /**\r
135 * Destructor\r
136 */\r
137 virtual ~StackItem();\r
138 \r
139 /**\r
140 *\r
141 */\r
142 StackItem &operator=(const StackItem &other);\r
143 \r
144 /**\r
145 *\r
146 */\r
147 void assign(const StackItem &other);\r
148 \r
149 \r
150 //treat the stack item like an union of string, integer, and double\r
151 \r
152 /**\r
153 * String value\r
154 */\r
155 DOMString sval;\r
156 \r
157 /**\r
158 * Integer value\r
159 */\r
160 long ival;\r
161 \r
162 /**\r
163 * Double value;\r
164 */\r
165 double dval;\r
166 \r
167 };\r
168 \r
169 class TokenList;\r
170 \r
171 //########################################################################\r
172 //# T O K E N E X E C U T O R\r
173 //########################################################################\r
174 \r
175 #define STACK_SIZE 1024\r
176 \r
177 /**\r
178 * A token evaluator, with stack and axis context\r
179 */\r
180 class TokenExecutor\r
181 {\r
182 public:\r
183 \r
184 /**\r
185 * Constructor\r
186 */\r
187 TokenExecutor();\r
188 \r
189 /**\r
190 * Copy constructor\r
191 */\r
192 TokenExecutor(const TokenExecutor &other);\r
193 \r
194 /**\r
195 * Destructor\r
196 */\r
197 virtual ~TokenExecutor();\r
198 \r
199 /**\r
200 * Assign our values to those of the other\r
201 */\r
202 virtual void assign(const TokenExecutor &other);\r
203 \r
204 /**\r
205 * Reset the stack to its original settings\r
206 */\r
207 virtual void reset();\r
208 \r
209 /**\r
210 * Push a stack item onto the stack\r
211 */\r
212 virtual void push(StackItem &item);\r
213 \r
214 /**\r
215 * Pop a stack item from the stack\r
216 */\r
217 virtual StackItem pop();\r
218 \r
219 /**\r
220 * Execute a token list on the stack\r
221 */\r
222 NodeList execute(const TokenList &list, const Node *node);\r
223 \r
224 /**\r
225 *\r
226 */\r
227 Axis axis;\r
228 \r
229 /**\r
230 *\r
231 */\r
232 std::vector<Axis> axisStack;\r
233 \r
234 private:\r
235 \r
236 /**\r
237 * Contains the StackItem stack;\r
238 */\r
239 StackItem stack[STACK_SIZE];\r
240 \r
241 /**\r
242 * Marks the head of the stack, for push() and pop()\r
243 */\r
244 int stackSize;\r
245 \r
246 /**\r
247 * Current list of nodes found by the expression\r
248 */\r
249 NodeList nodeList;\r
250 \r
251 \r
252 };\r
253 \r
254 \r
255 \r
256 //########################################################################\r
257 //# X P A T H T O K E N\r
258 //########################################################################\r
259 \r
260 \r
261 \r
262 /**\r
263 * This is a pseudocode-type class that executes itself on a stack,\r
264 * much like stack-oriented languages such as FORTH or Postscript.\r
265 * Each token can pop zero or more tokens off the stack, and push\r
266 * zero or one token back onto it. When a list of tokens is completed,\r
267 * a single stack value should be left on the stack.\r
268 */\r
269 class Token\r
270 {\r
271 public:\r
272 \r
273 /**\r
274 * Token types. Look in xpathtoken.cpp's function table\r
275 * to see how these types map to their respective\r
276 * functionalities\r
277 */\r
278 typedef enum\r
279 {\r
280 //primitives\r
281 TOK_NOP = 0,\r
282 TOK_STR,\r
283 TOK_INT,\r
284 TOK_FLOAT,\r
285 //operators\r
286 TOK_AND,\r
287 TOK_OR,\r
288 TOK_MOD,\r
289 TOK_DIV,\r
290 TOK_MULTIPLY,\r
291 TOK_DOUBLE_SLASH,\r
292 TOK_SLASH,\r
293 TOK_PIPE,\r
294 TOK_PLUS,\r
295 TOK_MINUS,\r
296 TOK_NEG,\r
297 TOK_EQUALS,\r
298 TOK_NOT_EQUALS,\r
299 TOK_LESS_THAN_EQUALS,\r
300 TOK_LESS_THAN,\r
301 TOK_GREATER_THAN_EQUALS,\r
302 TOK_GREATER_THAN,\r
303 //path types\r
304 TOK_ABSOLUTE,\r
305 TOK_RELATIVE,\r
306 TOK_STEP,\r
307 TOK_NAME_TEST,\r
308 TOK_EXPR,\r
309 TOK_UNION,\r
310 //axis types\r
311 TOK_AXIS_ANCESTOR_OR_SELF,\r
312 TOK_AXIS_ANCESTOR,\r
313 TOK_AXIS_ATTRIBUTE,\r
314 TOK_AXIS_CHILD,\r
315 TOK_AXIS_DESCENDANT_OR_SELF,\r
316 TOK_AXIS_DESCENDANT,\r
317 TOK_AXIS_FOLLOWING_SIBLING,\r
318 TOK_AXIS_FOLLOWING,\r
319 TOK_AXIS_NAMESPACE,\r
320 TOK_AXIS_PARENT,\r
321 TOK_AXIS_PRECEDING_SIBLING,\r
322 TOK_AXIS_PRECEDING,\r
323 TOK_AXIS_SELF,\r
324 //function types\r
325 TOK_FUNC_LAST,\r
326 TOK_FUNC_POSITION,\r
327 TOK_FUNC_COUNT,\r
328 TOK_FUNC_ID,\r
329 TOK_FUNC_LOCAL_NAME,\r
330 TOK_FUNC_NAMESPACE_URI,\r
331 TOK_FUNC_NAME,\r
332 TOK_FUNC_STRING,\r
333 TOK_FUNC_CONCAT,\r
334 TOK_FUNC_STARTS_WITH,\r
335 TOK_FUNC_CONTAINS,\r
336 TOK_FUNC_SUBSTRING_BEFORE,\r
337 TOK_FUNC_SUBSTRING_AFTER,\r
338 TOK_FUNC_SUBSTRING,\r
339 TOK_FUNC_STRING_LENGTH,\r
340 TOK_FUNC_NORMALIZE_SPACE,\r
341 TOK_FUNC_TRANSLATE,\r
342 TOK_FUNC_BOOLEAN,\r
343 TOK_FUNC_NOT,\r
344 TOK_FUNC_TRUE,\r
345 TOK_FUNC_FALSE,\r
346 TOK_FUNC_LANG,\r
347 TOK_FUNC_NUMBER,\r
348 TOK_FUNC_SUM,\r
349 TOK_FUNC_FLOOR,\r
350 TOK_FUNC_CEILING,\r
351 TOK_FUNC_ROUND,\r
352 } TokenType;\r
353 \r
354 \r
355 \r
356 \r
357 /**\r
358 * Constructor with a NOP default type\r
359 */\r
360 Token()\r
361 {\r
362 type = TOK_NOP;\r
363 ival = 0L;\r
364 dval = 0.0;\r
365 }\r
366 \r
367 /**\r
368 * Copy constructor\r
369 */\r
370 Token(const Token &other)\r
371 {\r
372 type = other.type;\r
373 sval = other.sval;\r
374 ival = other.ival;\r
375 dval = other.dval;\r
376 }\r
377 \r
378 /**\r
379 * Destructor\r
380 */\r
381 virtual ~Token()\r
382 {}\r
383 \r
384 /**\r
385 * Return the enumerated TokenType of this token\r
386 */\r
387 virtual int getType()\r
388 { return type; }\r
389 /**\r
390 * Return the string TokenType of this token\r
391 */\r
392 virtual DOMString getTypeString();\r
393 \r
394 /**\r
395 * Let this token execute itself on the given stack,\r
396 * possibly adding Nodes to the node list.\r
397 */\r
398 virtual bool execute(TokenExecutor &stack)\r
399 { return true; }\r
400 \r
401 /**\r
402 * Print the contents of this token\r
403 */\r
404 virtual void dump()\r
405 {\r
406 printf("%s %s %f %ld\n",\r
407 getTypeString().c_str(), sval.c_str(), dval, ival);\r
408 }\r
409 \r
410 //treat the token like an union of string, integer, and double\r
411 \r
412 /**\r
413 * String value\r
414 */\r
415 DOMString sval;\r
416 \r
417 /**\r
418 * Integer value\r
419 */\r
420 long ival;\r
421 \r
422 /**\r
423 * Double value;\r
424 */\r
425 double dval;\r
426 \r
427 protected:\r
428 \r
429 /**\r
430 * The enmerated token type\r
431 */\r
432 int type;\r
433 \r
434 \r
435 private:\r
436 \r
437 \r
438 };\r
439 \r
440 \r
441 //########################################################################\r
442 //# X P A T H T O K E N T Y P E S\r
443 //########################################################################\r
444 \r
445 \r
446 \r
447 //###########################\r
448 //# V A L U E S\r
449 //###########################\r
450 \r
451 class TokStr : public Token\r
452 {\r
453 public:\r
454 TokStr(const DOMString &val)\r
455 {\r
456 type = TOK_STR;\r
457 sval = val;\r
458 }\r
459 virtual bool execute(TokenExecutor &exec)\r
460 {\r
461 StackItem item;\r
462 item.sval = sval;\r
463 exec.push(item);\r
464 return true;\r
465 }\r
466 };\r
467 \r
468 class TokFloat : public Token\r
469 {\r
470 public:\r
471 TokFloat(double val)\r
472 {\r
473 type = TOK_FLOAT;\r
474 dval = val;\r
475 }\r
476 virtual bool execute(TokenExecutor &exec)\r
477 {\r
478 StackItem item;\r
479 item.dval = dval;\r
480 exec.push(item);\r
481 return true;\r
482 }\r
483 };\r
484 \r
485 class TokInt : public Token\r
486 {\r
487 public:\r
488 TokInt(long val)\r
489 {\r
490 type = TOK_INT;\r
491 ival = val;\r
492 }\r
493 virtual bool execute(TokenExecutor &exec)\r
494 {\r
495 StackItem item;\r
496 item.ival = ival;\r
497 exec.push(item);\r
498 return true;\r
499 }\r
500 };\r
501 \r
502 class TokAnd : public Token\r
503 {\r
504 public:\r
505 TokAnd()\r
506 {\r
507 type = TOK_AND;\r
508 }\r
509 virtual bool execute(TokenExecutor &exec)\r
510 {\r
511 StackItem item1 = exec.pop();\r
512 StackItem item2 = exec.pop();\r
513 item1.ival = item1.ival && item2.ival;\r
514 exec.push(item1);\r
515 return true;\r
516 }\r
517 };\r
518 \r
519 class TokOr : public Token\r
520 {\r
521 public:\r
522 TokOr()\r
523 {\r
524 type = TOK_OR;\r
525 }\r
526 virtual bool execute(TokenExecutor &exec)\r
527 {\r
528 StackItem item1 = exec.pop();\r
529 StackItem item2 = exec.pop();\r
530 item1.ival = item1.ival || item2.ival;\r
531 exec.push(item1);\r
532 return true;\r
533 }\r
534 };\r
535 \r
536 class TokMod : public Token\r
537 {\r
538 public:\r
539 TokMod()\r
540 {\r
541 type = TOK_MOD;\r
542 }\r
543 virtual bool execute(TokenExecutor &exec)\r
544 {\r
545 StackItem item1 = exec.pop();\r
546 StackItem item2 = exec.pop();\r
547 item1.dval = fmod(item1.dval, item2.dval);\r
548 exec.push(item1);\r
549 return true;\r
550 }\r
551 };\r
552 \r
553 class TokDiv : public Token\r
554 {\r
555 public:\r
556 TokDiv()\r
557 {\r
558 type = TOK_DIV;\r
559 }\r
560 virtual bool execute(TokenExecutor &exec)\r
561 {\r
562 StackItem item1 = exec.pop();\r
563 StackItem item2 = exec.pop();\r
564 item1.dval /= item2.dval;\r
565 exec.push(item1);\r
566 return true;\r
567 }\r
568 };\r
569 \r
570 class TokMul : public Token\r
571 {\r
572 public:\r
573 TokMul()\r
574 {\r
575 type = TOK_MULTIPLY;\r
576 }\r
577 virtual bool execute(TokenExecutor &exec)\r
578 {\r
579 StackItem item1 = exec.pop();\r
580 StackItem item2 = exec.pop();\r
581 item1.dval *= item2.dval;\r
582 exec.push(item1);\r
583 return true;\r
584 }\r
585 };\r
586 \r
587 class TokPlus : public Token\r
588 {\r
589 public:\r
590 TokPlus()\r
591 {\r
592 type = TOK_PLUS;\r
593 }\r
594 virtual bool execute(TokenExecutor &exec)\r
595 {\r
596 StackItem item1 = exec.pop();\r
597 StackItem item2 = exec.pop();\r
598 item1.dval += item2.dval;\r
599 exec.push(item1);\r
600 return true;\r
601 }\r
602 };\r
603 \r
604 class TokMinus : public Token\r
605 {\r
606 public:\r
607 TokMinus()\r
608 {\r
609 type = TOK_MINUS;\r
610 }\r
611 virtual bool execute(TokenExecutor &exec)\r
612 {\r
613 StackItem item1 = exec.pop();\r
614 StackItem item2 = exec.pop();\r
615 item1.dval -= item2.dval;\r
616 exec.push(item1);\r
617 return true;\r
618 }\r
619 };\r
620 \r
621 class TokNeg : public Token\r
622 {\r
623 public:\r
624 TokNeg()\r
625 {\r
626 type = TOK_NEG;\r
627 }\r
628 virtual bool execute(TokenExecutor &exec)\r
629 {\r
630 StackItem item = exec.pop();\r
631 item.dval = -item.dval;\r
632 item.ival = -item.ival;\r
633 exec.push(item);\r
634 return true;\r
635 }\r
636 };\r
637 \r
638 class TokEquals : public Token\r
639 {\r
640 public:\r
641 TokEquals()\r
642 {\r
643 type = TOK_EQUALS;\r
644 }\r
645 virtual bool execute(TokenExecutor &exec)\r
646 {\r
647 StackItem item1 = exec.pop();\r
648 StackItem item2 = exec.pop();\r
649 item1.ival = (item1.dval == item2.dval);\r
650 exec.push(item1);\r
651 return true;\r
652 }\r
653 };\r
654 \r
655 class TokNotEquals : public Token\r
656 {\r
657 public:\r
658 TokNotEquals()\r
659 {\r
660 type = TOK_NOT_EQUALS;\r
661 }\r
662 virtual bool execute(TokenExecutor &exec)\r
663 {\r
664 StackItem item1 = exec.pop();\r
665 StackItem item2 = exec.pop();\r
666 item1.ival = (item1.dval != item2.dval);\r
667 exec.push(item1);\r
668 return true;\r
669 }\r
670 };\r
671 \r
672 class TokLessThanEquals : public Token\r
673 {\r
674 public:\r
675 TokLessThanEquals()\r
676 {\r
677 type = TOK_LESS_THAN_EQUALS;\r
678 }\r
679 virtual bool execute(TokenExecutor &exec)\r
680 {\r
681 StackItem item1 = exec.pop();\r
682 StackItem item2 = exec.pop();\r
683 item1.ival = (item1.dval <= item2.dval);\r
684 exec.push(item1);\r
685 return true;\r
686 }\r
687 };\r
688 \r
689 class TokLessThan : public Token\r
690 {\r
691 public:\r
692 TokLessThan()\r
693 {\r
694 type = TOK_LESS_THAN;\r
695 }\r
696 virtual bool execute(TokenExecutor &exec)\r
697 {\r
698 StackItem item1 = exec.pop();\r
699 StackItem item2 = exec.pop();\r
700 item1.ival = (item1.dval < item2.dval);\r
701 exec.push(item1);\r
702 return true;\r
703 }\r
704 };\r
705 \r
706 class TokGreaterThanEquals : public Token\r
707 {\r
708 public:\r
709 TokGreaterThanEquals()\r
710 {\r
711 type = TOK_GREATER_THAN_EQUALS;\r
712 }\r
713 virtual bool execute(TokenExecutor &exec)\r
714 {\r
715 StackItem item1 = exec.pop();\r
716 StackItem item2 = exec.pop();\r
717 item1.ival = (item1.dval >= item2.dval);\r
718 exec.push(item1);\r
719 return true;\r
720 }\r
721 };\r
722 \r
723 class TokGreaterThan : public Token\r
724 {\r
725 public:\r
726 TokGreaterThan()\r
727 {\r
728 type = TOK_GREATER_THAN;\r
729 }\r
730 virtual bool execute(TokenExecutor &exec)\r
731 {\r
732 StackItem item1 = exec.pop();\r
733 StackItem item2 = exec.pop();\r
734 item1.ival = (item1.dval > item2.dval);\r
735 exec.push(item1);\r
736 return true;\r
737 }\r
738 };\r
739 \r
740 \r
741 //###########################\r
742 //# X P A T H I T E M S\r
743 //###########################\r
744 \r
745 class TokAbsolute : public Token\r
746 {\r
747 public:\r
748 TokAbsolute()\r
749 {\r
750 type = TOK_ABSOLUTE;\r
751 }\r
752 virtual bool execute(TokenExecutor &exec)\r
753 {\r
754 Node *n = exec.axis.getNode();\r
755 while (n->getParentNode())\r
756 n = n->getParentNode();\r
757 exec.axis.setNode(n);\r
758 return true;\r
759 }\r
760 };\r
761 \r
762 class TokRelative : public Token\r
763 {\r
764 public:\r
765 TokRelative()\r
766 {\r
767 type = TOK_RELATIVE;\r
768 }\r
769 virtual bool execute(TokenExecutor &exec)\r
770 {\r
771 ///exec.axis.currentNode = stack.rootNode;\r
772 return true;\r
773 }\r
774 };\r
775 \r
776 class TokStep : public Token\r
777 {\r
778 public:\r
779 TokStep()\r
780 {\r
781 type = TOK_STEP;\r
782 }\r
783 virtual bool execute(TokenExecutor &exec)\r
784 {\r
785 return true;\r
786 }\r
787 };\r
788 \r
789 class TokNameTest : public Token\r
790 {\r
791 public:\r
792 TokNameTest(const DOMString &name)\r
793 {\r
794 type = TOK_NAME_TEST;\r
795 sval = name;\r
796 }\r
797 virtual bool execute(TokenExecutor &exec)\r
798 {\r
799 return true;\r
800 }\r
801 };\r
802 \r
803 class TokExpr : public Token\r
804 {\r
805 public:\r
806 TokExpr()\r
807 {\r
808 type = TOK_EXPR;\r
809 }\r
810 virtual bool execute(TokenExecutor &exec)\r
811 {\r
812 return true;\r
813 }\r
814 };\r
815 \r
816 class TokUnion : public Token\r
817 {\r
818 public:\r
819 TokUnion()\r
820 {\r
821 type = TOK_UNION;\r
822 }\r
823 virtual bool execute(TokenExecutor &exec)\r
824 {\r
825 return true;\r
826 }\r
827 };\r
828 \r
829 \r
830 \r
831 \r
832 //###########################\r
833 //# A X I S\r
834 //###########################\r
835 \r
836 \r
837 class TokAxisAncestorOrSelf : public Token\r
838 {\r
839 public:\r
840 TokAxisAncestorOrSelf()\r
841 {\r
842 type = TOK_AXIS_ANCESTOR_OR_SELF;\r
843 }\r
844 virtual bool execute(TokenExecutor &exec)\r
845 {\r
846 return true;\r
847 }\r
848 };\r
849 \r
850 class TokAxisAncestor : public Token\r
851 {\r
852 public:\r
853 TokAxisAncestor()\r
854 {\r
855 type = TOK_AXIS_ANCESTOR;\r
856 }\r
857 virtual bool execute(TokenExecutor &exec)\r
858 {\r
859 return true;\r
860 }\r
861 };\r
862 \r
863 class TokAxisAttribute : public Token\r
864 {\r
865 public:\r
866 TokAxisAttribute()\r
867 {\r
868 type = TOK_AXIS_ATTRIBUTE;\r
869 }\r
870 virtual bool execute(TokenExecutor &exec)\r
871 {\r
872 return true;\r
873 }\r
874 };\r
875 \r
876 class TokAxisChild : public Token\r
877 {\r
878 public:\r
879 TokAxisChild()\r
880 {\r
881 type = TOK_AXIS_CHILD;\r
882 }\r
883 virtual bool execute(TokenExecutor &exec)\r
884 {\r
885 return true;\r
886 }\r
887 };\r
888 \r
889 class TokAxisDescendantOrSelf : public Token\r
890 {\r
891 public:\r
892 TokAxisDescendantOrSelf()\r
893 {\r
894 type = TOK_AXIS_DESCENDANT_OR_SELF;\r
895 }\r
896 virtual bool execute(TokenExecutor &exec)\r
897 {\r
898 return true;\r
899 }\r
900 };\r
901 \r
902 class TokAxisDescendant : public Token\r
903 {\r
904 public:\r
905 TokAxisDescendant()\r
906 {\r
907 type = TOK_AXIS_DESCENDANT;\r
908 }\r
909 virtual bool execute(TokenExecutor &exec)\r
910 {\r
911 return true;\r
912 }\r
913 };\r
914 \r
915 class TokAxisFollowingSibling : public Token\r
916 {\r
917 public:\r
918 TokAxisFollowingSibling()\r
919 {\r
920 type = TOK_AXIS_FOLLOWING_SIBLING;\r
921 }\r
922 virtual bool execute(TokenExecutor &exec)\r
923 {\r
924 return true;\r
925 }\r
926 };\r
927 \r
928 class TokAxisFollowing : public Token\r
929 {\r
930 public:\r
931 TokAxisFollowing()\r
932 {\r
933 type = TOK_AXIS_FOLLOWING;\r
934 }\r
935 virtual bool execute(TokenExecutor &exec)\r
936 {\r
937 return true;\r
938 }\r
939 };\r
940 \r
941 class TokAxisNamespace : public Token\r
942 {\r
943 public:\r
944 TokAxisNamespace()\r
945 {\r
946 type = TOK_AXIS_NAMESPACE;\r
947 }\r
948 virtual bool execute(TokenExecutor &exec)\r
949 {\r
950 return true;\r
951 }\r
952 };\r
953 \r
954 class TokAxisParent : public Token\r
955 {\r
956 public:\r
957 TokAxisParent()\r
958 {\r
959 type = TOK_AXIS_PARENT;\r
960 }\r
961 virtual bool execute(TokenExecutor &exec)\r
962 {\r
963 return true;\r
964 }\r
965 };\r
966 \r
967 class TokAxisPrecedingSibling : public Token\r
968 {\r
969 public:\r
970 TokAxisPrecedingSibling()\r
971 {\r
972 type = TOK_AXIS_PRECEDING_SIBLING;\r
973 }\r
974 virtual bool execute(TokenExecutor &exec)\r
975 {\r
976 return true;\r
977 }\r
978 };\r
979 \r
980 class TokAxisPreceding : public Token\r
981 {\r
982 public:\r
983 TokAxisPreceding()\r
984 {\r
985 type = TOK_AXIS_PRECEDING;\r
986 }\r
987 virtual bool execute(TokenExecutor &exec)\r
988 {\r
989 return true;\r
990 }\r
991 };\r
992 \r
993 class TokAxisSelf : public Token\r
994 {\r
995 public:\r
996 TokAxisSelf()\r
997 {\r
998 type = TOK_AXIS_SELF;\r
999 }\r
1000 virtual bool execute(TokenExecutor &exec)\r
1001 {\r
1002 return true;\r
1003 }\r
1004 };\r
1005 \r
1006 \r
1007 \r
1008 //###########################\r
1009 //# F U N C T I O N S\r
1010 //###########################\r
1011 \r
1012 class TokFuncLast : public Token\r
1013 {\r
1014 public:\r
1015 TokFuncLast()\r
1016 {\r
1017 type = TOK_FUNC_LAST;\r
1018 }\r
1019 virtual bool execute(TokenExecutor &exec)\r
1020 {\r
1021 return true;\r
1022 }\r
1023 };\r
1024 \r
1025 class TokFuncPosition : public Token\r
1026 {\r
1027 public:\r
1028 TokFuncPosition()\r
1029 {\r
1030 type = TOK_FUNC_POSITION;\r
1031 }\r
1032 virtual bool execute(TokenExecutor &exec)\r
1033 {\r
1034 return true;\r
1035 }\r
1036 };\r
1037 \r
1038 class TokFuncCount : public Token\r
1039 {\r
1040 public:\r
1041 TokFuncCount()\r
1042 {\r
1043 type = TOK_FUNC_COUNT;\r
1044 }\r
1045 virtual bool execute(TokenExecutor &exec)\r
1046 {\r
1047 return true;\r
1048 }\r
1049 };\r
1050 \r
1051 class TokFuncId : public Token\r
1052 {\r
1053 public:\r
1054 TokFuncId()\r
1055 {\r
1056 type = TOK_FUNC_ID;\r
1057 }\r
1058 virtual bool execute(TokenExecutor &exec)\r
1059 {\r
1060 return true;\r
1061 }\r
1062 };\r
1063 \r
1064 class TokFuncLocalName : public Token\r
1065 {\r
1066 public:\r
1067 TokFuncLocalName()\r
1068 {\r
1069 type = TOK_FUNC_LOCAL_NAME;\r
1070 }\r
1071 virtual bool execute(TokenExecutor &exec)\r
1072 {\r
1073 return true;\r
1074 }\r
1075 };\r
1076 \r
1077 class TokFuncNamespaceUri : public Token\r
1078 {\r
1079 public:\r
1080 TokFuncNamespaceUri()\r
1081 {\r
1082 type = TOK_FUNC_NAMESPACE_URI;\r
1083 }\r
1084 virtual bool execute(TokenExecutor &exec)\r
1085 {\r
1086 return true;\r
1087 }\r
1088 };\r
1089 \r
1090 class TokFuncName : public Token\r
1091 {\r
1092 public:\r
1093 TokFuncName()\r
1094 {\r
1095 type = TOK_FUNC_NAME;\r
1096 }\r
1097 virtual bool execute(TokenExecutor &exec)\r
1098 {\r
1099 return true;\r
1100 }\r
1101 };\r
1102 \r
1103 class TokFuncString : public Token\r
1104 {\r
1105 public:\r
1106 TokFuncString()\r
1107 {\r
1108 type = TOK_FUNC_STRING;\r
1109 }\r
1110 virtual bool execute(TokenExecutor &exec)\r
1111 {\r
1112 return true;\r
1113 }\r
1114 };\r
1115 \r
1116 class TokFuncConcat : public Token\r
1117 {\r
1118 public:\r
1119 TokFuncConcat()\r
1120 {\r
1121 type = TOK_FUNC_CONCAT;\r
1122 }\r
1123 virtual bool execute(TokenExecutor &exec)\r
1124 {\r
1125 return true;\r
1126 }\r
1127 };\r
1128 \r
1129 class TokFuncStartsWith : public Token\r
1130 {\r
1131 public:\r
1132 TokFuncStartsWith()\r
1133 {\r
1134 type = TOK_FUNC_STARTS_WITH;\r
1135 }\r
1136 virtual bool execute(TokenExecutor &exec)\r
1137 {\r
1138 return true;\r
1139 }\r
1140 };\r
1141 \r
1142 class TokFuncContains : public Token\r
1143 {\r
1144 public:\r
1145 TokFuncContains()\r
1146 {\r
1147 type = TOK_FUNC_CONTAINS;\r
1148 }\r
1149 virtual bool execute(TokenExecutor &exec)\r
1150 {\r
1151 return true;\r
1152 }\r
1153 };\r
1154 \r
1155 class TokFuncSubstringBefore : public Token\r
1156 {\r
1157 public:\r
1158 TokFuncSubstringBefore()\r
1159 {\r
1160 type = TOK_FUNC_SUBSTRING_BEFORE;\r
1161 }\r
1162 virtual bool execute(TokenExecutor &exec)\r
1163 {\r
1164 return true;\r
1165 }\r
1166 };\r
1167 \r
1168 class TokFuncSubstringAfter : public Token\r
1169 {\r
1170 public:\r
1171 TokFuncSubstringAfter()\r
1172 {\r
1173 type = TOK_FUNC_SUBSTRING_AFTER;\r
1174 }\r
1175 virtual bool execute(TokenExecutor &exec)\r
1176 {\r
1177 return true;\r
1178 }\r
1179 };\r
1180 \r
1181 class TokFuncSubstring : public Token\r
1182 {\r
1183 public:\r
1184 TokFuncSubstring()\r
1185 {\r
1186 type = TOK_FUNC_SUBSTRING;\r
1187 }\r
1188 virtual bool execute(TokenExecutor &exec)\r
1189 {\r
1190 return true;\r
1191 }\r
1192 };\r
1193 \r
1194 class TokFuncStringLength : public Token\r
1195 {\r
1196 public:\r
1197 TokFuncStringLength()\r
1198 {\r
1199 type = TOK_FUNC_STRING_LENGTH;\r
1200 }\r
1201 virtual bool execute(TokenExecutor &exec)\r
1202 {\r
1203 return true;\r
1204 }\r
1205 };\r
1206 \r
1207 class TokFuncNormalizeSpace : public Token\r
1208 {\r
1209 public:\r
1210 TokFuncNormalizeSpace()\r
1211 {\r
1212 type = TOK_FUNC_NORMALIZE_SPACE;\r
1213 }\r
1214 virtual bool execute(TokenExecutor &exec)\r
1215 {\r
1216 return true;\r
1217 }\r
1218 };\r
1219 \r
1220 class TokFuncTranslate : public Token\r
1221 {\r
1222 public:\r
1223 TokFuncTranslate()\r
1224 {\r
1225 type = TOK_FUNC_TRANSLATE;\r
1226 }\r
1227 virtual bool execute(TokenExecutor &exec)\r
1228 {\r
1229 return true;\r
1230 }\r
1231 };\r
1232 \r
1233 class TokFuncBoolean : public Token\r
1234 {\r
1235 public:\r
1236 TokFuncBoolean()\r
1237 {\r
1238 type = TOK_FUNC_BOOLEAN;\r
1239 }\r
1240 virtual bool execute(TokenExecutor &exec)\r
1241 {\r
1242 return true;\r
1243 }\r
1244 };\r
1245 \r
1246 class TokFuncNot : public Token\r
1247 {\r
1248 public:\r
1249 TokFuncNot()\r
1250 {\r
1251 type = TOK_FUNC_NOT;\r
1252 }\r
1253 virtual bool execute(TokenExecutor &exec)\r
1254 {\r
1255 return true;\r
1256 }\r
1257 };\r
1258 \r
1259 class TokFuncTrue : public Token\r
1260 {\r
1261 public:\r
1262 TokFuncTrue()\r
1263 {\r
1264 type = TOK_FUNC_TRUE;\r
1265 }\r
1266 virtual bool execute(TokenExecutor &exec)\r
1267 {\r
1268 return true;\r
1269 }\r
1270 };\r
1271 \r
1272 class TokFuncFalse : public Token\r
1273 {\r
1274 public:\r
1275 TokFuncFalse()\r
1276 {\r
1277 type = TOK_FUNC_FALSE;\r
1278 }\r
1279 virtual bool execute(TokenExecutor &exec)\r
1280 {\r
1281 return true;\r
1282 }\r
1283 };\r
1284 \r
1285 class TokFuncLang : public Token\r
1286 {\r
1287 public:\r
1288 TokFuncLang()\r
1289 {\r
1290 type = TOK_FUNC_LANG;\r
1291 }\r
1292 virtual bool execute(TokenExecutor &exec)\r
1293 {\r
1294 return true;\r
1295 }\r
1296 };\r
1297 \r
1298 class TokFuncNumber : public Token\r
1299 {\r
1300 public:\r
1301 TokFuncNumber()\r
1302 {\r
1303 type = TOK_FUNC_NUMBER;\r
1304 }\r
1305 virtual bool execute(TokenExecutor &exec)\r
1306 {\r
1307 return true;\r
1308 }\r
1309 };\r
1310 \r
1311 class TokFuncSum : public Token\r
1312 {\r
1313 public:\r
1314 TokFuncSum()\r
1315 {\r
1316 type = TOK_FUNC_SUM;\r
1317 }\r
1318 virtual bool execute(TokenExecutor &exec)\r
1319 {\r
1320 return true;\r
1321 }\r
1322 };\r
1323 \r
1324 class TokFuncFloor : public Token\r
1325 {\r
1326 public:\r
1327 TokFuncFloor()\r
1328 {\r
1329 type = TOK_FUNC_FLOOR;\r
1330 }\r
1331 virtual bool execute(TokenExecutor &exec)\r
1332 {\r
1333 return true;\r
1334 }\r
1335 };\r
1336 \r
1337 class TokFuncCeiling : public Token\r
1338 {\r
1339 public:\r
1340 TokFuncCeiling()\r
1341 {\r
1342 type = TOK_FUNC_CEILING;\r
1343 }\r
1344 virtual bool execute(TokenExecutor &exec)\r
1345 {\r
1346 return true;\r
1347 }\r
1348 };\r
1349 \r
1350 class TokFuncRound : public Token\r
1351 {\r
1352 public:\r
1353 TokFuncRound()\r
1354 {\r
1355 type = TOK_FUNC_ROUND;\r
1356 }\r
1357 virtual bool execute(TokenExecutor &exec)\r
1358 {\r
1359 return true;\r
1360 }\r
1361 };\r
1362 \r
1363 \r
1364 \r
1365 \r
1366 \r
1367 \r
1368 //########################################################################\r
1369 //# T O K E N L I S T\r
1370 //########################################################################\r
1371 \r
1372 /**\r
1373 *\r
1374 */\r
1375 class TokenList\r
1376 {\r
1377 public:\r
1378 \r
1379 /**\r
1380 *\r
1381 */\r
1382 TokenList();\r
1383 \r
1384 /**\r
1385 *\r
1386 */\r
1387 TokenList(const TokenList &other);\r
1388 \r
1389 /**\r
1390 *\r
1391 */\r
1392 TokenList &operator=(const TokenList &other);\r
1393 \r
1394 /**\r
1395 *\r
1396 */\r
1397 void assign(const TokenList &other);\r
1398 \r
1399 /**\r
1400 *\r
1401 */\r
1402 virtual ~TokenList();\r
1403 \r
1404 /**\r
1405 *\r
1406 */\r
1407 virtual void clear();\r
1408 \r
1409 /**\r
1410 *\r
1411 */\r
1412 virtual void add(Token *tok);\r
1413 \r
1414 /**\r
1415 *\r
1416 */\r
1417 virtual unsigned int size() const;\r
1418 \r
1419 /**\r
1420 *\r
1421 */\r
1422 virtual void dump();\r
1423 \r
1424 private:\r
1425 \r
1426 \r
1427 std::vector<Token *> tokens;\r
1428 \r
1429 \r
1430 };\r
1431 \r
1432 \r
1433 \r
1434 \r
1435 \r
1436 \r
1437 \r
1438 } // namespace xpath\r
1439 } // namespace dom\r
1440 } // namespace w3c\r
1441 } // namespace org\r
1442 \r
1443 \r
1444 \r
1445 \r
1446 \r
1447 \r
1448 #endif /* __XPATHTOKEN_H__ */\r
1449 //########################################################################\r
1450 //# E N D O F F I L E\r
1451 //########################################################################\r
1452 \r