Simplify the automaton encoding a bit (remove redundant predicates in formulae).

[tatoo.git] / src / xpath / xpath_internal_parser.mly

diff --git a/src/xpath/xpath_internal_parser.mly b/src/xpath/xpath_internal_parser.mly
index f0207ea..6395b6e 100644 (file)
--- a/src/xpath/xpath_internal_parser.mly
+++ b/src/xpath/xpath_internal_parser.mly
@@ -50,9 +50,15 @@ path EOF          { $1 }
 ;
 
 path:
 ;
 
 path:

-  separated_nonempty_list(PIPE, simple_path)  { $1 }
+  path_rev { List.rev $1 }

 ;
 
 ;
 

+path_rev:
+  simple_path     { [ $1 ] }
+| path_rev PIPE simple_path { $3 :: $1 }
+;
+
+

 simple_path:
    absolute_path  { Absolute  (List.rev $1) }
 |  relative_path  { Relative  (List.rev $1) }
 simple_path:
    absolute_path  { Absolute  (List.rev $1) }
 |  relative_path  { Relative  (List.rev $1) }


@@ -70,7 +76,6 @@ absolute_path:
   step is always a small list, of size 1-3 so @ is
   cheap
 */
   step is always a small list, of size 1-3 so @ is
   cheap
 */

-

 relative_path:
   step { $1 }
 | relative_path SLASH step { $3 @ $1 }
 relative_path:
   step { $1 }
 | relative_path SLASH step { $3 @ $1 }


@@ -94,12 +99,7 @@ step:
 axis_test:
   AXIS COLONCOLON test  { let a, (t,k) = $1, $3 in
                           match a with
 axis_test:
   AXIS COLONCOLON test  { let a, (t,k) = $1, $3 in
                           match a with

-                            Attribute when QNameSet.is_finite t ->
-                              [ a, ((QNameSet.fold
-                                       (fun t a ->
-                                         QNameSet.add
-                                           (QName.attribute t) a)
-                                       t QNameSet.empty), k) ]
+                          | Attribute -> [ a, (t, NodeKind.Attribute) ]

                           | Preceding|Following ->
                               [ (Descendant true, (t,k));
                                 if a == Preceding then
                           | Preceding|Following ->
                               [ (Descendant true, (t,k));
                                 if a == Preceding then


@@ -131,8 +131,7 @@ test:
                       }
 | PI                  { (if $1 = "" then star
                          else QNameSet.singleton(
                       }
 | PI                  { (if $1 = "" then star
                          else QNameSet.singleton(

-                           QName.processing_instruction (
-                             QName.of_string $1)
+                             QName.of_string $1

                          )), NodeKind.ProcessingInstruction
                       }
 | TAG                 { QNameSet.singleton(QName.of_string $1),
                          )), NodeKind.ProcessingInstruction
                       }
 | TAG                 { QNameSet.singleton(QName.of_string $1),


@@ -154,27 +153,24 @@ expr:
 | FLOAT                     { Number(`Float($1)) }
 | STRING                    { String $1 }
 | SUB expr     %prec uminus { Unop(Neg, $2) }
 | FLOAT                     { Number(`Float($1)) }
 | STRING                    { String $1 }
 | SUB expr     %prec uminus { Unop(Neg, $2) }

-| e1 = expr; op = binop; e2 = expr             { Binop(e1, op, e2) }
+| expr AND expr             { Binop($1, And, $3) }
+| expr OR expr              { Binop($1, Or, $3) }
+| expr ADD expr             { Binop($1, Add, $3) }
+| expr SUB expr             { Binop($1, Sub, $3) }
+| expr STAR expr            { Binop($1, Mult, $3) }
+| expr DIV expr             { Binop($1, Div, $3) }
+| expr MOD expr             { Binop($1, Mod, $3) }
+| expr EQ expr              { Binop($1, Eq, $3) }
+| expr NEQ expr             { Binop($1, Neq, $3) }
+| expr LT expr              { Binop($1, Lt, $3) }
+| expr LTE expr             { Binop($1, Lte, $3) }
+| expr GT expr              { Binop($1, Gt, $3) }
+| expr GTE expr             { Binop($1, Gte, $3) }

 | TAG LP arg_list RP        { Fun_call(QName.of_string $1, $3) }
 | LP expr RP                { $2 }
 | path                      { Path $1 }
 ;
 
 | TAG LP arg_list RP        { Fun_call(QName.of_string $1, $3) }
 | LP expr RP                { $2 }
 | path                      { Path $1 }
 ;
 

-%inline binop:
-|  AND              { And }
-|  OR               { Or }
-|  ADD              { Add }
-|  SUB              { Sub }
-|  STAR             { Mult }
-|  DIV              { Div }
-|  MOD              { Mod }
-|  EQ               { Eq }
-|  NEQ              { Neq }
-|  LT               { Lt }
-|  LTE              { Lte }
-|  GT               { Gt }
-|  GTE              { Gte }
-;

 arg_list:
                             { [] }
 | arg_list1                 { List.rev $1 }
 arg_list:
                             { [] }
 | arg_list1                 { List.rev $1 }