(** Lexing buffer. *)

type t
(** The state of the buffer *)

val from_lexbuf : ?reset_line:bool -> Sedlexing.lexbuf -> t
(** Create a new buffer *)

val start : t -> unit
(** Intialize a new run *)

val buffer : t -> Sedlexing.lexbuf
(** Extract the sedlex buffer. Required in each rule. *)

val positions : t -> Lexing.position * Lexing.position
(** Extract the starting and ending position for the matched token. 

    This function is used outside of the parser, in order to get the position
    of the latest token in the case of an error.
 *)

val content : t -> string
(** Extract the token matched by the rule *)

val set_start_position : t -> Lexing.position -> unit
(** Reset the starting position. Used while parsing the string to keep the
    begining of the whole string. *)

val tokenize : (t -> 'a) -> t -> unit -> 'a * Lexing.position * Lexing.position
(** Function to use in the parser in order to extract the token match, and the
    starting and ending position. *)

val rollback : t -> unit
(** Rollback the latest token matched *)

(** {1 State in expressions} 

 The comment system is terrible. The same symbol can be used for :
     - starting a comment
     - inequality operation

   In order to manage this, I try to identify the context in a very basic way,
   using a stack for determining the token to send.
*)

type state =
  | Token  (** Default state, parsing the tokens *)
  | String  (** String enclosed by [''] *)
  | DString  (** String enclosed by [""] *)
  | MString of int  (** String enclosed by [{}]*)
  | EndString  (** State raised just before closing the string *)
  | Expression  (** Expression where [!] is an operator *)

val state : t -> state option
(** Get the current state for the lexer. 

    @return [None] when in the default state *)

val enter_state : t -> state -> unit
(** Enter into a new state *)

val leave_state : t -> unit
(** Leave the current state *)