src/xpath/xpath_internal_parser.mly

   1 %{
   2 (***********************************************************************)
   3 (*                                                                     *)
   4 (*                               TAToo                                 *)
   5 (*                                                                     *)
   6 (*                     Kim Nguyen, LRI UMR8623                         *)
   7 (*                   Université Paris-Sud & CNRS                       *)
   8 (*                                                                     *)
   9 (*  Copyright 2010-2012 Université Paris-Sud and Centre National de la *)
  10 (*  Recherche Scientifique. All rights reserved.  This file is         *)
  11 (*  distributed under the terms of the GNU Lesser General Public       *)
  12 (*  License, with the special exception on linking described in file   *)
  13 (*  ../LICENSE.                                                        *)
  14 (*                                                                     *)
  15 (***********************************************************************)
  16
  17 (*
  18   Time-stamp: <Last modified on 2013-03-13 09:56:09 CET by Kim Nguyen>
  19 *)
  20
  21   open Ast
  22   open Tree.Common
  23 %}
  24
  25 %token <string> TAG
  26 %token <string> PI
  27 %token <string> ATTNAME
  28 %token <string> STRING
  29 %token <int>  INT
  30 %token <float> FLOAT
  31 %token <Ast.axis> AXIS
  32 %token RB LB LP RP
  33 %token SLASH SLASHSLASH COLONCOLON STAR PIPE
  34 %token EQ NEQ LT GT LTE GTE OR AND ADD SUB DIV MOD
  35 %token NODE TEXT COMMENT
  36 %token COMMA
  37 %token EOF
  38
  39 %left OR
  40 %left AND
  41 %left EQ NEQ
  42 %left LT GT LTE GTE
  43 %left ADD SUB
  44 %left MOD DIV STAR
  45 %nonassoc uminus
  46
  47 %start xpath_query
  48 %type <Ast.path> xpath_query
  49
  50
  51 %%
  52 xpath_query:
  53 path EOF          { $1 }
  54 ;
  55
  56 path:
  57   path_rev { List.rev $1 }
  58 ;
  59
  60 path_rev:
  61   simple_path     { [ $1 ] }
  62 | path_rev PIPE simple_path { $3 :: $1 }
  63 ;
  64
  65
  66 simple_path:
  67    absolute_path  { Absolute  (List.rev $1) }
  68 |  relative_path  { Relative  (List.rev $1) }
  69 ;
  70
  71 absolute_path:
  72   SLASH relative_path { $2 }
  73 | SLASHSLASH relative_path { $2 @
  74                                [(Descendant true,
  75                                  (node, NodeKind.Node),
  76                                  [])] }
  77 ;
  78
  79 relative_path:
  80   step { [ $1 ] }
  81 | relative_path SLASH step { $3 :: $1 }
  82 | relative_path SLASHSLASH step { $3
  83                                   :: (Descendant true,
  84                                       (node, NodeKind.Node),
  85                                       [])
  86                                   :: $1 }
  87 ;
  88
  89 step:
  90   axis_test pred_list    { let a, b = $1 in a, b, $2 }
  91 ;
  92
  93 axis_test:
  94   AXIS COLONCOLON test  { let a, (t,k) = $1, $3 in
  95                           let new_t =
  96                             if a == Attribute && Utils.QNameSet.is_finite t then
  97                               Utils.QNameSet.fold
  98                                 (fun t a ->
  99                                   Utils.QNameSet.add
 100                                     (Utils.QName.attribute t) a)
 101                                 t Utils.QNameSet.empty
 102                             else t
 103                           in
 104                           (a, (new_t,k))
 105                         }
 106 | test                  { Child, $1 }
 107 | AXIS            {
 108   let _ = Format.flush_str_formatter () in
 109   let () = Format.fprintf Format.str_formatter "%a" Ast.print_axis $1 in
 110   let a = Format.flush_str_formatter () in
 111   Child, (Utils.QNameSet.singleton (Utils.QName.of_string a),NodeKind.Element)
 112 }
 113 | ATTNAME             {  (Attribute,
 114                           (Utils.QNameSet.singleton (Utils.QName.of_string $1),
 115                           NodeKind.Attribute)) }
 116 ;
 117
 118 test:
 119   NODE                { node, NodeKind.Node }
 120 | TEXT                { text, NodeKind.Text }
 121 | STAR                { star, NodeKind.Element }
 122 | COMMENT             { Utils.QNameSet.singleton(Utils.QName.comment),
 123                         NodeKind.Comment
 124                       }
 125 | PI                  { Utils.QNameSet.singleton(
 126                               Utils.QName.processing_instruction (
 127                                 Utils.QName.of_string $1)
 128                          ), NodeKind.ProcessingInstruction
 129                       }
 130 | TAG                 { Utils.QNameSet.singleton(Utils.QName.of_string $1),
 131                         NodeKind.Element
 132                       }
 133 ;
 134
 135 pred_list:
 136   pred_list_rev             { List.rev $1 }
 137 ;
 138
 139 pred_list_rev:
 140              { [] }
 141 | pred_list LB expr RB   { $3 :: $1 }
 142 ;
 143
 144 expr:
 145   INT                       { Number(`Int($1)) }
 146 | FLOAT                     { Number(`Float($1)) }
 147 | STRING                    { String $1 }
 148 | SUB expr     %prec uminus { Unop(Neg, $2) }
 149 | expr AND expr             { Binop($1, And, $3) }
 150 | expr OR expr              { Binop($1, Or, $3) }
 151 | expr ADD expr             { Binop($1, Add, $3) }
 152 | expr SUB expr             { Binop($1, Sub, $3) }
 153 | expr STAR expr            { Binop($1, Mult, $3) }
 154 | expr DIV expr             { Binop($1, Div, $3) }
 155 | expr MOD expr             { Binop($1, Mod, $3) }
 156 | expr EQ expr              { Binop($1, Eq, $3) }
 157 | expr NEQ expr             { Binop($1, Neq, $3) }
 158 | expr LT expr              { Binop($1, Lt, $3) }
 159 | expr LTE expr             { Binop($1, Lte, $3) }
 160 | expr GT expr              { Binop($1, Gt, $3) }
 161 | expr GTE expr             { Binop($1, Gte, $3) }
 162 | TAG LP arg_list RP        { Fun_call(Utils.QName.of_string $1, $3) }
 163 | LP expr RP                { $2 }
 164 | path                      { Path $1 }
 165 ;
 166
 167 arg_list:
 168                             { [] }
 169 | arg_list1                 { List.rev $1 }
 170 ;
 171
 172 arg_list1:
 173   expr                     { [ $1 ] }
 174 | arg_list1 COMMA expr     { $3 :: $1 }
 175 ;