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) Stdlib.Hashtbl.t

val reverse_keyword_table : (Reason_parser.token, string) Stdlib.Hashtbl.t

val string_buffer : Stdlib.Buffer.t

val raw_buffer : Stdlib.Buffer.t

val reset_string_buffer : unit -> unit

val store_string_char : char -> unit

val store_string : string -> unit

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

val get_stored_string : unit -> string * string option

val string_start_loc : Location.t Stdlib.ref

val comment_start_loc : Location.t list Stdlib.ref

val in_comment : unit -> bool

val is_in_string : bool Stdlib.ref

val in_string : unit -> bool

val print_warnings : bool Stdlib.ref

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

val lexeme_without_comment : Stdlib.Lexing.lexbuf -> string

val unescape_operator : string -> string

val lexeme_operator : Stdlib.Lexing.lexbuf -> string

val char_for_backslash : char -> char

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

val char_for_hexadecimal_code : Stdlib.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 : 
  Stdlib.Lexing.lexbuf ->
  string option ->
  int ->
  bool ->
  int ->
  unit

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

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

val __ocaml_lex_tables : Stdlib.Lexing.lex_tables

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

val enter_comment : Stdlib.Lexing.lexbuf -> Reason_parser.token

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

val comment : Stdlib.Lexing.lexbuf -> Location.t

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

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

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

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

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

val skip_sharp_bang : Stdlib.Lexing.lexbuf -> unit

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

val token_with_comments : Stdlib.Lexing.lexbuf -> Reason_parser.token

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

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

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

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

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

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

exception Lex_balanced_failed of (Reason_parser.token
                        * Stdlib.Lexing.position
                        * Stdlib.Lexing.position)
                         list
  * (exn * Stdlib.Lexing.position * Stdlib.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 ->
  Stdlib.Lexing.lexbuf ->
  (Reason_parser.token * Stdlib.Lexing.position * Stdlib.Lexing.position) list ->
  Reason_parser.token ->
  (Reason_parser.token * Stdlib.Lexing.position * Stdlib.Lexing.position) list

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

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

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

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

val completion_ident_offset : int Stdlib.ref

val completion_ident_pos : Stdlib.Lexing.position Stdlib.ref

val token : Stdlib.Lexing.lexbuf -> Reason_parser.token

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

val init : unit -> unit