View Javadoc

1   /*
2    * $Header$
3    * $Revision: 1334 $
4    * $Date: 2008-11-29 09:58:48 -0800 (Sat, 29 Nov 2008) $
5    *
6    * ====================================================================
7    *
8    * Copyright 2000-2002 bob mcwhirter & James Strachan.
9    * All rights reserved.
10   *
11   *
12   * Redistribution and use in source and binary forms, with or without
13   * modification, are permitted provided that the following conditions are
14   * met:
15   * 
16   *   * Redistributions of source code must retain the above copyright
17   *     notice, this list of conditions and the following disclaimer.
18   * 
19   *   * Redistributions in binary form must reproduce the above copyright
20   *     notice, this list of conditions and the following disclaimer in the
21   *     documentation and/or other materials provided with the distribution.
22   * 
23   *   * Neither the name of the Jaxen Project nor the names of its
24   *     contributors may be used to endorse or promote products derived 
25   *     from this software without specific prior written permission.
26   * 
27   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
28   * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29   * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
30   * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
31   * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
32   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
33   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
34   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
35   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38   *
39   * ====================================================================
40   * This software consists of voluntary contributions made by many
41   * individuals on behalf of the Jaxen Project and was originally
42   * created by bob mcwhirter <bob@werken.com> and
43   * James Strachan <jstrachan@apache.org>.  For more information on the
44   * Jaxen Project, please see <http://www.jaxen.org/>.
45   *
46   * $Id: XPathLexer.java 1334 2008-11-29 17:58:48Z elharo $
47   */
48  
49  package org.jaxen.saxpath.base;
50  
51  class XPathLexer
52  {
53      private String xpath;
54      private int    currentPosition;
55      private int    endPosition;
56      private boolean expectOperator = false;
57  
58      XPathLexer(String xpath)
59      {
60          setXPath( xpath );
61      }
62  
63      private void setXPath(String xpath)
64      {
65          this.xpath           = xpath;
66          this.currentPosition = 0;
67          this.endPosition     = xpath.length();
68      }
69  
70      String getXPath()
71      {
72          return this.xpath;
73      }
74  
75      Token nextToken()
76      {
77          Token token = null;
78  
79          do
80          {
81              token = null;
82  
83              switch ( LA(1) )
84              {
85                  case '$':
86                  {
87                      token = dollar();
88                      break;
89                  }
90                      
91                  case '"':
92                  case '\'':
93                  {
94                      token = literal();
95                      break;
96                  }
97                      
98                  case '/':
99                  {
100                     token = slashes();
101                     break;
102                 }
103 
104                 case ',':
105                 {
106                     token = comma();
107                     break;
108                 }
109                     
110                 case '(':
111                 {
112                     token = leftParen();
113                     break;
114                 }
115                     
116                 case ')':
117                 {
118                     token = rightParen();
119                     break;
120                 }
121                     
122                 case '[':
123                 {
124                     token = leftBracket();
125                     break;
126                 }
127                     
128                 case ']':
129                 {
130                     token = rightBracket();
131                     break;
132                 }
133                     
134                 case '+':
135                 {
136                     token = plus();
137                     break;
138                 }
139                     
140                 case '-':
141                 {
142                     token = minus();
143                     break;
144                 }
145                     
146                 case '<':
147                 case '>':
148                 {
149                     token = relationalOperator();
150                     break;
151                 }        
152 
153                 case '=':
154                 {
155                     token = equals();
156                     break;
157                 }
158                     
159                 case '!':
160                 {
161                     if ( LA(2) == '=' )
162                     {
163                         token = notEquals();
164                     }
165                     break;
166                 }
167                     
168                 case '|':
169                 {
170                     token = pipe();
171                     break;
172                 }
173                     
174                 case '@':
175                 {
176                     token = at();
177                     break;
178                 }
179                     
180                 case ':':
181                 {
182                     if ( LA(2) == ':' )
183                     {
184                         token = doubleColon();
185                     }
186                     else
187                     {
188                         token = colon();
189                     }
190                     break;
191                 }
192                     
193                 case '*':
194                 {
195                     token = star();
196                     break;
197                 }
198                     
199                 case '.':
200                 {
201                     switch ( LA(2) )
202                     {
203                         case '0':
204                         case '1':
205                         case '2':
206                         case '3':
207                         case '4':
208                         case '5':
209                         case '6':
210                         case '7':
211                         case '8':
212                         case '9':
213                         {
214                             token = number();
215                             break;
216                         }
217                         default:
218                         {
219                             token = dots();
220                             break;
221                         }
222                     }
223                     break;
224                 }
225 
226                 case '0':
227                 case '1':
228                 case '2':
229                 case '3':
230                 case '4':
231                 case '5':
232                 case '6':
233                 case '7':
234                 case '8':
235                 case '9':
236                 {
237                     token = number();
238                     break;
239                 }
240 
241                 case ' ':
242                 case '\t':
243                 case '\n':
244                 case '\r':
245                 {
246                     token = whitespace();
247                     break;
248                 }
249                     
250                 default:
251                 {
252                     if ( Verifier.isXMLNCNameStartCharacter( LA(1) ) )
253                     {
254                         token = identifierOrOperatorName();
255                     }
256                 }
257             }
258 
259             if ( token == null )
260             {
261                 if (!hasMoreChars())
262                 {
263                     token = new Token( TokenTypes.EOF,
264                                    getXPath(),
265                                    this.currentPosition,
266                                    this.endPosition );
267             }
268                 else
269                 {
270                     token = new Token( TokenTypes.ERROR,
271                                    getXPath(),
272                                    this.currentPosition,
273                                    this.endPosition );
274                 }
275             }
276 
277         }
278         while (token.getTokenType() == TokenTypes.SKIP );
279         
280         // For some reason, section 3.7, Lexical structure,
281         // doesn't seem to feel like it needs to mention the
282         // SLASH, DOUBLE_SLASH, and COLON tokens for the test
283         // if an NCName is an operator or not.
284         //
285         // According to section 3.7, "/foo" should be considered
286         // as a SLASH following by an OperatorName being 'foo'.
287         // Which is just simply, clearly, wrong, in my mind.
288         //
289         //     -bob
290 
291         switch ( token.getTokenType() )
292         {
293             case TokenTypes.AT:
294             case TokenTypes.DOUBLE_COLON:
295             case TokenTypes.LEFT_PAREN:
296             case TokenTypes.LEFT_BRACKET:
297             case TokenTypes.AND:
298             case TokenTypes.OR:
299             case TokenTypes.MOD:
300             case TokenTypes.DIV:
301             case TokenTypes.COLON:
302             case TokenTypes.SLASH:
303             case TokenTypes.DOUBLE_SLASH:
304             case TokenTypes.PIPE:
305             case TokenTypes.DOLLAR:
306             case TokenTypes.PLUS:
307             case TokenTypes.MINUS:
308             case TokenTypes.STAR_OPERATOR:
309             case TokenTypes.COMMA:
310             case TokenTypes.LESS_THAN_SIGN:
311             case TokenTypes.GREATER_THAN_SIGN:
312             case TokenTypes.LESS_THAN_OR_EQUALS_SIGN:
313             case TokenTypes.GREATER_THAN_OR_EQUALS_SIGN:
314             case TokenTypes.EQUALS:
315             case TokenTypes.NOT_EQUALS:
316             {
317                 expectOperator = false;
318                 break;
319             }
320             default:
321             {
322                 expectOperator = true;
323                 break;
324             }
325         }
326 
327          return token;
328      }
329 
330     private Token identifierOrOperatorName()
331     {
332         Token token = null;
333         if ( expectOperator ) {
334             token = operatorName();
335         } else {
336             token = identifier();
337         }
338         return token;
339     }
340     
341     private Token identifier()
342     {
343         Token token = null;
344     
345         int start = this.currentPosition;
346     
347         while ( hasMoreChars() )
348         {
349             if ( Verifier.isXMLNCNameCharacter( LA(1) ) )
350             {
351                 consume();
352             }
353             else
354             {
355                 break;
356             }
357         }
358     
359         token = new Token( TokenTypes.IDENTIFIER,
360                            getXPath(),
361                            start,
362                            this.currentPosition );
363     
364         return token;
365     }
366     
367     private Token operatorName()
368     {
369         Token token = null;
370     
371         switch ( LA(1) )
372         {
373             case 'a':
374             {
375                 token = and();
376                 break;
377             }
378     
379             case 'o':
380             {
381                 token = or();
382                 break;
383             }
384     
385             case 'm':
386             {
387                 token = mod();
388                 break;
389             }
390     
391             case 'd':
392             {
393                 token = div();
394                 break;
395             }
396         }
397     
398         return token;
399     }
400     
401     private Token mod()
402     {
403         Token token = null;
404     
405         if ( ( LA(1) == 'm' )
406              &&
407              ( LA(2) == 'o' )
408              &&
409              ( LA(3) == 'd' )
410            )
411         {
412             token = new Token( TokenTypes.MOD,
413                                getXPath(),
414                                this.currentPosition,
415                                this.currentPosition+3 );
416     
417             consume();
418             consume();
419             consume();
420         }
421     
422         return token;
423     }
424     
425     private Token div()
426     {
427         Token token = null;
428     
429         if ( ( LA(1) == 'd' )
430              &&
431              ( LA(2) == 'i' )
432              &&
433              ( LA(3) == 'v' )
434             )
435         {
436             token = new Token( TokenTypes.DIV,
437                                getXPath(),
438                                this.currentPosition,
439                                this.currentPosition+3 );
440     
441             consume();
442             consume();
443             consume();
444         }
445     
446         return token;
447     }
448     
449     private Token and()
450     {
451         Token token = null;
452     
453         if ( ( LA(1) == 'a' )
454              &&
455              ( LA(2) == 'n' )
456              &&
457              ( LA(3) == 'd' )
458            )
459         {
460             token = new Token( TokenTypes.AND,
461                                getXPath(),
462                                this.currentPosition,
463                                this.currentPosition+3 );
464     
465             consume();
466             consume();
467             consume();
468         }
469     
470         return token;
471     }
472     
473     private Token or()
474     {
475         Token token = null;
476     
477         if ( ( LA(1) == 'o' )
478              &&
479              ( LA(2) == 'r' )
480            )
481         {
482             token = new Token( TokenTypes.OR,
483                                getXPath(),
484                                this.currentPosition,
485                                this.currentPosition+2 );
486     
487             consume();
488             consume();
489         }
490     
491         return token;
492     }
493     
494     private Token number()
495     {
496         int     start         = this.currentPosition;
497         boolean periodAllowed = true;
498     
499       loop:
500         while( true )
501         {
502             switch ( LA(1) )
503             {
504                 case '.':
505                     if ( periodAllowed )
506                     {
507                         periodAllowed = false;
508                         consume();
509                     }
510                     else
511                     {
512                         break loop;
513                     }
514                     break;
515                 case '0':
516                 case '1':
517                 case '2':
518                 case '3':
519                 case '4':
520                 case '5':
521                 case '6':
522                 case '7':
523                 case '8':
524                 case '9':
525                     consume();
526                     break;
527                 default:
528                     break loop;
529             }
530         }
531     
532         return new Token( TokenTypes.DOUBLE,
533                                getXPath(),
534                                start,
535                                this.currentPosition );
536     }
537     
538     private Token whitespace()
539     {
540         consume();
541             
542       loop:
543         while( hasMoreChars() )
544         {
545             switch ( LA(1) )
546             {
547                 case ' ':
548                 case '\t':
549                 case '\n':
550                 case '\r':
551                 {
552                     consume();
553                     break;
554                 }
555                     
556                 default:
557                 {
558                     break loop;
559                 }
560             }
561         }
562     
563         return new Token( TokenTypes.SKIP,
564                           getXPath(),
565                           0,
566                           0 );
567     }
568     
569     private Token comma()
570     {
571         Token token = new Token( TokenTypes.COMMA,
572                                  getXPath(),
573                                  this.currentPosition,
574                                  this.currentPosition+1 );
575     
576         consume();
577     
578         return token;
579     }
580     
581     private Token equals()
582     {
583         Token token = new Token( TokenTypes.EQUALS,
584                                  getXPath(),
585                                  this.currentPosition,
586                                  this.currentPosition+1 );
587     
588         consume();
589     
590         return token;
591     }
592     
593     private Token minus()
594     {
595         Token token = new Token( TokenTypes.MINUS,
596                                  getXPath(),
597                                  this.currentPosition,
598                                  this.currentPosition+1 );
599         consume();
600             
601         return token;
602     }
603     
604     private Token plus()
605     {
606         Token token = new Token( TokenTypes.PLUS,
607                                  getXPath(),
608                                  this.currentPosition,
609                                  this.currentPosition+1 );
610         consume();
611     
612         return token;
613     }
614     
615     private Token dollar()
616     {
617         Token token = new Token( TokenTypes.DOLLAR,
618                                  getXPath(),
619                                  this.currentPosition,
620                                  this.currentPosition+1 );
621         consume();
622     
623         return token;
624     }
625     
626     private Token pipe()
627     {
628         Token token = new Token( TokenTypes.PIPE,
629                                  getXPath(),
630                                  this.currentPosition,
631                                  this.currentPosition+1 );
632     
633         consume();
634     
635         return token;
636     }
637     
638     private Token at()
639     {
640         Token token = new Token( TokenTypes.AT,
641                                  getXPath(),
642                                  this.currentPosition,
643                                  this.currentPosition+1 );
644     
645         consume();
646     
647         return token;
648     }
649     
650     private Token colon()
651     {
652         Token token = new Token( TokenTypes.COLON,
653                                  getXPath(),
654                                  this.currentPosition,
655                                  this.currentPosition+1 );
656         consume();
657     
658         return token;
659     }
660     
661     private Token doubleColon()
662     {
663         Token token = new Token( TokenTypes.DOUBLE_COLON,
664                                  getXPath(),
665                                  this.currentPosition,
666                                  this.currentPosition+2 );
667     
668         consume();
669         consume();
670     
671         return token;
672     }
673     
674     private Token notEquals()
675     {
676         Token token = new Token( TokenTypes.NOT_EQUALS,
677                                  getXPath(),
678                                  this.currentPosition,
679                                  this.currentPosition + 2 );
680     
681         consume();
682         consume();
683     
684         return token;
685     }
686     
687     private Token relationalOperator()
688     {
689         Token token = null;
690     
691         switch ( LA(1) )
692         {
693             case '<':
694             {
695                 if ( LA(2) == '=' )
696                 {
697                     token = new Token( TokenTypes.LESS_THAN_OR_EQUALS_SIGN,
698                                        getXPath(),
699                                        this.currentPosition,
700                                        this.currentPosition + 2 );
701                     consume();
702                 }
703                 else
704                 {
705                     token = new Token( TokenTypes.LESS_THAN_SIGN,
706                                        getXPath(),
707                                        this.currentPosition,
708                                        this.currentPosition + 1);
709                 }
710     
711                 consume();
712                 break;
713             }
714             case '>':
715             {
716                 if ( LA(2) == '=' )
717                 {
718                     token = new Token( TokenTypes.GREATER_THAN_OR_EQUALS_SIGN,
719                                        getXPath(),
720                                        this.currentPosition,
721                                        this.currentPosition + 2 );
722                     consume();
723                 }
724                 else
725                 {
726                     token = new Token( TokenTypes.GREATER_THAN_SIGN,
727                                        getXPath(),
728                                        this.currentPosition,
729                                        this.currentPosition + 1 );
730                 }
731     
732                 consume();
733                 break;
734             }
735         }
736     
737         return token;
738                 
739     }
740     
741     // ????
742     private Token star()
743     {
744         int tokenType = expectOperator ? TokenTypes.STAR_OPERATOR : TokenTypes.STAR;
745          Token token = new Token( tokenType,
746                          getXPath(),
747                          this.currentPosition,
748                          this.currentPosition+1 );
749     
750         consume();
751             
752         return token;
753     }
754     
755     private Token literal()
756     {
757         Token token = null;
758     
759         char match  = LA(1);
760     
761         consume();
762     
763         int start = this.currentPosition;
764             
765         while ( ( token == null )
766                 &&
767                 hasMoreChars() )
768         {
769             if ( LA(1) == match )
770             {
771                 token = new Token( TokenTypes.LITERAL,
772                                    getXPath(),
773                                    start,
774                                    this.currentPosition );
775             }
776             consume();
777         }
778     
779         return token;
780     }
781     
782     private Token dots()
783     {
784         Token token = null;
785     
786         switch ( LA(2) )
787         {
788             case '.':
789             {
790                 token = new Token( TokenTypes.DOT_DOT,
791                                    getXPath(),
792                                    this.currentPosition,
793                                    this.currentPosition+2 ) ;
794                 consume();
795                 consume();
796                 break;
797             }
798             default:
799             {
800                 token = new Token( TokenTypes.DOT,
801                                    getXPath(),
802                                    this.currentPosition,
803                                    this.currentPosition+1 );
804                 consume();
805                 break;
806             }
807         }
808     
809         return token;
810     }
811     
812     private Token leftBracket()
813     {
814         Token token = new Token( TokenTypes.LEFT_BRACKET,
815                                  getXPath(),
816                                  this.currentPosition,
817                                  this.currentPosition+1 );
818     
819         consume();
820     
821         return token;
822     }
823     
824     private Token rightBracket()
825     {
826         Token token = new Token( TokenTypes.RIGHT_BRACKET,
827                                  getXPath(),
828                                  this.currentPosition,
829                                  this.currentPosition+1 );
830     
831         consume();
832     
833         return token;
834     }
835     
836     private Token leftParen()
837     {
838         Token token = new Token( TokenTypes.LEFT_PAREN,
839                                  getXPath(),
840                                  this.currentPosition,
841                                  this.currentPosition+1 );
842     
843         consume();
844     
845         return token;
846     }
847     
848     private Token rightParen()
849     {
850         Token token = new Token( TokenTypes.RIGHT_PAREN,
851                                  getXPath(),
852                                  this.currentPosition,
853                                  this.currentPosition+1 );
854     
855         consume();
856     
857         return token;
858     }
859     
860     private Token slashes()
861     {
862         Token token = null;
863     
864         switch ( LA(2) )
865         {
866             case '/':
867             {
868                 token = new Token( TokenTypes.DOUBLE_SLASH,
869                                    getXPath(),
870                                    this.currentPosition,
871                                    this.currentPosition+2 );
872                 consume();
873                 consume();
874                 break;
875             }
876             default:
877             {
878                 token = new Token( TokenTypes.SLASH,
879                                    getXPath(),
880                                    this.currentPosition,
881                                    this.currentPosition+1 );
882                 consume();
883             }
884         }
885     
886         return token;
887     }
888     
889     private char LA(int i) 
890     {
891         if ( currentPosition + ( i - 1 ) >= this.endPosition )
892         {
893             return (char) -1;
894         }
895     
896         return getXPath().charAt( this.currentPosition + (i - 1) );
897     }
898     
899     private void consume()
900     {
901         ++this.currentPosition;
902     }
903     
904     private boolean hasMoreChars()
905     {
906         return this.currentPosition < this.endPosition;
907     }
908 
909 }