Lexers.__ocaml_lex_parse_environment_path_aux

let rec ocamldep_output lexbuf =

  __ocaml_lex_ocamldep_output_rec lexbuf 0

and __ocaml_lex_ocamldep_output_rec lexbuf __ocaml_lex_state =

  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 42 "ocamlbuild/lexers.mll"

                            k

# 628 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos (lexbuf.Lexing.lex_curr_pos + -1) in

# 42 "ocamlbuild/lexers.mll"

                                   ( let x = (k, space_sep_strings_nl lexbuf) in x :: ocamldep_output lexbuf )

# 632 "ocamlbuild/lexers.ml"



  | 1 ->

# 43 "ocamlbuild/lexers.mll"

        ( [] )

# 637 "ocamlbuild/lexers.ml"



  | 2 ->

# 44 "ocamlbuild/lexers.mll"

      ( raise (Error "Expecting colon followed by space-separated module name list") )

# 642 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_ocamldep_output_rec lexbuf __ocaml_lex_state



and space_sep_strings_nl lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 2 (-1) ; (* L=1 [1] <- p ;  *)

  lexbuf.Lexing.lex_mem.(1) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_space_sep_strings_nl_rec lexbuf 6

and __ocaml_lex_space_sep_strings_nl_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 47 "ocamlbuild/lexers.mll"

                          word

# 656 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 47 "ocamlbuild/lexers.mll"

                                ( word :: space_sep_strings_nl lexbuf )

# 660 "ocamlbuild/lexers.ml"



  | 1 ->

# 48 "ocamlbuild/lexers.mll"

                   ( [] )

# 665 "ocamlbuild/lexers.ml"



  | 2 ->

# 49 "ocamlbuild/lexers.mll"

      ( raise (Error "Expecting space-separated strings terminated with newline") )

# 670 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_space_sep_strings_nl_rec lexbuf __ocaml_lex_state



and space_sep_strings lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 2 (-1) ; (* L=1 [1] <- p ;  *)

  lexbuf.Lexing.lex_mem.(1) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_space_sep_strings_rec lexbuf 12

and __ocaml_lex_space_sep_strings_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 52 "ocamlbuild/lexers.mll"

                          word

# 684 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 52 "ocamlbuild/lexers.mll"

                                ( word :: space_sep_strings lexbuf )

# 688 "ocamlbuild/lexers.ml"



  | 1 ->

# 53 "ocamlbuild/lexers.mll"

                        ( [] )

# 693 "ocamlbuild/lexers.ml"



  | 2 ->

# 54 "ocamlbuild/lexers.mll"

      ( raise (Error "Expecting space-separated strings") )

# 698 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_space_sep_strings_rec lexbuf __ocaml_lex_state



and blank_sep_strings lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 2 (-1) ; (* L=1 [1] <- p ;  *)

  lexbuf.Lexing.lex_mem.(1) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_blank_sep_strings_rec lexbuf 21

and __ocaml_lex_blank_sep_strings_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

# 57 "ocamlbuild/lexers.mll"

                                    ( blank_sep_strings lexbuf )

# 711 "ocamlbuild/lexers.ml"



  | 1 ->

# 58 "ocamlbuild/lexers.mll"

                                ( [] )

# 716 "ocamlbuild/lexers.ml"



  | 2 ->

let

# 59 "ocamlbuild/lexers.mll"

                          word

# 722 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 59 "ocamlbuild/lexers.mll"

                                ( word :: blank_sep_strings lexbuf )

# 726 "ocamlbuild/lexers.ml"



  | 3 ->

# 60 "ocamlbuild/lexers.mll"

               ( [] )

# 731 "ocamlbuild/lexers.ml"



  | 4 ->

# 61 "ocamlbuild/lexers.mll"

      ( raise (Error "Expecting blank-separated strings") )

# 736 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_blank_sep_strings_rec lexbuf __ocaml_lex_state



and comma_sep_strings lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 5 (-1) ; (* L=2 [3] <- p ; [2] <- p ;  *)

  lexbuf.Lexing.lex_mem.(3) <- lexbuf.Lexing.lex_curr_pos ;

  lexbuf.Lexing.lex_mem.(2) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_comma_sep_strings_rec lexbuf 33

and __ocaml_lex_comma_sep_strings_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 64 "ocamlbuild/lexers.mll"

                                    word

# 751 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_mem.(1) in

# 64 "ocamlbuild/lexers.mll"

                                                     ( [word] )

# 755 "ocamlbuild/lexers.ml"



  | 1 ->

let

# 65 "ocamlbuild/lexers.mll"

                                    word

# 761 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 65 "ocamlbuild/lexers.mll"

                                          ( word :: comma_sep_strings_aux lexbuf )

# 765 "ocamlbuild/lexers.ml"



  | 2 ->

# 66 "ocamlbuild/lexers.mll"

               ( [] )

# 770 "ocamlbuild/lexers.ml"



  | 3 ->

# 67 "ocamlbuild/lexers.mll"

      ( raise (Error "Expecting comma-separated strings (1)") )

# 775 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_comma_sep_strings_rec lexbuf __ocaml_lex_state



and comma_sep_strings_aux lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 2 (-1) ;   __ocaml_lex_comma_sep_strings_aux_rec lexbuf 41

and __ocaml_lex_comma_sep_strings_aux_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 69 "ocamlbuild/lexers.mll"

                                               word

# 787 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 69 "ocamlbuild/lexers.mll"

                                                     ( word :: comma_sep_strings_aux lexbuf )

# 791 "ocamlbuild/lexers.ml"



  | 1 ->

# 70 "ocamlbuild/lexers.mll"

               ( [] )

# 796 "ocamlbuild/lexers.ml"



  | 2 ->

# 71 "ocamlbuild/lexers.mll"

      ( raise (Error "Expecting comma-separated strings (2)") )

# 801 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_comma_sep_strings_aux_rec lexbuf __ocaml_lex_state



and comma_or_blank_sep_strings lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 5 (-1) ; (* L=2 [3] <- p ; [2] <- p ;  *)

  lexbuf.Lexing.lex_mem.(3) <- lexbuf.Lexing.lex_curr_pos ;

  lexbuf.Lexing.lex_mem.(2) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_comma_or_blank_sep_strings_rec lexbuf 49

and __ocaml_lex_comma_or_blank_sep_strings_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 74 "ocamlbuild/lexers.mll"

                                    word

# 816 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_mem.(1) in

# 74 "ocamlbuild/lexers.mll"

                                                     ( [word] )

# 820 "ocamlbuild/lexers.ml"



  | 1 ->

let

# 75 "ocamlbuild/lexers.mll"

                                    word

# 826 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 75 "ocamlbuild/lexers.mll"

                                          ( word :: comma_or_blank_sep_strings_aux lexbuf )

# 830 "ocamlbuild/lexers.ml"



  | 2 ->

# 76 "ocamlbuild/lexers.mll"

               ( [] )

# 835 "ocamlbuild/lexers.ml"



  | 3 ->

# 77 "ocamlbuild/lexers.mll"

      ( raise (Error "Expecting (comma|blank)-separated strings (1)") )

# 840 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_comma_or_blank_sep_strings_rec lexbuf __ocaml_lex_state



and comma_or_blank_sep_strings_aux lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 3 (-1) ; (* L=1 [1] <- p ;  *)

  lexbuf.Lexing.lex_mem.(1) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_comma_or_blank_sep_strings_aux_rec lexbuf 57

and __ocaml_lex_comma_or_blank_sep_strings_aux_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 79 "ocamlbuild/lexers.mll"

                                               word

# 854 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 79 "ocamlbuild/lexers.mll"

                                                     ( word :: comma_or_blank_sep_strings_aux lexbuf )

# 858 "ocamlbuild/lexers.ml"



  | 1 ->

let

# 80 "ocamlbuild/lexers.mll"

                                    word

# 864 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 80 "ocamlbuild/lexers.mll"

                                          ( word :: comma_or_blank_sep_strings_aux lexbuf )

# 868 "ocamlbuild/lexers.ml"



  | 2 ->

# 81 "ocamlbuild/lexers.mll"

               ( [] )

# 873 "ocamlbuild/lexers.ml"



  | 3 ->

# 82 "ocamlbuild/lexers.mll"

      ( raise (Error "Expecting (comma|blank)-separated strings (2)") )

# 878 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_comma_or_blank_sep_strings_aux_rec lexbuf __ocaml_lex_state



and parse_environment_path lexbuf =

  __ocaml_lex_parse_environment_path_rec lexbuf 65

and __ocaml_lex_parse_environment_path_rec lexbuf __ocaml_lex_state =

  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 85 "ocamlbuild/lexers.mll"

                 word

# 890 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in

# 85 "ocamlbuild/lexers.mll"

                       ( word :: parse_environment_path_aux lexbuf )

# 894 "ocamlbuild/lexers.ml"



  | 1 ->

let

# 86 "ocamlbuild/lexers.mll"

                     word

# 900 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) lexbuf.Lexing.lex_curr_pos in

# 86 "ocamlbuild/lexers.mll"

                           ( "" :: word :: parse_environment_path_aux lexbuf )

# 904 "ocamlbuild/lexers.ml"



  | 2 ->

# 87 "ocamlbuild/lexers.mll"

        ( [] )

# 909 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_parse_environment_path_rec lexbuf __ocaml_lex_state



and parse_environment_path_aux lexbuf =

  __ocaml_lex_parse_environment_path_aux_rec lexbuf 69

and __ocaml_lex_parse_environment_path_aux_rec lexbuf __ocaml_lex_state =

  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 89 "ocamlbuild/lexers.mll"

                     word

# 921 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) lexbuf.Lexing.lex_curr_pos in

# 89 "ocamlbuild/lexers.mll"

                           ( word :: parse_environment_path_aux lexbuf )

# 925 "ocamlbuild/lexers.ml"



  | 1 ->

# 90 "ocamlbuild/lexers.mll"

        ( [] )

# 930 "ocamlbuild/lexers.ml"



  | 2 ->

# 91 "ocamlbuild/lexers.mll"

      ( raise (Error "Impossible: expecting colon-separated strings") )

# 935 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_parse_environment_path_aux_rec lexbuf __ocaml_lex_state



and conf_lines dir pos err lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 5 (-1) ; (* L=1 [2] <- p ;  *)

  lexbuf.Lexing.lex_mem.(2) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_conf_lines_rec dir pos err lexbuf 73

and __ocaml_lex_conf_lines_rec dir pos err lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

# 94 "ocamlbuild/lexers.mll"

                                    ( conf_lines dir (pos + 1) err lexbuf )

# 948 "ocamlbuild/lexers.ml"



  | 1 ->

# 95 "ocamlbuild/lexers.mll"

                                ( [] )

# 953 "ocamlbuild/lexers.ml"



  | 2 ->

# 96 "ocamlbuild/lexers.mll"

                   ( conf_lines dir (pos + 1) err lexbuf )

# 958 "ocamlbuild/lexers.ml"



  | 3 ->

# 97 "ocamlbuild/lexers.mll"

               ( [] )

# 963 "ocamlbuild/lexers.ml"



  | 4 ->

let

# 98 "ocamlbuild/lexers.mll"

                                      k

# 969 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_mem.(1) in

# 99 "ocamlbuild/lexers.mll"

      (

        let bexpr = Glob.parse ?dir k in

        let v1 = conf_value pos err empty lexbuf in

        let v2 = conf_values pos err v1 lexbuf in

        let rest = conf_lines dir (pos + 1) err lexbuf in (bexpr, v2) :: rest

      )

# 978 "ocamlbuild/lexers.ml"



  | 5 ->

# 105 "ocamlbuild/lexers.mll"

      ( raise (Error(Printf.sprintf "Bad key in configuration line at line %d (from %s)" pos err)) )

# 983 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_conf_lines_rec dir pos err lexbuf __ocaml_lex_state



and conf_value pos err x lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 3 (-1) ; (* L=1 [1] <- p ;  *)

  lexbuf.Lexing.lex_mem.(1) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_conf_value_rec pos err x lexbuf 90

and __ocaml_lex_conf_value_rec pos err x lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 108 "ocamlbuild/lexers.mll"

                 tag

# 997 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 1) lexbuf.Lexing.lex_curr_pos in

# 108 "ocamlbuild/lexers.mll"

                      ( { (x) with minus_tags = tag :: x.minus_tags } )

# 1001 "ocamlbuild/lexers.ml"



  | 1 ->

let

# 109 "ocamlbuild/lexers.mll"

                 tag

# 1007 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_curr_pos in

# 109 "ocamlbuild/lexers.mll"

                      ( { (x) with plus_tags = tag :: x.plus_tags } )

# 1011 "ocamlbuild/lexers.ml"



  | 2 ->

# 110 "ocamlbuild/lexers.mll"

              ( raise (Error(Printf.sprintf "Bad value in configuration line at line %d (from %s)" pos err)) )

# 1016 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_conf_value_rec pos err x lexbuf __ocaml_lex_state



and conf_values pos err x lexbuf =

  __ocaml_lex_conf_values_rec pos err x lexbuf 104

and __ocaml_lex_conf_values_rec pos err x lexbuf __ocaml_lex_state =

  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

# 113 "ocamlbuild/lexers.mll"

                                          ( conf_values pos err (conf_value pos err x lexbuf) lexbuf )

# 1027 "ocamlbuild/lexers.ml"



  | 1 ->

# 114 "ocamlbuild/lexers.mll"

                    ( x )

# 1032 "ocamlbuild/lexers.ml"



  | 2 ->

# 115 "ocamlbuild/lexers.mll"

              ( raise (Error(Printf.sprintf "Bad values in configuration line at line %d (from %s)" pos err)) )

# 1037 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_conf_values_rec pos err x lexbuf __ocaml_lex_state



and path_scheme patt_allowed lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 2 (-1) ;   __ocaml_lex_path_scheme_rec patt_allowed lexbuf 116

and __ocaml_lex_path_scheme_rec patt_allowed lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 118 "ocamlbuild/lexers.mll"

                  prefix

# 1049 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_curr_pos in

# 119 "ocamlbuild/lexers.mll"

      ( `Word prefix :: path_scheme patt_allowed lexbuf )

# 1053 "ocamlbuild/lexers.ml"



  | 1 ->

let

# 120 "ocamlbuild/lexers.mll"

                      var

# 1059 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) (lexbuf.Lexing.lex_curr_pos + -1) in

# 121 "ocamlbuild/lexers.mll"

      ( `Var (var, Bool.True) :: path_scheme patt_allowed lexbuf )

# 1063 "ocamlbuild/lexers.ml"



  | 2 ->

let

# 122 "ocamlbuild/lexers.mll"

                      var

# 1069 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_start_pos + 2) lexbuf.Lexing.lex_mem.(0)

and

# 122 "ocamlbuild/lexers.mll"

                                           patt

# 1074 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf (lexbuf.Lexing.lex_mem.(0) + 1) (lexbuf.Lexing.lex_curr_pos + -1) in

# 123 "ocamlbuild/lexers.mll"

      ( if patt_allowed then

          let patt = My_std.String.implode (unescape (Lexing.from_string patt)) in

          `Var (var, Glob.parse patt) :: path_scheme patt_allowed lexbuf

        else raise (Error(

          Printf.sprintf "Patterns are not allowed in this pathname (%%(%s:%s) only in ~prod)"

            var patt)) )

# 1083 "ocamlbuild/lexers.ml"



  | 3 ->

# 130 "ocamlbuild/lexers.mll"

      ( `Var ("", Bool.True) :: path_scheme patt_allowed lexbuf )

# 1088 "ocamlbuild/lexers.ml"



  | 4 ->

# 132 "ocamlbuild/lexers.mll"

      ( [] )

# 1093 "ocamlbuild/lexers.ml"



  | 5 ->

# 133 "ocamlbuild/lexers.mll"

      ( raise (Error("Bad pathanme scheme")) )

# 1098 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_path_scheme_rec patt_allowed lexbuf __ocaml_lex_state



and unescape lexbuf =

  __ocaml_lex_unescape_rec lexbuf 125

and __ocaml_lex_unescape_rec lexbuf __ocaml_lex_state =

  match Lexing.engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 136 "ocamlbuild/lexers.mll"

                       c

# 1110 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme_char lexbuf (lexbuf.Lexing.lex_start_pos + 1) in

# 136 "ocamlbuild/lexers.mll"

                                 ( c :: unescape lexbuf )

# 1114 "ocamlbuild/lexers.ml"



  | 1 ->

let

# 137 "ocamlbuild/lexers.mll"

         c

# 1120 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme_char lexbuf lexbuf.Lexing.lex_start_pos in

# 137 "ocamlbuild/lexers.mll"

                                 ( c :: unescape lexbuf )

# 1124 "ocamlbuild/lexers.ml"



  | 2 ->

# 138 "ocamlbuild/lexers.mll"

                                 ( [] )

# 1129 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_unescape_rec lexbuf __ocaml_lex_state



and ocamlfind_query lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 24 (-1) ;   __ocaml_lex_ocamlfind_query_rec lexbuf 130

and __ocaml_lex_ocamlfind_query_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 142 "ocamlbuild/lexers.mll"

                                       n

# 1141 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_mem.(1)

and

# 143 "ocamlbuild/lexers.mll"

                                           d

# 1146 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(2) lexbuf.Lexing.lex_mem.(3)

and

# 144 "ocamlbuild/lexers.mll"

                                       v

# 1151 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(4) lexbuf.Lexing.lex_mem.(5)

and

# 145 "ocamlbuild/lexers.mll"

                                          a

# 1156 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(6) lexbuf.Lexing.lex_mem.(7)

and

# 146 "ocamlbuild/lexers.mll"

                                        lo

# 1161 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(8) lexbuf.Lexing.lex_mem.(9)

and

# 147 "ocamlbuild/lexers.mll"

                                        l

# 1166 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(10) lexbuf.Lexing.lex_mem.(11) in

# 148 "ocamlbuild/lexers.mll"

    ( n, d, v, a, lo, l )

# 1170 "ocamlbuild/lexers.ml"



  | 1 ->

# 149 "ocamlbuild/lexers.mll"

      ( raise (Error "Bad ocamlfind query") )

# 1175 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_ocamlfind_query_rec lexbuf __ocaml_lex_state



and trim_blanks lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 6 (-1) ; (* L=2 [3] <- p ; [2] <- p ;  *)

  lexbuf.Lexing.lex_mem.(3) <- lexbuf.Lexing.lex_curr_pos ;

  lexbuf.Lexing.lex_mem.(2) <- lexbuf.Lexing.lex_curr_pos ;

  __ocaml_lex_trim_blanks_rec lexbuf 212

and __ocaml_lex_trim_blanks_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 152 "ocamlbuild/lexers.mll"

                          word

# 1190 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_mem.(0) lexbuf.Lexing.lex_mem.(1) in

# 152 "ocamlbuild/lexers.mll"

                                       ( word )

# 1194 "ocamlbuild/lexers.ml"



  | 1 ->

# 153 "ocamlbuild/lexers.mll"

      ( raise (Error "Bad input for trim_blanks") )

# 1199 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_trim_blanks_rec lexbuf __ocaml_lex_state



and tag_gen lexbuf =

lexbuf.Lexing.lex_mem <- Array.create 6 (-1) ;   __ocaml_lex_tag_gen_rec lexbuf 218

and __ocaml_lex_tag_gen_rec lexbuf __ocaml_lex_state =

  match Lexing.new_engine __ocaml_lex_tables __ocaml_lex_state lexbuf with

      | 0 ->

let

# 156 "ocamlbuild/lexers.mll"

                name

# 1211 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme lexbuf lexbuf.Lexing.lex_start_pos lexbuf.Lexing.lex_mem.(0)

and

# 156 "ocamlbuild/lexers.mll"

                                       param

# 1216 "ocamlbuild/lexers.ml"

= Lexing.sub_lexeme_opt lexbuf lexbuf.Lexing.lex_mem.(2) lexbuf.Lexing.lex_mem.(1) in

# 156 "ocamlbuild/lexers.mll"

                                                    ( name, param )

# 1220 "ocamlbuild/lexers.ml"



  | __ocaml_lex_state -> lexbuf.Lexing.refill_buff lexbuf; __ocaml_lex_tag_gen_rec lexbuf __ocaml_lex_state