package reason

You can search for identifiers within the package.

in-package search v0.2.0

package reason

reason
reason.easy_format
- Vendored_easy_format
  - Compact
  - Pretty

Legend:
Library
Module
Module type
Parameter
Class
Class type

include module type of struct include Reason_lexer end

type error = Reason_lexer.error =

| Illegal_character of char
| Illegal_escape of string
| Unterminated_comment of Location.t
| Unterminated_string
| Unterminated_string_in_comment of Location.t * Location.t
| Keyword_as_label of string
| Literal_overflow of string
| Invalid_literal of string

exception Error of error * Location.t

val keyword_table : (string, Reason_parser.token) Hashtbl.t

val string_buffer : Buffer.t

val raw_buffer : Buffer.t

val reset_string_buffer : unit -> unit

val store_string_char : char -> unit

val store_string : string -> unit

val store_lexeme : Buffer.t -> Lexing.lexbuf -> unit

val get_stored_string : unit -> string * string option

val string_start_loc : Location.t Pervasives.ref

val comment_start_loc : Location.t list Pervasives.ref

val in_comment : unit -> bool

val is_in_string : bool Pervasives.ref

val in_string : unit -> bool

val print_warnings : bool Pervasives.ref

val lexeme_without_comment : Lexing.lexbuf -> string

val unescape_operator : string -> string

val lexeme_operator : Lexing.lexbuf -> string

val char_for_backslash : char -> char

val char_for_decimal_code : Lexing.lexbuf -> int -> char

val char_for_hexadecimal_code : Lexing.lexbuf -> int -> char

val cvt_int_literal : string -> int

val cvt_int32_literal : string -> int32

val cvt_int64_literal : string -> int64

val cvt_nativeint_literal : string -> nativeint

val remove_underscores : string -> string

val update_loc : Lexing.lexbuf -> string option -> int -> bool -> int -> unit

val preprocessor : 
  ((unit ->
   unit)
   * ((Lexing.lexbuf -> Reason_parser.token) ->
   Lexing.lexbuf ->
   Reason_parser.token))
    option
    Pervasives.ref

val report_error : Format.formatter -> error -> unit

val set_lexeme_length : Lexing.lexbuf -> int -> unit

val __ocaml_lex_tables : Lexing.lex_tables

val __ocaml_lex_token_rec : Lexing.lexbuf -> int -> Reason_parser.token

val enter_comment : Lexing.lexbuf -> Reason_parser.token

val __ocaml_lex_enter_comment_rec : Lexing.lexbuf -> int -> Reason_parser.token

val comment : Lexing.lexbuf -> Location.t

val __ocaml_lex_comment_rec : Lexing.lexbuf -> int -> Location.t

val string : Buffer.t -> Lexing.lexbuf -> unit

val __ocaml_lex_string_rec : Buffer.t -> Lexing.lexbuf -> int -> unit

val quoted_string : string -> Lexing.lexbuf -> unit

val __ocaml_lex_quoted_string_rec : string -> Lexing.lexbuf -> int -> unit

val skip_sharp_bang : Lexing.lexbuf -> unit

val __ocaml_lex_skip_sharp_bang_rec : Lexing.lexbuf -> int -> unit

val token_with_comments : Lexing.lexbuf -> Reason_parser.token

val last_comments : (string * Location.t) list Pervasives.ref

val add_invalid_docstring : string -> Location.t -> unit

val comments : unit -> (string * Location.t) list

val save_triple : Lexing.lexbuf -> 'a -> 'a * Lexing.position * Lexing.position

val load_triple : 
  Lexing.lexbuf ->
  ('a * Lexing.position * Lexing.position) ->
  'a

val fake_triple : 'a -> ('b * 'c * 'd) -> 'a * 'c * 'c

exception Lex_balanced_failed of (Reason_parser.token * Lexing.position * Lexing.position)
                         list
  * (exn * Lexing.position * Lexing.position) option

val closing_of : Reason_parser.token -> Reason_parser.token

val inject_es6_fun : 
  (Reason_parser.token * 'a * 'a) list ->
  (Reason_parser.token * 'a * 'a) list

val is_triggering_token : Reason_parser.token -> bool

val lex_balanced_step : 
  Reason_parser.token ->
  Lexing.lexbuf ->
  (Reason_parser.token * Lexing.position * Lexing.position) list ->
  Reason_parser.token ->
  (Reason_parser.token * Lexing.position * Lexing.position) list

val lex_balanced : 
  Reason_parser.token ->
  Lexing.lexbuf ->
  (Reason_parser.token * Lexing.position * Lexing.position) list ->
  (Reason_parser.token * Lexing.position * Lexing.position) list

val queued_tokens : 
  (Reason_parser.token * Lexing.position * Lexing.position) list Pervasives.ref

val queued_exn : 
  (exn * Lexing.position * Lexing.position) option Pervasives.ref

val lookahead_esfun : 
  Lexing.lexbuf ->
  (Reason_parser.token * Lexing.position * Lexing.position) ->
  Reason_parser.token

val completion_ident_offset : int Pervasives.ref

val completion_ident_pos : Lexing.position Pervasives.ref

val token : Lexing.lexbuf -> Reason_parser.token

val set_preprocessor : 
  (unit -> unit) ->
  ((Lexing.lexbuf -> Reason_parser.token) ->
    Lexing.lexbuf ->
    Reason_parser.token) ->
  unit

val init : unit -> unit