diff --git a/src/passes/1-parser/cameligo.ml b/src/passes/1-parser/cameligo.ml
index 3ae2063c1..79093af97 100644
--- a/src/passes/1-parser/cameligo.ml
+++ b/src/passes/1-parser/cameligo.ml
@@ -8,15 +8,14 @@ module SSet     = Set.Make (String)
 
 (* Mock IOs TODO: Fill them with CLI options *)
 
-type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
 module SubIO =
   struct
     type options = <
       libs    : string list;
       verbose : SSet.t;
       offsets : bool;
-      lang    : language;
+      block   : EvalOpt.block_comment option;
+      line    : EvalOpt.line_comment option;
       ext     : string;   (* ".mligo" *)
       mode    : [`Byte | `Point];
       cmd     : EvalOpt.command;
@@ -24,22 +23,25 @@ module SubIO =
     >
 
     let options : options =
-      object
-        method libs    = []
-        method verbose = SSet.empty
-        method offsets = true
-        method lang    = `CameLIGO
-        method ext     = ".mligo"
-        method mode    = `Point
-        method cmd     = EvalOpt.Quiet
-        method mono    = false
-      end
+      let block = EvalOpt.mk_block ~opening:"(*" ~closing:"*)"
+      in object
+           method libs    = []
+           method verbose = SSet.empty
+           method offsets = true
+           method block   = Some block
+           method line    = Some "//"
+           method ext     = ".mligo"
+           method mode    = `Point
+           method cmd     = EvalOpt.Quiet
+           method mono    = false
+         end
 
     let make =
       EvalOpt.make ~libs:options#libs
                    ~verbose:options#verbose
                    ~offsets:options#offsets
-                   ~lang:options#lang
+                   ?block:options#block
+                   ?line:options#line
                    ~ext:options#ext
                    ~mode:options#mode
                    ~cmd:options#cmd
diff --git a/src/passes/1-parser/cameligo/LexToken.mli b/src/passes/1-parser/cameligo/LexToken.mli
index 26cd6416a..4af326823 100644
--- a/src/passes/1-parser/cameligo/LexToken.mli
+++ b/src/passes/1-parser/cameligo/LexToken.mli
@@ -156,11 +156,22 @@ val eof       : Region.t -> token
 
 (* Predicates *)
 
-val is_string : token -> bool
-val is_bytes  : token -> bool
-val is_int    : token -> bool
-val is_ident  : token -> bool
-val is_kwd    : token -> bool
-val is_constr : token -> bool
-val is_sym    : token -> bool
 val is_eof    : token -> bool
+
+(* Style *)
+
+type error
+
+val error_to_string : error -> string
+
+exception Error of error Region.reg
+
+val format_error :
+  ?offsets:bool -> [`Byte | `Point] ->
+  error Region.reg -> file:bool -> string Region.reg
+
+val check_right_context :
+  token ->
+  (Lexing.lexbuf -> (Markup.t list * token) option) ->
+  Lexing.lexbuf ->
+  unit
diff --git a/src/passes/1-parser/cameligo/LexToken.mll b/src/passes/1-parser/cameligo/LexToken.mll
index a9dc9cfe1..bb44c4e78 100644
--- a/src/passes/1-parser/cameligo/LexToken.mll
+++ b/src/passes/1-parser/cameligo/LexToken.mll
@@ -480,81 +480,60 @@ let mk_attr header lexeme region =
 
 (* Predicates *)
 
-let is_string = function
-  String _ -> true
-|        _ -> false
+let is_string = function String _ -> true | _ -> false
+let is_bytes  = function Bytes _ -> true | _ -> false
+let is_int    = function Int _ -> true | _ -> false
+let is_ident  = function Ident _ -> true | _ -> false
+let is_eof    = function EOF _ -> true | _ -> false
 
-let is_bytes = function
-  Bytes _ -> true
-|       _ -> false
+(* Errors *)
 
-let is_int = function
-  Int _ -> true
-|     _ -> false
+type error =
+  Odd_lengthed_bytes
+| Missing_break
 
-let is_ident = function
-  Ident _ -> true
-|       _ -> false
+let error_to_string = function
+  Odd_lengthed_bytes ->
+    "The length of the byte sequence is an odd number.\n\
+     Hint: Add or remove a digit."
+| Missing_break ->
+    "Missing break.\n\
+     Hint: Insert some space."
 
-let is_kwd = function
-  | Begin _
-  | Else _
-  | End _
-  | False _
-  | Fun _
-  | Rec _
-  | If _
-  | In _
-  | Let _
-  | Match _
-  | Mod _
-  | Not _
-  | Of _
-  | Or _
-  | Then _
-  | True _
-  | Type _
-  | With _ -> true
-  | _ -> false
+exception Error of error Region.reg
 
-let is_constr = function
-| Constr  _
-| Ident _
-| False _
-| True _    -> true
-| _         -> false
+let format_error ?(offsets=true) mode Region.{region; value} ~file =
+  let msg = error_to_string value
+  and reg = region#to_string ~file ~offsets mode in
+  let value = sprintf "Lexical error %s:\n%s\n" reg msg
+  in Region.{value; region}
 
-let is_sym = function
-| ARROW _
-| CONS _
-| CAT _
-| MINUS _
-| PLUS _
-| SLASH _
-| TIMES _
-| LPAR _
-| RPAR _
-| LBRACKET _
-| RBRACKET _
-| LBRACE _
-| RBRACE _
-| COMMA _
-| SEMI  _
-| VBAR _
-| COLON _
-| DOT _
-| WILD _
-| EQ _
-| NE _
-| LT _
-| GT _
-| LE _
-| GE _
-| BOOL_OR _
-| BOOL_AND _ -> true
-|          _ -> false
+let fail region value = raise (Error Region.{region; value})
 
-let is_eof = function EOF _ -> true | _ -> false
+let check_right_context token next_token buffer : unit =
+  if not (is_eof token) then
+    if is_int token || is_bytes token then
+      match next_token buffer with
+        Some ([], next) ->
+          let pos    = (to_region token)#stop in
+          let region = Region.make ~start:pos ~stop:pos in
+          if is_int next then
+            fail region Odd_lengthed_bytes
+          else
+            if is_ident next || is_string next || is_bytes next then
+              fail region Missing_break
+      | Some (_::_, _) | None -> ()
+    else
+      if is_ident token || is_string token then
+        match next_token buffer with
+          Some ([], next) ->
+          if is_ident next || is_string next
+             || is_bytes next || is_int next
+          then
+            let pos    = (to_region token)#stop in
+            let region = Region.make ~start:pos ~stop:pos
+            in fail region Missing_break
+        | Some (_::_, _) | None -> ()
 
 (* END TRAILER *)
 }
diff --git a/src/passes/1-parser/cameligo/LexerMain.ml b/src/passes/1-parser/cameligo/LexerMain.ml
index 2a281efd5..498098035 100644
--- a/src/passes/1-parser/cameligo/LexerMain.ml
+++ b/src/passes/1-parser/cameligo/LexerMain.ml
@@ -4,7 +4,10 @@ module Region = Simple_utils.Region
 
 module IO =
   struct
-    let options = EvalOpt.(read ~lang:`CameLIGO ~ext:".mligo")
+    let options =
+      let open EvalOpt in
+      let block = mk_block ~opening:"(*" ~closing:"*)"
+      in read ~block ~line:"//" ".mligo"
   end
 
 module M = LexerUnit.Make (IO) (Lexer.Make (LexToken))
@@ -12,4 +15,4 @@ module M = LexerUnit.Make (IO) (Lexer.Make (LexToken))
 let () =
   match M.trace () with
     Stdlib.Ok () -> ()
-  | Error Region.{value; _} -> Utils.highlight value
+  | Error Region.{value; _} -> Printf.eprintf "\027[31m%s\027[0m%!" value
diff --git a/src/passes/1-parser/cameligo/ParserMain.ml b/src/passes/1-parser/cameligo/ParserMain.ml
index bc47d9199..a3d13f3cc 100644
--- a/src/passes/1-parser/cameligo/ParserMain.ml
+++ b/src/passes/1-parser/cameligo/ParserMain.ml
@@ -5,7 +5,10 @@ module SSet   = Set.Make (String)
 
 module IO =
   struct
-    let options = EvalOpt.(read ~lang:`CameLIGO ~ext:".mligo")
+    let options =
+      let open EvalOpt in
+      let block = mk_block ~opening:"(*" ~closing:"*)"
+      in read ~block ~line:"//" ".mligo"
   end
 
 module SubIO =
@@ -14,7 +17,8 @@ module SubIO =
       libs    : string list;
       verbose : SSet.t;
       offsets : bool;
-      lang    : EvalOpt.language;
+      block   : EvalOpt.block_comment option;
+      line    : EvalOpt.line_comment option;
       ext     : string;
       mode    : [`Byte | `Point];
       cmd     : EvalOpt.command;
@@ -26,7 +30,8 @@ module SubIO =
         method libs    = IO.options#libs
         method verbose = IO.options#verbose
         method offsets = IO.options#offsets
-        method lang    = IO.options#lang
+        method block   = IO.options#block
+        method line    = IO.options#line
         method ext     = IO.options#ext
         method mode    = IO.options#mode
         method cmd     = IO.options#cmd
@@ -37,7 +42,8 @@ module SubIO =
       EvalOpt.make ~libs:options#libs
                    ~verbose:options#verbose
                    ~offsets:options#offsets
-                   ~lang:options#lang
+                   ?block:options#block
+                   ?line:options#line
                    ~ext:options#ext
                    ~mode:options#mode
                    ~cmd:options#cmd
diff --git a/src/passes/1-parser/pascaligo.ml b/src/passes/1-parser/pascaligo.ml
index 6e4759fe8..02b8f462e 100644
--- a/src/passes/1-parser/pascaligo.ml
+++ b/src/passes/1-parser/pascaligo.ml
@@ -8,15 +8,14 @@ module SSet     = Set.Make (String)
 
 (* Mock IOs TODO: Fill them with CLI options *)
 
-type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
 module SubIO =
   struct
     type options = <
       libs    : string list;
       verbose : SSet.t;
       offsets : bool;
-      lang    : language;
+      block   : EvalOpt.block_comment option;
+      line    : EvalOpt.line_comment option;
       ext     : string;   (* ".ligo" *)
       mode    : [`Byte | `Point];
       cmd     : EvalOpt.command;
@@ -24,22 +23,25 @@ module SubIO =
     >
 
     let options : options =
-      object
-        method libs    = []
-        method verbose = SSet.empty
-        method offsets = true
-        method lang    = `PascaLIGO
-        method ext     = ".ligo"
-        method mode    = `Point
-        method cmd     = EvalOpt.Quiet
-        method mono    = false
-      end
+      let block = EvalOpt.mk_block ~opening:"(*" ~closing:"*)"
+      in object
+           method libs    = []
+           method verbose = SSet.empty
+           method offsets = true
+           method block   = Some block
+           method line    = Some "//"
+           method ext     = ".ligo"
+           method mode    = `Point
+           method cmd     = EvalOpt.Quiet
+           method mono    = false
+         end
 
     let make =
       EvalOpt.make ~libs:options#libs
                    ~verbose:options#verbose
                    ~offsets:options#offsets
-                   ~lang:options#lang
+                   ?block:options#block
+                   ?line:options#line
                    ~ext:options#ext
                    ~mode:options#mode
                    ~cmd:options#cmd
diff --git a/src/passes/1-parser/pascaligo/.links b/src/passes/1-parser/pascaligo/.links
index 0b836a2d9..fed453f99 100644
--- a/src/passes/1-parser/pascaligo/.links
+++ b/src/passes/1-parser/pascaligo/.links
@@ -2,6 +2,7 @@ $HOME/git/OCaml-build/Makefile
 
 ../shared/Lexer.mli
 ../shared/Lexer.mll
+../shared/LexerLib.ml
 ../shared/EvalOpt.ml
 ../shared/EvalOpt.mli
 ../shared/FQueue.ml
@@ -18,5 +19,6 @@ $HOME/git/OCaml-build/Makefile
 ../shared/LexerUnit.ml
 ../shared/ParserUnit.mli
 ../shared/ParserUnit.ml
+../shared/LexerLib.ml
 
 $HOME/git/ligo/_build/default/src/passes/1-parser/pascaligo/ParErr.ml
diff --git a/src/passes/1-parser/pascaligo/LexToken.mli b/src/passes/1-parser/pascaligo/LexToken.mli
index 60479955f..88adbff37 100644
--- a/src/passes/1-parser/pascaligo/LexToken.mli
+++ b/src/passes/1-parser/pascaligo/LexToken.mli
@@ -163,11 +163,22 @@ val eof       : Region.t -> token
 
 (* Predicates *)
 
-val is_string : token -> bool
-val is_bytes  : token -> bool
-val is_int    : token -> bool
-val is_ident  : token -> bool
-val is_kwd    : token -> bool
-val is_constr : token -> bool
-val is_sym    : token -> bool
 val is_eof    : token -> bool
+
+(* Style *)
+
+type error
+
+val error_to_string : error -> string
+
+exception Error of error Region.reg
+
+val format_error :
+  ?offsets:bool -> [`Byte | `Point] ->
+  error Region.reg -> file:bool -> string Region.reg
+
+val check_right_context :
+  token ->
+  (Lexing.lexbuf -> (Markup.t list * token) option) ->
+  Lexing.lexbuf ->
+  unit
diff --git a/src/passes/1-parser/pascaligo/LexToken.mll b/src/passes/1-parser/pascaligo/LexToken.mll
index 95035cf37..f300187fe 100644
--- a/src/passes/1-parser/pascaligo/LexToken.mll
+++ b/src/passes/1-parser/pascaligo/LexToken.mll
@@ -483,17 +483,16 @@ type nat_err =
 | Non_canonical_zero_nat
 
 let mk_nat lexeme region =
-  match (String.index_opt lexeme 'n') with
-  | None -> Error Invalid_natural
-  | Some _ -> (
-    let z =
-      Str.(global_replace (regexp "_") "" lexeme) |>
-      Str.(global_replace (regexp "n") "") |>
-      Z.of_string in
-    if Z.equal z Z.zero && lexeme <> "0n"
-    then Error Non_canonical_zero_nat
-    else Ok (Nat Region.{region; value = lexeme,z})
-  )
+  match String.index_opt lexeme 'n' with
+    None -> Error Invalid_natural
+  | Some _ ->
+      let z =
+        Str.(global_replace (regexp "_") "" lexeme) |>
+        Str.(global_replace (regexp "n") "") |>
+        Z.of_string in
+      if Z.equal z Z.zero && lexeme <> "0n"
+      then Error Non_canonical_zero_nat
+      else Ok (Nat Region.{region; value = lexeme,z})
 
 let mk_mutez lexeme region =
   let z =
@@ -563,99 +562,60 @@ let mk_attr _header _string _region =
 
 (* Predicates *)
 
-let is_string = function
-  String _ -> true
-|        _ -> false
+let is_string = function String _ -> true | _ -> false
+let is_bytes  = function Bytes _ -> true | _ -> false
+let is_int    = function Int _ -> true | _ -> false
+let is_ident  = function Ident _ -> true | _ -> false
+let is_eof    = function EOF _ -> true | _ -> false
 
-let is_bytes = function
-  Bytes _ -> true
-|       _ -> false
+(* Errors *)
 
-let is_int = function
-  Int _ -> true
-|     _ -> false
+type error =
+  Odd_lengthed_bytes
+| Missing_break
 
-let is_ident = function
-  Ident _ -> true
-|       _ -> false
+let error_to_string = function
+  Odd_lengthed_bytes ->
+    "The length of the byte sequence is an odd number.\n\
+     Hint: Add or remove a digit."
+| Missing_break ->
+    "Missing break.\n\
+     Hint: Insert some space."
 
-let is_kwd = function
-  And        _
-| Attributes _
-| Begin      _
-| BigMap     _
-| Block      _
-| Case       _
-| Const      _
-| Contains   _
-| Else       _
-| End        _
-| False      _
-| For        _
-| From       _
-| Function   _
-| If         _
-| In         _
-| Is         _
-| List       _
-| Map        _
-| Mod        _
-| Nil        _
-| Not        _
-| Of         _
-| Or         _
-| Patch      _
-| Record     _
-| Remove     _
-| Set        _
-| Skip       _
-| Step       _
-| Then       _
-| To         _
-| True       _
-| Type       _
-| Unit       _
-| Var        _
-| While      _
-| With       _ -> true
-|            _ -> false
+exception Error of error Region.reg
 
-let is_constr = function
-  Constr  _
-| C_None  _
-| C_Some  _ -> true
-|         _ -> false
+let format_error ?(offsets=true) mode Region.{region; value} ~file =
+  let msg = error_to_string value
+  and reg = region#to_string ~file ~offsets mode in
+  let value = sprintf "Lexical error %s:\n%s\n" reg msg
+  in Region.{value; region}
 
-let is_sym = function
-  SEMI     _
-| COMMA    _
-| LPAR     _
-| RPAR     _
-| LBRACE   _
-| RBRACE   _
-| LBRACKET _
-| RBRACKET _
-| CONS     _
-| VBAR     _
-| ARROW    _
-| ASS      _
-| EQ       _
-| COLON    _
-| LT       _
-| LE       _
-| GT       _
-| GE       _
-| NE       _
-| PLUS     _
-| MINUS    _
-| SLASH    _
-| TIMES    _
-| DOT      _
-| WILD     _
-| CAT      _ -> true
-|          _ -> false
+let fail region value = raise (Error Region.{region; value})
 
-let is_eof = function EOF _ -> true | _ -> false
+let check_right_context token next_token buffer : unit =
+  if not (is_eof token) then
+    if is_int token || is_bytes token then
+      match next_token buffer with
+        Some ([], next) ->
+          let pos    = (to_region token)#stop in
+          let region = Region.make ~start:pos ~stop:pos in
+          if is_int next then
+            fail region Odd_lengthed_bytes
+          else
+            if is_ident next || is_string next || is_bytes next then
+              fail region Missing_break
+      | Some (_::_, _) | None -> ()
+    else
+      if is_ident token || is_string token then
+        match next_token buffer with
+          Some ([], next) ->
+          if is_ident next || is_string next
+             || is_bytes next || is_int next
+          then
+            let pos    = (to_region token)#stop in
+            let region = Region.make ~start:pos ~stop:pos
+            in fail region Missing_break
+        | Some (_::_, _) | None -> ()
 
 (* END TRAILER *)
 }
diff --git a/src/passes/1-parser/pascaligo/LexerMain.ml b/src/passes/1-parser/pascaligo/LexerMain.ml
index 3c8d7c642..a497df466 100644
--- a/src/passes/1-parser/pascaligo/LexerMain.ml
+++ b/src/passes/1-parser/pascaligo/LexerMain.ml
@@ -4,7 +4,10 @@ module Region = Simple_utils.Region
 
 module IO =
   struct
-    let options = EvalOpt.(read ~lang:`PascaLIGO ~ext:".ligo")
+    let options =
+      let open EvalOpt in
+      let block = mk_block ~opening:"(*" ~closing:"*)"
+      in read ~block ~line:"//" ".ligo"
   end
 
 module M = LexerUnit.Make (IO) (Lexer.Make (LexToken))
diff --git a/src/passes/1-parser/pascaligo/ParserMain.ml b/src/passes/1-parser/pascaligo/ParserMain.ml
index c94ca806d..beb0b4885 100644
--- a/src/passes/1-parser/pascaligo/ParserMain.ml
+++ b/src/passes/1-parser/pascaligo/ParserMain.ml
@@ -5,7 +5,10 @@ module SSet   = Set.Make (String)
 
 module IO =
   struct
-    let options = EvalOpt.(read ~lang:`PascaLIGO ~ext:".ligo")
+    let options =
+      let open EvalOpt in
+      let block = mk_block ~opening:"(*" ~closing:"*)"
+      in read ~block ~line:"//" ".ligo"
   end
 
 module SubIO =
@@ -14,7 +17,8 @@ module SubIO =
       libs    : string list;
       verbose : SSet.t;
       offsets : bool;
-      lang    : EvalOpt.language;
+      block   : EvalOpt.block_comment option;
+      line    : EvalOpt.line_comment option;
       ext     : string;
       mode    : [`Byte | `Point];
       cmd     : EvalOpt.command;
@@ -26,7 +30,8 @@ module SubIO =
         method libs    = IO.options#libs
         method verbose = IO.options#verbose
         method offsets = IO.options#offsets
-        method lang    = IO.options#lang
+        method block   = IO.options#block
+        method line    = IO.options#line
         method ext     = IO.options#ext
         method mode    = IO.options#mode
         method cmd     = IO.options#cmd
@@ -37,7 +42,8 @@ module SubIO =
       EvalOpt.make ~libs:options#libs
                    ~verbose:options#verbose
                    ~offsets:options#offsets
-                   ~lang:options#lang
+                   ?block:options#block
+                   ?line:options#line
                    ~ext:options#ext
                    ~mode:options#mode
                    ~cmd:options#cmd
diff --git a/src/passes/1-parser/reasonligo.ml b/src/passes/1-parser/reasonligo.ml
index 85f9557e4..1af70c927 100644
--- a/src/passes/1-parser/reasonligo.ml
+++ b/src/passes/1-parser/reasonligo.ml
@@ -11,15 +11,14 @@ module SSet        = Set.Make (String)
 
 (* Mock IOs TODO: Fill them with CLI options *)
 
-type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
 module SubIO =
   struct
     type options = <
       libs    : string list;
       verbose : SSet.t;
       offsets : bool;
-      lang    : language;
+      block   : EvalOpt.block_comment option;
+      line    : EvalOpt.line_comment option;
       ext     : string;   (* ".religo" *)
       mode    : [`Byte | `Point];
       cmd     : EvalOpt.command;
@@ -27,22 +26,25 @@ module SubIO =
     >
 
     let options : options =
-      object
-        method libs    = []
-        method verbose = SSet.empty
-        method offsets = true
-        method lang    = `ReasonLIGO
-        method ext     = ".religo"
-        method mode    = `Point
-        method cmd     = EvalOpt.Quiet
-        method mono    = false
-      end
+      let block = EvalOpt.mk_block ~opening:"/*" ~closing:"*/"
+      in object
+           method libs    = []
+           method verbose = SSet.empty
+           method offsets = true
+           method block   = Some block
+           method line    = Some "//"
+           method ext     = ".religo"
+           method mode    = `Point
+           method cmd     = EvalOpt.Quiet
+           method mono    = false
+         end
 
     let make =
       EvalOpt.make ~libs:options#libs
                    ~verbose:options#verbose
                    ~offsets:options#offsets
-                   ~lang:options#lang
+                   ?block:options#block
+                   ?line:options#line
                    ~ext:options#ext
                    ~mode:options#mode
                    ~cmd:options#cmd
diff --git a/src/passes/1-parser/reasonligo/LexToken.mli b/src/passes/1-parser/reasonligo/LexToken.mli
index 4a70d9d13..240e824d2 100644
--- a/src/passes/1-parser/reasonligo/LexToken.mli
+++ b/src/passes/1-parser/reasonligo/LexToken.mli
@@ -154,11 +154,22 @@ val eof       : Region.t -> token
 
 (* Predicates *)
 
-val is_string : token -> bool
-val is_bytes  : token -> bool
-val is_int    : token -> bool
-val is_ident  : token -> bool
-val is_kwd    : token -> bool
-val is_constr : token -> bool
-val is_sym    : token -> bool
 val is_eof    : token -> bool
+
+(* Style *)
+
+type error
+
+val error_to_string : error -> string
+
+exception Error of error Region.reg
+
+val format_error :
+  ?offsets:bool -> [`Byte | `Point] ->
+  error Region.reg -> file:bool -> string Region.reg
+
+val check_right_context :
+  token ->
+  (Lexing.lexbuf -> (Markup.t list * token) option) ->
+  Lexing.lexbuf ->
+  unit
diff --git a/src/passes/1-parser/reasonligo/LexToken.mll b/src/passes/1-parser/reasonligo/LexToken.mll
index cd05538e7..92aec58e3 100644
--- a/src/passes/1-parser/reasonligo/LexToken.mll
+++ b/src/passes/1-parser/reasonligo/LexToken.mll
@@ -460,75 +460,60 @@ let mk_attr header lexeme region =
 
 (* Predicates *)
 
-let is_string = function
-  String _ -> true
-|        _ -> false
+let is_string = function String _ -> true | _ -> false
+let is_bytes  = function Bytes _ -> true | _ -> false
+let is_int    = function Int _ -> true | _ -> false
+let is_ident  = function Ident _ -> true | _ -> false
+let is_eof    = function EOF _ -> true | _ -> false
 
-let is_bytes = function
-  Bytes _ -> true
-|       _ -> false
+(* Errors *)
 
-let is_int = function
-  Int _ -> true
-|     _ -> false
+type error =
+  Odd_lengthed_bytes
+| Missing_break
 
-let is_ident = function
-  Ident _ -> true
-|       _ -> false
+let error_to_string = function
+  Odd_lengthed_bytes ->
+    "The length of the byte sequence is an odd number.\n\
+     Hint: Add or remove a digit."
+| Missing_break ->
+    "Missing break.\n\
+     Hint: Insert some space."
 
-let is_kwd = function
-  Else _
-| False _
-| If _
-| Let _
-| Rec _
-| Switch _
-| Mod _
-| Or _
-| True _
-| Type _ -> true
-| _ -> false
+exception Error of error Region.reg
 
-let is_constr = function
-  Constr _
-| Ident _
-| False _
-| True _ -> true
-| _ -> false
+let format_error ?(offsets=true) mode Region.{region; value} ~file =
+  let msg = error_to_string value
+  and reg = region#to_string ~file ~offsets mode in
+  let value = sprintf "Lexical error %s:\n%s\n" reg msg
+  in Region.{value; region}
 
-let is_sym = function
-  CAT _
-| MINUS _
-| PLUS _
-| SLASH _
-| TIMES _
-| LPAR _
-| RPAR _
-| LBRACKET _
-| RBRACKET _
-| LBRACE _
-| RBRACE _
-| COMMA _
-| SEMI  _
-| VBAR _
-| COLON _
-| DOT _
-| ELLIPSIS _
-| WILD _
-| EQ _
-| EQEQ _
-| NE _
-| LT _
-| GT _
-| LE _
-| GE _
-| ARROW _
-| BOOL_OR _
-| NOT _
-| BOOL_AND _ -> true
-|          _ -> false
+let fail region value = raise (Error Region.{region; value})
 
-let is_eof = function EOF _ -> true | _ -> false
+let check_right_context token next_token buffer : unit =
+  if not (is_eof token) then
+    if is_int token || is_bytes token then
+      match next_token buffer with
+        Some ([], next) ->
+          let pos    = (to_region token)#stop in
+          let region = Region.make ~start:pos ~stop:pos in
+          if is_int next then
+            fail region Odd_lengthed_bytes
+          else
+            if is_ident next || is_string next || is_bytes next then
+              fail region Missing_break
+      | Some (_::_, _) | None -> ()
+    else
+      if is_ident token || is_string token then
+        match next_token buffer with
+          Some ([], next) ->
+          if is_ident next || is_string next
+             || is_bytes next || is_int next
+          then
+            let pos    = (to_region token)#stop in
+            let region = Region.make ~start:pos ~stop:pos
+            in fail region Missing_break
+        | Some (_::_, _) | None -> ()
 
 (* END TRAILER *)
 }
diff --git a/src/passes/1-parser/reasonligo/LexerMain.ml b/src/passes/1-parser/reasonligo/LexerMain.ml
index 4f063582f..f0d6fdfa1 100644
--- a/src/passes/1-parser/reasonligo/LexerMain.ml
+++ b/src/passes/1-parser/reasonligo/LexerMain.ml
@@ -4,7 +4,10 @@ module Region = Simple_utils.Region
 
 module IO =
   struct
-    let options = EvalOpt.(read ~lang:`ReasonLIGO ~ext:".religo")
+    let options =
+      let open EvalOpt in
+      let block = mk_block ~opening:"/*" ~closing:"*/"
+      in read ~block ~line:"//" ".religo"
   end
 
 module M = LexerUnit.Make (IO) (Lexer.Make (LexToken))
@@ -12,4 +15,4 @@ module M = LexerUnit.Make (IO) (Lexer.Make (LexToken))
 let () =
   match M.trace () with
     Stdlib.Ok () -> ()
-  | Error Region.{value; _} -> Utils.highlight value
+  | Error Region.{value; _} -> Printf.eprintf "\027[31m%s\027[0m%!" value
diff --git a/src/passes/1-parser/reasonligo/Parser.mly b/src/passes/1-parser/reasonligo/Parser.mly
index 7a1c02ada..9e6e77799 100644
--- a/src/passes/1-parser/reasonligo/Parser.mly
+++ b/src/passes/1-parser/reasonligo/Parser.mly
@@ -40,11 +40,11 @@ let rec curry hd = function
     in TFun {value; region}
 | [] -> hd
 
-let wild_error e = 
-  match e with 
-    | EVar { value = "_"; _} as e -> 
+let wild_error e =
+  match e with
+    | EVar { value = "_"; _} as e ->
       let open! SyntaxError in
-      raise (Error (InvalidWild e)) 
+      raise (Error (InvalidWild e))
     | _ -> ()
 
 (* END HEADER *)
@@ -270,30 +270,30 @@ let_declaration:
 
 let_binding:
   "<ident>" type_annotation? "=" expr {
-    wild_error $4;    
+    wild_error $4;
     Scoping.check_reserved_name $1;
     {binders = PVar $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | "_" type_annotation? "=" expr {
-    wild_error $4;   
+    wild_error $4;
     {binders = PWild $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | unit type_annotation? "=" expr {
-    wild_error $4;   
+    wild_error $4;
     {binders = PUnit $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | record_pattern type_annotation? "=" expr {
-    wild_error $4;   
+    wild_error $4;
     Scoping.check_pattern (PRecord $1);
     {binders = PRecord $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | par(closed_irrefutable) type_annotation? "=" expr {
-    wild_error $4;   
+    wild_error $4;
     Scoping.check_pattern $1.value.inside;
     {binders = PPar $1, []; lhs_type=$2; eq=$3; let_rhs=$4}
   }
 | tuple(sub_irrefutable) type_annotation? "=" expr {
-    wild_error $4;   
+    wild_error $4;
     Utils.nsepseq_iter Scoping.check_pattern $1;
     let hd, tl  = $1 in
     let start   = pattern_to_region hd in
@@ -422,7 +422,7 @@ expr:
   base_cond__open(expr) | switch_expr(base_cond) { $1 }
 
 base_cond__open(x):
-  base_expr(x) | conditional(expr_with_let_expr) { 
+  base_expr(x) | conditional(expr_with_let_expr) {
     wild_error $1;
     $1 }
 
@@ -460,11 +460,11 @@ fun_expr:
     let region      = cover start stop in
 
     let rec arg_to_pattern = function
-      EVar v ->        
+      EVar v ->
         if v.value = "_" then
           PWild v.region
         else (
-          Scoping.check_reserved_name v;          
+          Scoping.check_reserved_name v;
           PVar v
         )
     | EAnnot {region; value = {inside = EVar v, colon, typ; _}} ->
@@ -895,7 +895,7 @@ path:
 | projection { Path $1 }
 
 update_record:
-  "{""..."path "," sep_or_term_list(field_path_assignment,",") "}" {
+  "{" "..." path "," sep_or_term_list(field_path_assignment,",") "}" {
     let region = cover $1 $6 in
     let ne_elements, terminator = $5 in
     let value = {
@@ -913,7 +913,7 @@ expr_with_let_expr:
   expr { $1 }
 | let_expr(expr_with_let_expr) { $1 }
 
-more_field_assignments: 
+more_field_assignments:
   "," sep_or_term_list(field_assignment_punning,",") {
     let elts, _region = $2 in
     $1, elts
@@ -926,9 +926,9 @@ sequence_or_record_in:
     PaSequence {s_elts = elts; s_terminator=None}
   }
 | field_assignment more_field_assignments? {
-    match $2 with 
-    | Some (comma, elts) -> 
-      let r_elts = Utils.nsepseq_cons $1 comma elts in 
+    match $2 with
+    | Some (comma, elts) ->
+      let r_elts = Utils.nsepseq_cons $1 comma elts in
       PaRecord {r_elts; r_terminator = None}
     | None ->
       PaRecord {r_elts = ($1, []); r_terminator = None}
@@ -950,15 +950,15 @@ sequence_or_record:
                      terminator = r.r_terminator}
         in ERecord {region; value}}
 
-field_assignment_punning: 
-  (* This can only happen with multiple fields - 
+field_assignment_punning:
+  (* This can only happen with multiple fields -
      one item punning does NOT work in ReasonML *)
-  field_name { 
+  field_name {
     let value = {
       field_name = $1;
       assignment = ghost;
       field_expr = EVar $1 }
-    in 
+    in
     {$1 with value}
   }
 | field_assignment {
diff --git a/src/passes/1-parser/reasonligo/ParserMain.ml b/src/passes/1-parser/reasonligo/ParserMain.ml
index 82ffc7b32..1c173bee0 100644
--- a/src/passes/1-parser/reasonligo/ParserMain.ml
+++ b/src/passes/1-parser/reasonligo/ParserMain.ml
@@ -5,7 +5,10 @@ module SSet   = Set.Make (String)
 
 module IO =
   struct
-    let options = EvalOpt.(read ~lang:`ReasonLIGO ~ext:".religo")
+    let options =
+      let open EvalOpt in
+      let block = mk_block ~opening:"/*" ~closing:"*/"
+      in read ~block ~line:"//" ".religo"
   end
 
 module SubIO =
@@ -14,7 +17,8 @@ module SubIO =
       libs    : string list;
       verbose : SSet.t;
       offsets : bool;
-      lang    : EvalOpt.language;
+      block   : EvalOpt.block_comment option;
+      line    : EvalOpt.line_comment option;
       ext     : string;
       mode    : [`Byte | `Point];
       cmd     : EvalOpt.command;
@@ -26,7 +30,8 @@ module SubIO =
         method libs    = IO.options#libs
         method verbose = IO.options#verbose
         method offsets = IO.options#offsets
-        method lang    = IO.options#lang
+        method block   = IO.options#block
+        method line    = IO.options#line
         method ext     = IO.options#ext
         method mode    = IO.options#mode
         method cmd     = IO.options#cmd
@@ -37,7 +42,8 @@ module SubIO =
       EvalOpt.make ~libs:options#libs
                    ~verbose:options#verbose
                    ~offsets:options#offsets
-                   ~lang:options#lang
+                   ?block:options#block
+                   ?line:options#line
                    ~ext:options#ext
                    ~mode:options#mode
                    ~cmd:options#cmd
diff --git a/src/passes/1-parser/shared/.links b/src/passes/1-parser/shared/.links
index df8a82cd9..b29b57639 100644
--- a/src/passes/1-parser/shared/.links
+++ b/src/passes/1-parser/shared/.links
@@ -1,7 +1,2 @@
 $HOME/git/OCaml-build/Makefile
 $HOME/git/OCaml-build/Makefile.cfg
-
-$HOME/git/ligo/vendors/ligo-utils/simple-utils/pos.mli
-$HOME/git/ligo/vendors/ligo-utils/simple-utils/pos.ml
-$HOME/git/ligo/vendors/ligo-utils/simple-utils/region.mli
-$HOME/git/ligo/vendors/ligo-utils/simple-utils/region.ml
diff --git a/src/passes/1-parser/shared/EvalOpt.ml b/src/passes/1-parser/shared/EvalOpt.ml
index 54d971846..8cb22608d 100644
--- a/src/passes/1-parser/shared/EvalOpt.ml
+++ b/src/passes/1-parser/shared/EvalOpt.ml
@@ -5,37 +5,42 @@
 
 type command = Quiet | Copy | Units | Tokens
 
-type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
-let lang_to_string = function
-  `PascaLIGO -> "PascaLIGO"
-| `CameLIGO -> "CameLIGO"
-| `ReasonLIGO -> "ReasonLIGO"
-
 (* The type [options] gathers the command-line options. *)
 
 module SSet = Set.Make (String)
 
+type line_comment = string (* Opening of a line comment *)
+type block_comment = <opening : string; closing : string>
+
+let mk_block ~opening ~closing : block_comment =
+  object
+    method opening = opening
+    method closing = closing
+  end
+
 type options = <
   input   : string option;
   libs    : string list;
   verbose : SSet.t;
   offsets : bool;
-  lang    : language;
-  ext     : string;           (* ".ligo", ".mligo", ".religo" *)
+  block   : block_comment option;
+  line    : line_comment option;
+  ext     : string;
   mode    : [`Byte | `Point];
   cmd     : command;
   mono    : bool;
   expr    : bool
 >
 
-let make ~input ~libs ~verbose ~offsets ~lang ~ext ~mode ~cmd ~mono ~expr : options =
+let make ~input ~libs ~verbose ~offsets ?block
+         ?line ~ext ~mode ~cmd ~mono ~expr : options =
   object
     method input   = input
     method libs    = libs
     method verbose = verbose
     method offsets = offsets
-    method lang    = lang
+    method block   = block
+    method line    = line
     method ext     = ext
     method mode    = mode
     method cmd     = cmd
@@ -58,10 +63,10 @@ let abort msg =
 
 (* Help *)
 
-let help language extension () =
+let help extension () =
   let file = Filename.basename Sys.argv.(0) in
   printf "Usage: %s [<option> ...] [<input>%s | \"-\"]\n" file extension;
-  printf "where <input>%s is the %s source file (default: stdin),\n" extension language;
+  printf "where <input>%s is the LIGO source file (default: stdin),\n" extension;
   print "and each <option> (if any) is one of the following:";
   print "  -I <paths>             Library paths (colon-separated)";
   print "  -t, --tokens           Print tokens";
@@ -105,8 +110,7 @@ let add_verbose d =
                             !verbose
                             (split_at_colon d)
 
-let specs language extension =
-  let language = lang_to_string language in
+let specs extension =
   let open! Getopt in [
     'I',     nolong,    None, Some add_path;
     'c',     "copy",    set copy true, None;
@@ -118,7 +122,7 @@ let specs language extension =
     noshort, "mono",    set mono true, None;
     noshort, "expr",    set expr true, None;
     noshort, "verbose", None, Some add_verbose;
-    'h',     "help",    Some (help language extension), None;
+    'h',     "help",    Some (help extension), None;
     noshort, "version", Some version, None
   ]
 ;;
@@ -156,7 +160,7 @@ let print_opt () =
   printf "input    = %s\n" (string_of quote !input);
   printf "libs     = %s\n" (string_of_path !libs)
 
-let check lang ext =
+let check ?block ?line ~ext =
   let () =
     if SSet.mem "cli" !verbose then print_opt () in
 
@@ -209,16 +213,19 @@ let check lang ext =
     | false, false, false,  true -> Tokens
     | _ -> abort "Choose one of -q, -c, -u, -t."
 
-  in make ~input ~libs ~verbose ~offsets ~mode ~cmd ~mono ~expr ~lang ~ext
+  in make ~input ~libs ~verbose ~offsets ~mode
+          ~cmd ~mono ~expr ?block ?line ~ext
 
 (* Parsing the command-line options *)
 
-let read ~lang ~ext =
+type extension = string
+
+let read ?block ?line (ext: extension) =
   try
-    Getopt.parse_cmdline (specs lang ext) anonymous;
+    Getopt.parse_cmdline (specs ext) anonymous;
     (verb_str :=
        let apply e a =
          if a = "" then e else Printf.sprintf "%s, %s" e a
        in SSet.fold apply !verbose "");
-    check lang ext
+    check ?block ?line ~ext
   with Getopt.Error msg -> abort msg
diff --git a/src/passes/1-parser/shared/EvalOpt.mli b/src/passes/1-parser/shared/EvalOpt.mli
index 6ffd0ffce..2e7e7f3cd 100644
--- a/src/passes/1-parser/shared/EvalOpt.mli
+++ b/src/passes/1-parser/shared/EvalOpt.mli
@@ -49,19 +49,21 @@ type command = Quiet | Copy | Units | Tokens
           expected.}
 } *)
 
-type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
-val lang_to_string : language -> string
-
 module SSet : Set.S with type elt = string and type t = Set.Make(String).t
 
+type line_comment = string (* Opening of a line comment *)
+type block_comment = <opening : string; closing : string>
+
+val mk_block : opening:string -> closing:string -> block_comment
+
 type options = <
   input   : string option;
   libs    : string list;
   verbose : SSet.t;
   offsets : bool;
-  lang    : language;
-  ext     : string;   (* ".ligo", ".mligo", ".religo" *)
+  block   : block_comment option;
+  line    : line_comment option;
+  ext     : string;
   mode    : [`Byte | `Point];
   cmd     : command;
   mono    : bool;
@@ -73,7 +75,8 @@ val make :
   libs:string list ->
   verbose:SSet.t ->
   offsets:bool ->
-  lang:language ->
+  ?block:block_comment ->
+  ?line:line_comment ->
   ext:string ->
   mode:[`Byte | `Point] ->
   cmd:command ->
@@ -81,8 +84,9 @@ val make :
   expr:bool ->
   options
 
-(** Parsing the command-line options on stdin.  The first parameter is
-   the name of the concrete syntax, e.g., [PascaLIGO], and the second
-   is the expected file extension, e.g., ".ligo". *)
+(** Parsing the command-line options on stdin. *)
 
-val read : lang:language -> ext:string -> options
+type extension = string
+
+val read :
+  ?block:block_comment -> ?line:line_comment -> extension -> options
diff --git a/src/passes/1-parser/shared/Lexer.mli b/src/passes/1-parser/shared/Lexer.mli
index 60e3be89b..f7af4b055 100644
--- a/src/passes/1-parser/shared/Lexer.mli
+++ b/src/passes/1-parser/shared/Lexer.mli
@@ -82,13 +82,6 @@ module type TOKEN =
 
     (* Predicates *)
 
-    val is_string : token -> bool
-    val is_bytes  : token -> bool
-    val is_int    : token -> bool
-    val is_ident  : token -> bool
-    val is_kwd    : token -> bool
-    val is_constr : token -> bool
-    val is_sym    : token -> bool
     val is_eof    : token -> bool
 
     (* Projections *)
@@ -96,73 +89,8 @@ module type TOKEN =
     val to_lexeme : token -> lexeme
     val to_string : token -> ?offsets:bool -> [`Byte | `Point] -> string
     val to_region : token -> Region.t
-  end
 
-(* The module type for lexers is [S]. It mainly exports the function
-   [open_token_stream], which returns
-
-     * a function [read] that extracts tokens from a lexing buffer,
-       together with a lexing buffer [buffer] to read from,
-     * a function [close] that closes that buffer,
-     * a function [get_pos] that returns the current position, and
-     * a function [get_last] that returns the region of the last
-       recognised token.
-     * a function [get_file] that returns the name of the file being scanned
-       (empty string if [stdin]).
-
-   Note that a module [Token] is exported too, because the signature
-   of the exported functions depend on it.
-
-   The call [read ~log] evaluates in a lexer (also known as a
-   tokeniser or scanner) whose type is [Lexing.lexbuf -> token], and
-   suitable for a parser generated by Menhir. The argument labelled
-   [log] is a logger, that is, it may print a token and its left
-   markup to a given channel, at the caller's discretion.
-*)
-
-module type S =
-  sig
-    module Token : TOKEN
-    type token = Token.token
-
-    type file_path = string
-    type logger = Markup.t list -> token -> unit
-
-    type window =
-      Nil
-    | One of token
-    | Two of token * token
-
-    val slide : token -> window -> window
-
-    type input =
-      File    of file_path
-    | String  of string
-    | Channel of in_channel
-    | Buffer  of Lexing.lexbuf
-
-    type instance = {
-      input    : input;
-      read     : log:logger -> Lexing.lexbuf -> token;
-      buffer   : Lexing.lexbuf;
-      get_win  : unit -> window;
-      get_pos  : unit -> Pos.t;
-      get_last : unit -> Region.t;
-      get_file : unit -> file_path;
-      close    : unit -> unit
-    }
-
-    type open_err = File_opening of string
-
-    val lexbuf_from_input :
-      input -> (Lexing.lexbuf * (unit -> unit), open_err) Stdlib.result
-
-    type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
-    val open_token_stream :
-      language -> input -> (instance, open_err) Stdlib.result
-
-    (* Error reporting *)
+    (* Style *)
 
     type error
 
@@ -171,9 +99,17 @@ module type S =
     exception Error of error Region.reg
 
     val format_error :
-      ?offsets:bool -> [`Byte | `Point] ->
-      error Region.reg -> file:bool -> string Region.reg
+      ?offsets:bool ->
+      [`Byte | `Point] ->
+      error Region.reg ->
+      file:bool ->
+      string Region.reg
 
+    val check_right_context :
+      token ->
+      (Lexing.lexbuf -> (Markup.t list * token) option) ->
+      Lexing.lexbuf ->
+      unit
   end
 
 (* The functorised interface
@@ -182,4 +118,4 @@ module type S =
    submodule in [S].
 *)
 
-module Make (Token: TOKEN) : S with module Token = Token
+module Make (Token: TOKEN) : LexerLib.S with module Token = Token
diff --git a/src/passes/1-parser/shared/Lexer.mll b/src/passes/1-parser/shared/Lexer.mll
index a67e438c8..0f0b0e52e 100644
--- a/src/passes/1-parser/shared/Lexer.mll
+++ b/src/passes/1-parser/shared/Lexer.mll
@@ -10,80 +10,6 @@ module Pos = Simple_utils.Pos
 
 type lexeme = string
 
-(* STRING PROCESSING *)
-
-(* The value of [mk_str len p] ("make string") is a string of length
-   [len] containing the [len] characters in the list [p], in reverse
-   order. For instance, [mk_str 3 ['c';'b';'a'] = "abc"]. *)
-
-let mk_str (len: int) (p: char list) : string =
-  let bytes = Bytes.make len ' ' in
-  let rec fill i = function
-         [] -> bytes
-  | char::l -> Bytes.set bytes i char; fill (i-1) l
-  in fill (len-1) p |> Bytes.to_string
-
-(* The call [explode s a] is the list made by pushing the characters
-   in the string [s] on top of [a], in reverse order. For example,
-   [explode "ba" ['c';'d'] = ['a'; 'b'; 'c'; 'd']]. *)
-
-let explode s acc =
-  let rec push = function
-    0 -> acc
-  | i -> s.[i-1] :: push (i-1)
-in push (String.length s)
-
-(* LEXER ENGINE *)
-
-(* Resetting file name and line number in the lexing buffer
-
-   The call [reset ~file ~line buffer] modifies in-place the lexing
-   buffer [buffer] so the lexing engine records that the file
-   associated with [buffer] is named [file], and the current line is
-   [line]. This function is useful when lexing a file that has been
-   previously preprocessed by the C preprocessor, in which case the
-   argument [file] is the name of the file that was preprocessed,
-   _not_ the preprocessed file (of which the user is not normally
-   aware). By default, the [line] argument is [1].
-*)
-
-let reset_file ~file buffer =
-  let open Lexing in
-  buffer.lex_curr_p <- {buffer.lex_curr_p with pos_fname = file}
-
-let reset_line ~line buffer =
-  assert (line >= 0);
-  let open Lexing in
-  buffer.lex_curr_p <- {buffer.lex_curr_p with pos_lnum = line}
-
-let reset_offset ~offset buffer =
-  assert (offset >= 0);
-  let open Lexing in
-  let bol = buffer.lex_curr_p.pos_bol in
-  buffer.lex_curr_p <- {buffer.lex_curr_p with pos_cnum = bol + offset }
-
-let reset ?file ?line ?offset buffer =
-  let () =
-    match file with
-      Some file -> reset_file ~file buffer
-    |      None -> () in
-  let () =
-    match line with
-      Some line -> reset_line ~line buffer
-    |      None -> () in
-  match offset with
-    Some offset -> reset_offset ~offset buffer
-  |        None -> ()
-
-(* Rolling back one lexeme _within the current semantic action_ *)
-
-let rollback buffer =
-  let open Lexing in
-  let len = String.length (lexeme buffer) in
-  let pos_cnum = buffer.lex_curr_p.pos_cnum - len in
-  buffer.lex_curr_pos <- buffer.lex_curr_pos - len;
-  buffer.lex_curr_p <- {buffer.lex_curr_p with pos_cnum}
-
 (* ALIASES *)
 
 let sprintf = Printf.sprintf
@@ -124,13 +50,6 @@ module type TOKEN =
 
     (* Predicates *)
 
-    val is_string : token -> bool
-    val is_bytes  : token -> bool
-    val is_int    : token -> bool
-    val is_ident  : token -> bool
-    val is_kwd    : token -> bool
-    val is_constr : token -> bool
-    val is_sym    : token -> bool
     val is_eof    : token -> bool
 
     (* Projections *)
@@ -138,53 +57,8 @@ module type TOKEN =
     val to_lexeme : token -> lexeme
     val to_string : token -> ?offsets:bool -> [`Byte | `Point] -> string
     val to_region : token -> Region.t
-  end
 
-(* The module type for lexers is [S]. *)
-
-module type S =
-  sig
-    module Token : TOKEN
-    type token = Token.token
-
-    type file_path = string
-    type logger = Markup.t list -> token -> unit
-
-    type window =
-      Nil
-    | One of token
-    | Two of token * token
-
-    val slide : token -> window -> window
-
-    type input =
-      File    of file_path
-    | String  of string
-    | Channel of in_channel
-    | Buffer  of Lexing.lexbuf
-
-    type instance = {
-      input    : input;
-      read     : log:logger -> Lexing.lexbuf -> token;
-      buffer   : Lexing.lexbuf;
-      get_win  : unit -> window;
-      get_pos  : unit -> Pos.t;
-      get_last : unit -> Region.t;
-      get_file : unit -> file_path;
-      close    : unit -> unit
-    }
-
-    type open_err = File_opening of string
-
-    val lexbuf_from_input :
-      input -> (Lexing.lexbuf * (unit -> unit), open_err) Stdlib.result
-
-    type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
-    val open_token_stream :
-      language -> input -> (instance, open_err) Stdlib.result
-
-    (* Error reporting *)
+    (* Style *)
 
     type error
 
@@ -195,198 +69,31 @@ module type S =
     val format_error :
       ?offsets:bool -> [`Byte | `Point] ->
       error Region.reg -> file:bool -> string Region.reg
+
+    val check_right_context :
+      token ->
+      (Lexing.lexbuf -> (Markup.t list * token) option) ->
+      Lexing.lexbuf ->
+      unit
   end
 
+
 (* The functorised interface
 
    Note that the module parameter [Token] is re-exported as a
    submodule in [S].
  *)
 
-module Make (Token: TOKEN) : (S with module Token = Token) =
+module Make (Token: TOKEN) : (LexerLib.S with module Token = Token) =
   struct
     module Token = Token
     type token = Token.token
 
     type file_path = string
 
-    (* THREAD FOR STRUCTURED CONSTRUCTS (STRINGS, COMMENTS) *)
-
-    (* When scanning structured constructs, like strings and comments,
-       we need to keep the region of the opening symbol (like double
-       quote, "//" or "(*") in order to report any error more
-       precisely. Since ocamllex is byte-oriented, we need to store
-       the parsed bytes as characters in an accumulator [acc] and
-       also its length [len], so, we are done, it is easy to build the
-       string making up the structured construct with [mk_str] (see
-       above).
-
-       The resulting data structure is called a _thread_.
-       (Note for Emacs: "*)".)
-    *)
-
-    type thread = {
-      opening : Region.t;
-      len     : int;
-      acc     : char list
-    }
-
-    let push_char char {opening; len; acc} = {opening; len=len+1; acc=char::acc}
-
-    let push_string str {opening; len; acc} =
-      {opening;
-       len = len + String.length str;
-       acc = explode str acc}
-
-    (* STATE *)
-
-    (** The type [buffer] models a two-slot buffer of tokens for
-       reporting after a parse error.
-
-       In [Two(t1,t2)], the token [t2] is the next to be sent to the
-       parser.
-
-       The call [slide token buffer] pushes the token [token] in the
-       buffer [buffer]. If the buffer is full, that is, it is
-       [Two(t1,t2)], then the token [t2] is discarded to make room for
-       [token].
-     *)
-    type window =
-      Nil
-    | One of token
-    | Two of token * token
-
-    let slide token = function
-                    Nil -> One token
-    | One t | Two (t,_) -> Two (token,t)
-
-    (* Beyond tokens, the result of lexing is a state. The type
-       [state] represents the logical state of the lexing engine, that
-       is, a value which is threaded during scanning and which denotes
-       useful, high-level information beyond what the type
-       [Lexing.lexbuf] in the standard library already provides for
-       all generic lexers.
-
-         Tokens are the smallest units used by the parser to build the
-       abstract syntax tree. The state includes a queue of recognised
-       tokens, with the markup at the left of its lexeme until either
-       the start of the file or the end of the previously recognised
-       token.
-
-         The markup from the last recognised token or, if the first
-       token has not been recognised yet, from the beginning of the
-       file is stored in the field [markup] of the state because it is
-       a side-effect, with respect to the output token list, and we
-       use a record with a single field [units] because that record
-       may be easily extended during the future maintenance of this
-       lexer.
-
-         The state also includes a field [pos] which holds the current
-       position in the LIGO source file. The position is not always
-       updated after a single character has been matched: that depends
-       on the regular expression that matched the lexing buffer.
-
-         The field [win] is a two-token window, that is, a buffer that
-       contains the last recognised token, and the penultimate (if
-       any).
-
-         The fields [decoder] and [supply] offer the support needed
-       for the lexing of UTF-8 encoded characters in comments (the
-       only place where they are allowed in LIGO). The former is the
-       decoder proper and the latter is the effectful function
-       [supply] that takes a byte, a start index and a length and feed
-       it to [decoder]. See the documentation of the third-party
-       library Uutf.
-     *)
-
-    type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
-    type state = {
-      units   : (Markup.t list * token) FQueue.t;
-      markup  : Markup.t list;
-      window  : window;
-      last    : Region.t;
-      pos     : Pos.t;
-      decoder : Uutf.decoder;
-      supply  : Bytes.t -> int -> int -> unit;
-      lang    : language
-    }
-
-    (* The call [enqueue (token, state)] updates functionally the
-       state [state] by associating the token [token] with the stored
-       markup and enqueuing the pair into the units queue. The field
-       [markup] is then reset to the empty list. *)
-
-    let enqueue (token, state) = {
-      state with
-        units  = FQueue.enq (state.markup, token) state.units;
-        markup = []
-    }
-
-    (* The call [sync state buffer] updates the current position in
-       accordance with the contents of the lexing buffer, more
-       precisely, depending on the length of the string which has just
-       been recognised by the scanner: that length is used as a
-       positive offset to the current column. *)
-
-    let sync state buffer =
-      let lex   = Lexing.lexeme buffer in
-      let len   = String.length lex in
-      let start = state.pos in
-      let stop  = start#shift_bytes len in
-      let state = {state with pos = stop}
-      in Region.make ~start ~stop, lex, state
-
-    (* MARKUP *)
-
-    (* Committing markup to the current logical state *)
-
-    let push_newline state buffer =
-      let value  = Lexing.lexeme buffer
-      and ()     = Lexing.new_line buffer
-      and start  = state.pos in
-      let stop   = start#new_line value in
-      let state  = {state with pos = stop}
-      and region = Region.make ~start ~stop in
-      let unit   = Markup.Newline Region.{region; value} in
-      let markup = unit :: state.markup
-      in {state with markup}
-
-    let push_line (thread, state) =
-      let start  = thread.opening#start in
-      let region = Region.make ~start ~stop:state.pos
-      and value  = mk_str thread.len thread.acc in
-      let unit   = Markup.LineCom Region.{region; value} in
-      let markup = unit :: state.markup
-      in {state with markup}
-
-    let push_block (thread, state) =
-      let start  = thread.opening#start in
-      let region = Region.make ~start ~stop:state.pos
-      and value  = mk_str thread.len thread.acc in
-      let unit   = Markup.BlockCom Region.{region; value} in
-      let markup = unit :: state.markup
-      in {state with markup}
-
-    let push_space state buffer =
-      let region, lex, state = sync state buffer in
-      let value  = String.length lex in
-      let unit   = Markup.Space Region.{region; value} in
-      let markup = unit :: state.markup
-      in {state with markup}
-
-    let push_tabs state buffer =
-      let region, lex, state = sync state buffer in
-      let value  = String.length lex in
-      let unit   = Markup.Tabs Region.{region; value} in
-      let markup = unit :: state.markup
-      in {state with markup}
-
-    let push_bom state buffer =
-      let region, value, state = sync state buffer in
-      let unit   = Markup.BOM Region.{region; value} in
-      let markup = unit :: state.markup
-      in {state with markup}
+    type line_comment = LexerLib.line_comment
+    type block_comment = LexerLib.block_comment
+    let mk_block = LexerLib.mk_block
 
     (* ERRORS *)
 
@@ -394,14 +101,14 @@ module Make (Token: TOKEN) : (S with module Token = Token) =
       Invalid_utf8_sequence
     | Unexpected_character of char
     | Undefined_escape_sequence
-    | Missing_break
+    (*    | Missing_break*)
     | Unterminated_string
-    | Unterminated_integer
-    | Odd_lengthed_bytes
+    (*    | Unterminated_integer*)
+    (*    | Odd_lengthed_bytes*)
     | Unterminated_comment of string
-    | Orphan_minus
+    (*    | Orphan_minus*)
     | Non_canonical_zero
-    | Negative_byte_sequence
+    (*    | Negative_byte_sequence *)
     | Broken_string
     | Invalid_character_in_string
     | Reserved_name of string
@@ -417,30 +124,30 @@ module Make (Token: TOKEN) : (S with module Token = Token) =
     | Undefined_escape_sequence ->
         "Undefined escape sequence.\n\
          Hint: Remove or replace the sequence."
-    | Missing_break ->
+(*    | Missing_break ->
         "Missing break.\n\
          Hint: Insert some space."
-    | Unterminated_string ->
+ *)    | Unterminated_string ->
         "Unterminated string.\n\
          Hint: Close with double quotes."
-    | Unterminated_integer ->
+(*    | Unterminated_integer ->
         "Unterminated integer.\n\
-         Hint: Remove the sign or proceed with a natural number."
-    | Odd_lengthed_bytes ->
+         Hint: Remove the sign or proceed with a natural number." *)
+(*    | Odd_lengthed_bytes ->
         "The length of the byte sequence is an odd number.\n\
          Hint: Add or remove a digit."
-    | Unterminated_comment ending ->
+ *)    | Unterminated_comment ending ->
         sprintf "Unterminated comment.\n\
                  Hint: Close with \"%s\"." ending
-    | Orphan_minus ->
+(*    | Orphan_minus ->
         "Orphan minus sign.\n\
-         Hint: Remove the trailing space."
+         Hint: Remove the trailing space." *)
     | Non_canonical_zero ->
         "Non-canonical zero.\n\
          Hint: Use 0."
-    | Negative_byte_sequence ->
+(*    | Negative_byte_sequence ->
         "Negative byte sequence.\n\
-         Hint: Remove the leading minus sign."
+         Hint: Remove the leading minus sign." *)
     | Broken_string ->
         "The string starting here is interrupted by a line break.\n\
          Hint: Remove the break, close the string before or insert a \
@@ -474,47 +181,47 @@ module Make (Token: TOKEN) : (S with module Token = Token) =
     (* Making tokens *)
 
     let mk_string (thread, state) =
-      let start  = thread.opening#start in
-      let stop   = state.pos in
+      let start  = thread#opening#start in
+      let stop   = state#pos in
       let region = Region.make ~start ~stop in
-      let lexeme = mk_str thread.len thread.acc in
+      let lexeme = thread#to_string in
       let token  = Token.mk_string lexeme region
-      in token, state
+      in state#enqueue token
 
     let mk_bytes bytes state buffer =
-      let region, _, state = sync state buffer in
+      let region, _, state = state#sync buffer in
       let token = Token.mk_bytes bytes region
-      in token, state
+      in state#enqueue token
 
     let mk_int state buffer =
-      let region, lexeme, state = sync state buffer in
+      let region, lexeme, state = state#sync buffer in
       match Token.mk_int lexeme region with
-        Ok token -> token, state
+        Ok token -> state#enqueue token
       | Error Token.Non_canonical_zero ->
           fail region Non_canonical_zero
 
     let mk_nat state buffer =
-      let region, lexeme, state = sync state buffer in
+      let region, lexeme, state = state#sync buffer in
       match Token.mk_nat lexeme region with
-        Ok token -> token, state
+        Ok token -> state#enqueue token
       | Error Token.Non_canonical_zero_nat ->
           fail region Non_canonical_zero
       | Error Token.Invalid_natural ->
           fail region Invalid_natural
 
     let mk_mutez state buffer =
-      let region, lexeme, state = sync state buffer in
+      let region, lexeme, state = state#sync buffer in
       match Token.mk_mutez lexeme region with
-        Ok token -> token, state
+        Ok token -> state#enqueue token
       | Error Token.Non_canonical_zero ->
           fail region Non_canonical_zero
 
     let mk_tez state buffer =
-      let region, lexeme, state = sync state buffer in
+      let region, lexeme, state = state#sync buffer in
       let lexeme = Str.string_before lexeme (String.index lexeme 't') in
       let lexeme = Z.mul (Z.of_int 1_000_000) (Z.of_string lexeme) in
       match Token.mk_mutez (Z.to_string lexeme ^ "mutez") region with
-        Ok token -> token, state
+        Ok token -> state#enqueue token
       | Error Token.Non_canonical_zero ->
           fail region Non_canonical_zero
 
@@ -533,44 +240,45 @@ module Make (Token: TOKEN) : (S with module Token = Token) =
       | exception Not_found -> assert false
 
     let mk_tez_decimal state buffer =
-      let region, lexeme, state = sync state buffer in
+      let region, lexeme, state = state#sync buffer in
       let lexeme = Str.(global_replace (regexp "_") "" lexeme) in
       let lexeme = Str.string_before lexeme (String.index lexeme 't') in
       match format_tez lexeme with
         None -> assert false
       | Some tz ->
           match Token.mk_mutez (Z.to_string tz ^ "mutez") region with
-            Ok token -> token, state
+            Ok token -> state#enqueue token
         | Error Token.Non_canonical_zero ->
             fail region Non_canonical_zero
 
     let mk_ident state buffer =
-      let region, lexeme, state = sync state buffer in
+      let region, lexeme, state = state#sync buffer in
       match Token.mk_ident lexeme region with
-        Ok token -> token, state
+        Ok token -> state#enqueue token
       | Error Token.Reserved_name -> fail region (Reserved_name lexeme)
 
     let mk_attr header attr state buffer =
-      let region, _, state = sync state buffer in
+      let region, _, state = state#sync buffer in
       match Token.mk_attr header attr region with
-        Ok token ->
-          token, state
+        Ok token -> state#enqueue token
       | Error Token.Invalid_attribute ->
           fail region Invalid_attribute
 
     let mk_constr state buffer =
-      let region, lexeme, state = sync state buffer
-      in Token.mk_constr lexeme region, state
+      let region, lexeme, state = state#sync buffer in
+      let token = Token.mk_constr lexeme region
+      in state#enqueue token
 
     let mk_sym state buffer =
-      let region, lexeme, state = sync state buffer in
+      let region, lexeme, state = state#sync buffer in
       match Token.mk_sym lexeme region with
-        Ok token -> token, state
+        Ok token -> state#enqueue token
       | Error Token.Invalid_symbol -> fail region Invalid_symbol
 
     let mk_eof state buffer =
-      let region, _, state = sync state buffer
-      in Token.eof region, state
+      let region, _, state = state#sync buffer in
+      let token = Token.eof region
+      in state#enqueue token
 
 (* END HEADER *)
 }
@@ -598,16 +306,47 @@ let bytes      = "0x" (byte_seq? as seq)
 let esc        = "\\n" | "\\\"" | "\\\\" | "\\b"
                | "\\r" | "\\t" | "\\x" byte
 
+(* Symbols *)
+
+let common_sym     =   ';' | ',' | '(' | ')'  | '[' | ']'  | '{' | '}'
+                     | '=' | ':' | '|' | "->" | '.' | '_'  | '^'
+                     | '+' | '-' | '*' | '/'  | '<' | "<=" | '>' | ">="
 let pascaligo_sym  = "=/=" | '#' | ":="
 let cameligo_sym   = "<>" | "::" | "||" | "&&"
 let reasonligo_sym = '!' | "=>" | "!=" | "==" | "++" | "..." | "||" | "&&"
 
-let symbol =
-  ';' | ',' | '(' | ')'| '[' | ']' | '{' | '}'
-| '=' | ':' | '|' | "->" | '.' | '_' | '^'
-| '+' | '-' | '*' | '/'
-| '<' | "<=" | '>' | ">="
-| pascaligo_sym | cameligo_sym | reasonligo_sym
+let symbol = common_sym | pascaligo_sym | cameligo_sym | reasonligo_sym
+
+(* Comments *)
+
+let pascaligo_block_comment_opening = "(*"
+let pascaligo_block_comment_closing = "*)"
+let pascaligo_line_comment          = "//"
+
+let cameligo_block_comment_opening = "(*"
+let cameligo_block_comment_closing = "*)"
+let cameligo_line_comment          = "//"
+
+let reasonligo_block_comment_opening = "/*"
+let reasonligo_block_comment_closing = "*/"
+let reasonligo_line_comment          = "//"
+
+let block_comment_openings =
+  pascaligo_block_comment_opening
+| cameligo_block_comment_opening
+| reasonligo_block_comment_opening
+
+let block_comment_closings =
+  pascaligo_block_comment_closing
+| cameligo_block_comment_closing
+| reasonligo_block_comment_closing
+
+let line_comments =
+  pascaligo_line_comment
+| cameligo_line_comment
+| reasonligo_line_comment
+
+(* #include files *)
 
 let string = [^'"' '\\' '\n']*  (* For strings of #include *)
 
@@ -618,56 +357,32 @@ let string = [^'"' '\\' '\n']*  (* For strings of #include *)
 
    All have a parameter [state] that they thread through their
    recursive calls. The rules for the structured constructs (strings
-   and comments) have an extra parameter of type [thread] (see above).
-*)
+   and comments) have an extra parameter of type [thread] to record
+   the location where they start, and their contents (see above).
+ *)
 
 rule init state = parse
-  utf8_bom { scan (push_bom state lexbuf) lexbuf }
-| _        { rollback lexbuf; scan state lexbuf  }
+  utf8_bom { scan (state#push_bom lexbuf) lexbuf          }
+| _        { LexerLib.rollback lexbuf; scan state lexbuf  }
 
 and scan state = parse
-  nl                     { scan (push_newline state lexbuf) lexbuf }
-| ' '+                   { scan (push_space   state lexbuf) lexbuf }
-| '\t'+                  { scan (push_tabs    state lexbuf) lexbuf }
-| ident                  { mk_ident        state lexbuf |> enqueue  }
-| constr                 { mk_constr       state lexbuf |> enqueue  }
-| bytes                  { mk_bytes seq    state lexbuf |> enqueue  }
-| natural 'n'            { mk_nat          state lexbuf |> enqueue  }
-| natural "mutez"        { mk_mutez        state lexbuf |> enqueue  }
+  nl                     { scan (state#push_newline lexbuf) lexbuf }
+| ' '+                   { scan (state#push_space   lexbuf) lexbuf }
+| '\t'+                  { scan (state#push_tabs    lexbuf) lexbuf }
+| ident                  { mk_ident        state lexbuf }
+| constr                 { mk_constr       state lexbuf }
+| bytes                  { mk_bytes seq    state lexbuf }
+| natural 'n'            { mk_nat          state lexbuf }
+| natural "mutez"        { mk_mutez        state lexbuf }
 | natural "tz"
-| natural "tez"          { mk_tez          state lexbuf |> enqueue  }
+| natural "tez"          { mk_tez          state lexbuf }
 | decimal "tz"
-| decimal "tez"          { mk_tez_decimal  state lexbuf |> enqueue  }
-| natural                { mk_int          state lexbuf |> enqueue  }
-| symbol                 { mk_sym          state lexbuf |> enqueue  }
-| eof                    { mk_eof          state lexbuf |> enqueue  }
-| "[@"  (attr as a) "]"  { mk_attr "[@"  a state lexbuf |> enqueue  }
-| "[@@" (attr as a) "]"  { mk_attr "[@@" a state lexbuf |> enqueue  }
-
-| '"'  { let opening, _, state = sync state lexbuf in
-         let thread = {opening; len=1; acc=['"']} in
-         scan_string thread state lexbuf |> mk_string |> enqueue }
-
-| "(*" { if state.lang = `PascaLIGO || state.lang = `CameLIGO then
-           let opening, _, state = sync state lexbuf in
-           let thread = {opening; len=2; acc=['*';'(']} in
-           let state  = scan_pascaligo_block thread state lexbuf |> push_block
-           in scan state lexbuf
-         else (rollback lexbuf; scan_two_sym state lexbuf)
-       }
-
-| "/*" { if state.lang = `ReasonLIGO then
-           let opening, _, state = sync state lexbuf in
-           let thread = {opening; len=2; acc=['*';'/']} in
-           let state  = scan_reasonligo_block thread state lexbuf |> push_block
-           in scan state lexbuf
-         else (rollback lexbuf; scan_two_sym state lexbuf)
-       }
-
-| "//" { let opening, _, state = sync state lexbuf in
-         let thread = {opening; len=2; acc=['/';'/']} in
-         let state  = scan_line thread state lexbuf |> push_line
-         in scan state lexbuf }
+| decimal "tez"          { mk_tez_decimal  state lexbuf }
+| natural                { mk_int          state lexbuf }
+| symbol                 { mk_sym          state lexbuf }
+| eof                    { mk_eof          state lexbuf }
+| "[@"  (attr as a) "]"  { mk_attr "[@"  a state lexbuf }
+| "[@@" (attr as a) "]"  { mk_attr "[@@" a state lexbuf }
 
   (* Management of #include preprocessing directives
 
@@ -695,191 +410,211 @@ and scan state = parse
     processed).
    *)
 
-| '#' blank* ("line" blank+)? (natural as line) blank+
-    '"' (string as file) '"' {
-    let  _, _, state = sync state lexbuf in
+| '#' blank* (natural as line) blank+ '"' (string as file) '"' {
+    let  _, _, state = state#sync lexbuf in
     let flags, state = scan_flags state [] lexbuf in
     let           () = ignore flags in
     let line         = int_of_string line
     and file         = Filename.basename file in
-    let pos          = state.pos#set ~file ~line ~offset:0 in
-    let state        = {state with pos} in
+    let pos          = state#pos#set ~file ~line ~offset:0 in
+    let state        = state#set_pos pos in
     scan state lexbuf }
 
-  (* Some special errors
+(* Some special errors *)
 
-     Some special errors are recognised in the semantic actions of the
-     following regular expressions. The first error is a minus sign
-     separated from the integer it applies to by some markup (space or
-     tabs). The second is a minus sign immediately followed by
-     anything else than a natural number (matched above) or markup and
-     a number (previous error). The third is the strange occurrence of
-     an attempt at defining a negative byte sequence. Finally, the
-     catch-all rule reports unexpected characters in the buffer (and
-     is not so special, after all).
-  *)
-
-| '-' { let region, _, state = sync state lexbuf in
+(*
+| '-' { let region, _, state = state#sync lexbuf in
         let state = scan state lexbuf in
         let open Markup in
-        match FQueue.peek state.units with
+        match FQueue.peek state#units with
           None -> assert false
         | Some (_, ((Space _ | Tabs _)::_, token))
-            when Token.is_int token ->
-              fail region Orphan_minus
+            when Token.is_int token -> fail region Orphan_minus
         | _ -> fail region Unterminated_integer }
 
 | "-0x" byte_seq?
-      { let region, _, _ = sync state lexbuf
+      { let region, _, _ = state#sync lexbuf
         in fail region Negative_byte_sequence }
+ *)
 
-| _ as c { let region, _, _ = sync state lexbuf
+| '"' { let opening, lexeme, state = state#sync lexbuf in
+        let thread = LexerLib.mk_thread opening lexeme in
+        scan_string thread state lexbuf |> mk_string }
+
+| block_comment_openings {
+    let lexeme = Lexing.lexeme lexbuf in
+    match state#block with
+      Some block when block#opening = lexeme ->
+        let opening, _, state = state#sync lexbuf in
+        let thread            = LexerLib.mk_thread opening lexeme in
+        let thread, state     = scan_block block thread state lexbuf in
+        let state             = state#push_block thread
+        in scan state lexbuf
+    | Some _ | None ->
+        let n = String.length lexeme in
+          begin
+            LexerLib.rollback lexbuf;
+            assert (n > 0);
+            scan (scan_n_sym n state lexbuf) lexbuf
+          end }
+
+| line_comments {
+    let lexeme = Lexing.lexeme lexbuf in
+    match state#line with
+      Some line when line = lexeme ->
+        let opening, _, state = state#sync lexbuf in
+        let thread            = LexerLib.mk_thread opening lexeme in
+        let thread, state     = scan_line thread state lexbuf in
+        let state             = state#push_line thread
+        in scan state lexbuf
+    | Some _ | None ->
+        let n = String.length lexeme in
+          begin
+            LexerLib.rollback lexbuf;
+            scan (scan_n_sym n state lexbuf) lexbuf
+          end }
+
+| _ as c { let region, _, _ = state#sync lexbuf
            in fail region (Unexpected_character c) }
 
-(* Scanning two symbols *)
+(* Scanning a series of symbols *)
 
-and scan_two_sym state = parse
-  symbol { scan_one_sym (mk_sym state lexbuf |> enqueue) lexbuf }
+and scan_n_sym n state = parse
+  symbol { let state = mk_sym state lexbuf in
+           if n = 1 then state
+           else scan_n_sym (n-1) state lexbuf }
 
-and scan_one_sym state = parse
-  symbol { scan (mk_sym state lexbuf |> enqueue) lexbuf }
-
-(* Scanning CPP #include flags *)
+(* Scanning #include flag *)
 
 and scan_flags state acc = parse
-  blank+          { let _, _, state = sync state lexbuf
+  blank+          { let _, _, state = state#sync lexbuf
                     in scan_flags state acc lexbuf          }
-| natural as code { let _, _, state = sync state lexbuf in
+| natural as code { let _, _, state = state#sync lexbuf in
                     let acc = int_of_string code :: acc
                     in scan_flags state acc lexbuf          }
-| nl              { List.rev acc, push_newline state lexbuf }
-| eof             { let _, _, state = sync state lexbuf
-                    in List.rev acc, state       (* TODO *) }
+| nl              { List.rev acc, state#push_newline lexbuf }
+| eof             { let _, _, state = state#sync lexbuf
+                    in List.rev acc, state                  }
+
+(* TODO: Move below to [LexerCommon.mll] *)
 
 (* Finishing a string *)
 
 and scan_string thread state = parse
-  nl         { fail thread.opening Broken_string }
-| eof        { fail thread.opening Unterminated_string }
+  nl     { fail thread#opening Broken_string }
+| eof    { fail thread#opening Unterminated_string }
 | ['\t' '\r' '\b']
-             { let region, _, _ = sync state lexbuf
-               in fail region Invalid_character_in_string }
-| '"'        { let _, _, state = sync state lexbuf
-               in push_char '"' thread, state }
-| esc        { let _, lexeme, state = sync state lexbuf
-               in scan_string (push_string lexeme thread) state lexbuf }
-| '\\' _     { let region, _, _ = sync state lexbuf
-               in fail region Undefined_escape_sequence }
-| _ as c     { let _, _, state = sync state lexbuf in
-               scan_string (push_char c thread) state lexbuf }
+         { let region, _, _ = state#sync lexbuf
+           in fail region Invalid_character_in_string }
+| '"'    { let _, _, state = state#sync lexbuf
+           in thread#push_char '"', state }
+| esc    { let _, lexeme, state = state#sync lexbuf in
+           let thread = thread#push_string lexeme
+           in scan_string thread state lexbuf }
+| '\\' _ { let region, _, _ = state#sync lexbuf
+           in fail region Undefined_escape_sequence }
+| _ as c { let _, _, state = state#sync lexbuf in
+           scan_string (thread#push_char c) state lexbuf }
 
 (* Finishing a block comment
 
    (For Emacs: ("(*") The lexing of block comments must take care of
    embedded block comments that may occur within, as well as strings,
    so no substring "*/" or "*)" may inadvertently close the
-   block. This is the purpose of the first case of the scanners
-   [scan_pascaligo_block] and [scan_reasonligo_block].
+   block. This is the purpose of the first case of the scanner
+   [scan_block].
 *)
 
-and scan_pascaligo_block thread state = parse
-  '"' | "(*" { let opening = thread.opening in
-               let opening', lexeme, state = sync state lexbuf in
-               let thread = push_string lexeme thread in
-               let thread = {thread with opening=opening'} in
-               let next   = if lexeme = "\"" then scan_string
-                            else scan_pascaligo_block in
-               let thread, state = next thread state lexbuf in
-               let thread = {thread with opening}
-               in scan_pascaligo_block thread state lexbuf }
-| "*)"       { let _, lexeme, state = sync state lexbuf
-               in push_string lexeme thread, state }
-| nl as nl   { let ()     = Lexing.new_line lexbuf
-               and state  = {state with pos = state.pos#new_line nl}
-               and thread = push_string nl thread
-               in scan_pascaligo_block thread state lexbuf }
-| eof        { fail thread.opening (Unterminated_comment "*)") }
-| _          { let ()     = rollback lexbuf in
-               let len    = thread.len in
-               let thread,
-                   status = scan_utf8 "*)" thread state lexbuf in
-               let delta  = thread.len - len in
-               let pos    = state.pos#shift_one_uchar delta in
-               match status with
-                 Stdlib.Ok () ->
-                   scan_pascaligo_block thread {state with pos} lexbuf
-               | Error error ->
-                   let region = Region.make ~start:state.pos ~stop:pos
-                   in fail region error }
+and scan_block block thread state = parse
+  '"' | block_comment_openings {
+    let lexeme = Lexing.lexeme lexbuf in
+    if   block#opening = lexeme || lexeme = "\""
+    then let opening            = thread#opening in
+         let opening', _, state = state#sync lexbuf in
+         let thread             = thread#push_string lexeme in
+         let thread             = thread#set_opening opening' in
+         let next               = if lexeme = "\"" then scan_string
+                                  else scan_block block in
+         let thread, state      = next thread state lexbuf in
+         let thread             = thread#set_opening opening
+         in scan_block block thread state lexbuf
+    else let ()    = LexerLib.rollback lexbuf in
+         let n     = String.length lexeme in
+         let ()    = assert (n > 0) in
+         let state = scan_n_sym n state lexbuf
+         in scan_block block thread state lexbuf }
 
-and scan_reasonligo_block thread state = parse
-  '"' | "/*" { let opening = thread.opening in
-               let opening', lexeme, state = sync state lexbuf in
-               let thread = push_string lexeme thread in
-               let thread = {thread with opening=opening'} in
-               let next   = if lexeme = "\"" then scan_string
-                            else scan_reasonligo_block in
-               let thread, state = next thread state lexbuf in
-               let thread = {thread with opening}
-               in scan_reasonligo_block thread state lexbuf }
-| "*/"       { let _, lexeme, state = sync state lexbuf
-               in push_string lexeme thread, state }
-| nl as nl   { let ()     = Lexing.new_line lexbuf
-               and state  = {state with pos = state.pos#new_line nl}
-               and thread = push_string nl thread
-               in scan_reasonligo_block thread state lexbuf }
-| eof        { fail thread.opening (Unterminated_comment "*/") }
-| _          { let ()     = rollback lexbuf in
-               let len    = thread.len in
-               let thread,
-                   status = scan_utf8 "*/" thread state lexbuf in
-               let delta  = thread.len - len in
-               let pos    = state.pos#shift_one_uchar delta in
-               match status with
-                 Stdlib.Ok () ->
-                   scan_reasonligo_block thread {state with pos} lexbuf
-               | Error error ->
-                   let region = Region.make ~start:state.pos ~stop:pos
-                   in fail region error }
+| block_comment_closings {
+    let lexeme = Lexing.lexeme lexbuf in
+    if   block#closing = lexeme
+    then let _, _, state = state#sync lexbuf
+         in thread#push_string lexeme, state
+    else let ()    = LexerLib.rollback lexbuf in
+         let n     = String.length lexeme in
+         let ()    = assert (n > 0) in
+         let state = scan_n_sym n state lexbuf
+         in scan_block block thread state lexbuf }
+
+| nl as nl {
+    let ()     = Lexing.new_line lexbuf
+    and state  = state#set_pos (state#pos#new_line nl)
+    and thread = thread#push_string nl in
+    scan_block block thread state lexbuf }
+
+| eof { let err = Unterminated_comment (block#closing)
+        in fail thread#opening err }
+
+| _   { let ()             = LexerLib.rollback lexbuf in
+        let len            = thread#length in
+        let thread, status = scan_utf8 block thread state lexbuf in
+        let delta          = thread#length - len in
+        let pos            = state#pos#shift_one_uchar delta in
+        match status with
+          Stdlib.Ok () ->
+            scan_block block thread (state#set_pos pos) lexbuf
+        | Error error ->
+            let region = Region.make ~start:state#pos ~stop:pos
+            in fail region error }
 
 (* Finishing a line comment *)
 
 and scan_line thread state = parse
   nl as nl { let     () = Lexing.new_line lexbuf
-             and thread = push_string nl thread
-             and state  = {state with pos = state.pos#new_line nl}
+             and thread = thread#push_string nl
+             and state  = state#set_pos (state#pos#new_line nl)
              in thread, state }
 | eof      { thread, state }
-| _        { let     () = rollback lexbuf in
-             let len    = thread.len in
+| _        { let     () = LexerLib.rollback lexbuf in
+             let len    = thread#length in
              let thread,
                  status = scan_utf8_inline thread state lexbuf in
-             let delta  = thread.len - len in
-             let pos    = state.pos#shift_one_uchar delta in
+             let delta  = thread#length - len in
+             let pos    = state#pos#shift_one_uchar delta in
              match status with
                Stdlib.Ok () ->
-                 scan_line thread {state with pos} lexbuf
+                 scan_line thread (state#set_pos pos) lexbuf
              | Error error ->
-                 let region = Region.make ~start:state.pos ~stop:pos
+                 let region = Region.make ~start:state#pos ~stop:pos
                  in fail region error }
 
-and scan_utf8 closing thread state = parse
-     eof { fail thread.opening (Unterminated_comment closing) }
-| _ as c { let thread = push_char c thread in
+and scan_utf8 block thread state = parse
+     eof { let err = Unterminated_comment block#closing
+           in fail thread#opening err }
+| _ as c { let thread = thread#push_char c in
            let lexeme = Lexing.lexeme lexbuf in
-           let () = state.supply (Bytes.of_string lexeme) 0 1 in
-           match Uutf.decode state.decoder with
+           let () = state#supply (Bytes.of_string lexeme) 0 1 in
+           match Uutf.decode state#decoder with
              `Uchar _     -> thread, Stdlib.Ok ()
            | `Malformed _ -> thread, Stdlib.Error Invalid_utf8_sequence
-           | `Await       -> scan_utf8 closing thread state lexbuf
+           | `Await       -> scan_utf8 block thread state lexbuf
            | `End         -> assert false }
 
 and scan_utf8_inline thread state = parse
      eof { thread, Stdlib.Ok () }
-| _ as c { let thread = push_char c thread in
+| _ as c { let thread = thread#push_char c in
            let lexeme = Lexing.lexeme lexbuf in
-           let () = state.supply (Bytes.of_string lexeme) 0 1 in
-           match Uutf.decode state.decoder with
+           let () = state#supply (Bytes.of_string lexeme) 0 1 in
+           match Uutf.decode state#decoder with
              `Uchar _     -> thread, Stdlib.Ok ()
            | `Malformed _ -> thread, Stdlib.Error Invalid_utf8_sequence
            | `Await       -> scan_utf8_inline thread state lexbuf
@@ -890,6 +625,7 @@ and scan_utf8_inline thread state = parse
 {
 (* START TRAILER *)
 
+
 (* Scanning the lexing buffer for tokens (and markup, as a
    side-effect).
 
@@ -946,7 +682,7 @@ type instance = {
   input    : input;
   read     : log:logger -> Lexing.lexbuf -> token;
   buffer   : Lexing.lexbuf;
-  get_win  : unit -> window;
+  get_win  : unit -> token LexerLib.window;
   get_pos  : unit -> Pos.t;
   get_last : unit -> Region.t;
   get_file : unit -> file_path;
@@ -963,7 +699,7 @@ let lexbuf_from_input = function
       let lexbuf = Lexing.from_channel chan in
       let () =
         let open Lexing in
-        lexbuf.lex_curr_p <- {lexbuf.lex_curr_p with pos_fname = path}
+        lexbuf.lex_curr_p <- {lexbuf.lex_curr_p with pos_fname=path}
       in Ok (lexbuf, close)
     with Sys_error msg -> Stdlib.Error (File_opening msg))
 | String s ->
@@ -973,7 +709,7 @@ let lexbuf_from_input = function
     Ok (Lexing.from_channel chan, close)
 | Buffer b -> Ok (b, fun () -> ())
 
-let open_token_stream (lang: language) input =
+let open_token_stream ?line ?block input =
   let file_path  = match input with
                      File path -> path
                    | _ -> "" in
@@ -982,18 +718,21 @@ let open_token_stream (lang: language) input =
   and first_call = ref true
   and    decoder = Uutf.decoder ~encoding:`UTF_8 `Manual in
   let     supply = Uutf.Manual.src decoder in
-  let      state = ref {units = FQueue.empty;
-                        last = Region.ghost;
-                        window = Nil;
-                        pos;
-                        markup = [];
-                        decoder;
-                        supply;
-                        lang} in
+  let      state = ref (LexerLib.mk_state
+                          ~units:FQueue.empty
+                          ~last:Region.ghost
+                          ~window:LexerLib.Nil
+                          ~pos
+                          ~markup:[]
+                          ~decoder
+                          ~supply
+                          ?block
+                          ?line
+                          ()) in
 
-  let get_pos  () = !state.pos
-  and get_last () = !state.last
-  and get_win  () = !state.window
+  let get_pos  () = !state#pos
+  and get_last () = !state#last
+  and get_win  () = !state#window
   and get_file () = file_path in
 
   let patch_buffer (start, stop) buffer =
@@ -1014,54 +753,29 @@ let open_token_stream (lang: language) input =
 
   let next_token buffer =
     scan buffer;
-    match FQueue.peek !state.units with
-                         None -> assert false
+    match FQueue.peek !state#units with
+                         None -> None
     | Some (units, ext_token) ->
-        state := {!state with units}; Some ext_token in
-
-  let check_right_context token buffer =
-    let open Token in
-    if is_int token || is_bytes token then
-      match next_token buffer with
-        Some ([], next) ->
-          let pos    = (Token.to_region token)#stop in
-          let region = Region.make ~start:pos ~stop:pos in
-          if is_int next then
-            fail region Odd_lengthed_bytes
-          else
-          if is_ident next || is_string next || is_bytes next then
-            fail region Missing_break
-      | _ -> ()
-    else
-    if is_ident token || is_string token then
-      match next_token buffer with
-        Some ([], next) ->
-          if is_ident next || is_string next
-             || is_bytes next || is_int next
-          then
-            let pos    = (Token.to_region token)#stop in
-            let region = Region.make ~start:pos ~stop:pos
-            in fail region Missing_break
-      | _ -> () in
+        state := !state#set_units units; Some ext_token in
 
   let rec read ~log buffer =
-    match FQueue.deq !state.units with
+    match FQueue.deq !state#units with
       None ->
         scan buffer;
         read ~log buffer
     | Some (units, (left_mark, token)) ->
         log left_mark token;
-        state := {!state with units;
-                              last = Token.to_region token;
-                              window = slide token !state.window};
-        check_right_context token buffer;
+        state := ((!state#set_units units)
+                  #set_last (Token.to_region token))
+                  #slide_token token;
+        Token.check_right_context token next_token buffer;
         patch_buffer (Token.to_region token)#byte_pos buffer;
         token in
   match lexbuf_from_input input with
     Ok (buffer, close) ->
       let () =
         match input with
-          File path when path <> "" -> reset ~file:path buffer
+          File path when path <> "" -> LexerLib.reset ~file:path buffer
         | _ -> () in
       let instance = {
         input; read; buffer; get_win; get_pos; get_last; get_file; close}
diff --git a/src/passes/1-parser/shared/LexerLib.ml b/src/passes/1-parser/shared/LexerLib.ml
new file mode 100644
index 000000000..48ff79dfe
--- /dev/null
+++ b/src/passes/1-parser/shared/LexerLib.ml
@@ -0,0 +1,451 @@
+(* Sliding window *)
+
+(* The type [window] models a two-slot buffer of tokens for reporting
+   after a parse error. Technically, it is a parametric type, but its
+   use is meant for tokens, wherever they are defined.
+
+   In [Two(t1,t2)], the token [t2] is the next to be sent to the
+   parser.
+
+   The call [slide token buffer] pushes the token [token] in the
+   buffer [buffer]. If the buffer is full, that is, it is
+   [Two(t1,t2)], then the token [t2] is discarded to make room for
+   [token].
+ *)
+
+type 'a window =
+  Nil
+| One of 'a
+| Two of 'a * 'a
+
+let slide token = function
+  Nil -> One token
+| One t | Two (t,_) -> Two (token,t)
+
+module Region = Simple_utils.Region
+module Pos = Simple_utils.Pos
+
+type lexeme = string
+
+(* The signature [TOKEN] exports an abstract type [token], so a lexer
+   can be a functor over tokens. This enables to externalise
+   version-dependent constraints in any module whose signature matches
+   [TOKEN]. Generic functions to construct tokens are required.
+
+   Note the predicate [is_eof], which caracterises the virtual token
+   for end-of-file, because it requires special handling.
+*)
+
+module type TOKEN =
+  sig
+    type token
+
+    (* Predicates *)
+
+    val is_eof : token -> bool
+
+    (* Projections *)
+
+    val to_lexeme : token -> lexeme
+    val to_string : token -> ?offsets:bool -> [`Byte | `Point] -> string
+    val to_region : token -> Region.t
+
+    (* Style *)
+
+    type error
+
+    val error_to_string : error -> string
+
+    exception Error of error Region.reg
+
+    val format_error :
+      ?offsets:bool ->
+      [`Byte | `Point] ->
+      error Region.reg ->
+      file:bool ->
+      string Region.reg
+
+    val check_right_context :
+      token ->
+      (Lexing.lexbuf -> (Markup.t list * token) option) ->
+      Lexing.lexbuf ->
+      unit
+  end
+
+(* The module type for lexers is [S]. It mainly exports the function
+   [open_token_stream], which returns
+
+     * a function [read] that extracts tokens from a lexing buffer,
+       together with a lexing buffer [buffer] to read from,
+     * a function [close] that closes that buffer,
+     * a function [get_pos] that returns the current position, and
+     * a function [get_last] that returns the region of the last
+       recognised token.
+     * a function [get_file] that returns the name of the file being
+       scanned (empty string if [stdin]).
+
+   Note that a module [Token] is exported too, because the signature
+   of the exported functions depend on it.
+
+     The type [window] is a two-token window, that is, a buffer that
+   contains the last recognised token, and the penultimate (if any).
+
+     The call [read ~log] evaluates in a lexer (also known as a
+   tokeniser or scanner) whose type is [Lexing.lexbuf -> token], and
+   suitable for a parser generated by Menhir. The argument labelled
+   [log] is a logger, that is, it may print a token and its left
+   markup to a given channel, at the caller's discretion.
+*)
+
+module type S =
+  sig
+    module Token : TOKEN
+    type token = Token.token
+
+    type file_path = string
+    type logger = Markup.t list -> token -> unit
+
+    type input =
+      File    of file_path
+    | String  of string
+    | Channel of in_channel
+    | Buffer  of Lexing.lexbuf
+
+    type instance = {
+      input    : input;
+      read     : log:logger -> Lexing.lexbuf -> token;
+      buffer   : Lexing.lexbuf;
+      get_win  : unit -> token window;
+      get_pos  : unit -> Pos.t;
+      get_last : unit -> Region.t;
+      get_file : unit -> file_path;
+      close    : unit -> unit
+    }
+
+    type open_err = File_opening of string
+
+    val lexbuf_from_input :
+      input -> (Lexing.lexbuf * (unit -> unit), open_err) Stdlib.result
+
+    type line_comment = string (* Opening of a line comment *)
+    type block_comment = <opening : string; closing : string>
+
+    val mk_block : opening:string -> closing:string -> block_comment
+
+    val open_token_stream :
+      ?line:line_comment ->
+      ?block:block_comment ->
+      input ->
+      (instance, open_err) Stdlib.result
+
+    (* Error reporting *)
+
+    type error
+
+    val error_to_string : error -> string
+
+    exception Error of error Region.reg
+
+    val format_error :
+      ?offsets:bool ->
+      [`Byte | `Point] ->
+      error Region.reg ->
+      file:bool ->
+      string Region.reg
+  end
+
+(* LEXER ENGINE *)
+
+(* Resetting file name and line number in the lexing buffer
+
+   The call [reset ~file ~line buffer] modifies in-place the lexing
+   buffer [buffer] so the lexing engine records that the file
+   associated with [buffer] is named [file], and the current line is
+   [line]. This function is useful when lexing a file that has been
+   previously preprocessed by the C preprocessor, in which case the
+   argument [file] is the name of the file that was preprocessed,
+   _not_ the preprocessed file (of which the user is not normally
+   aware). By default, the [line] argument is [1].
+ *)
+
+let reset_file ~file buffer =
+  let open Lexing in
+  buffer.lex_curr_p <- {buffer.lex_curr_p with pos_fname = file}
+
+let reset_line ~line buffer =
+  assert (line >= 0);
+  let open Lexing in
+  buffer.lex_curr_p <- {buffer.lex_curr_p with pos_lnum = line}
+
+let reset_offset ~offset buffer =
+  assert (offset >= 0);
+  let open Lexing in
+  let bol = buffer.lex_curr_p.pos_bol in
+  buffer.lex_curr_p <- {buffer.lex_curr_p with pos_cnum = bol + offset }
+
+let reset ?file ?line ?offset buffer =
+  let () =
+    match file with
+      Some file -> reset_file ~file buffer
+    |      None -> () in
+  let () =
+    match line with
+      Some line -> reset_line ~line buffer
+    |      None -> () in
+  match offset with
+    Some offset -> reset_offset ~offset buffer
+  |        None -> ()
+
+(* Rolling back one lexeme _within the current semantic action_ *)
+
+let rollback buffer =
+  let open Lexing in
+  let len = String.length (lexeme buffer) in
+  let pos_cnum = buffer.lex_curr_p.pos_cnum - len in
+  buffer.lex_curr_pos <- buffer.lex_curr_pos - len;
+  buffer.lex_curr_p <- {buffer.lex_curr_p with pos_cnum}
+
+(* THREAD FOR STRUCTURED CONSTRUCTS (STRINGS, COMMENTS) *)
+
+(* When scanning structured constructs, like strings and comments, we
+   need to keep the region of the opening symbol (like double quote,
+   "//" or "(*") in order to report any error more precisely. Since
+   ocamllex is byte-oriented, we need to store the parsed bytes as
+   characters in an accumulator [acc] and also its length [len], so,
+   we are done, it is easy to build the string making up the
+   structured construct with [mk_str] (see above).
+
+     The resulting data structure is called a _thread_. (Note for
+   Emacs: "*)".)
+*)
+
+type thread = <
+  opening : Region.t;
+  length  : int;
+  acc     : char list;
+  push_char : char -> thread;
+  push_string : string -> thread;
+  to_string : string;
+  set_opening : Region.t -> thread
+>
+
+let mk_thread region lexeme : thread =
+  (* The call [explode s a] is the list made by pushing the characters
+     in the string [s] on top of [a], in reverse order. For example,
+     [explode "ba" ['c';'d'] = ['a'; 'b'; 'c'; 'd']]. *)
+  let explode s acc =
+    let rec push = function
+      0 -> acc
+    | i -> s.[i-1] :: push (i-1)
+    in push (String.length s)
+  in
+  object
+    val opening = region
+    method opening = opening
+
+    val length = String.length lexeme
+    method length = length
+
+    val acc = explode lexeme []
+    method acc = acc
+
+    method set_opening opening = {< opening; length; acc >}
+
+    method push_char char =
+      {< opening; length=length+1; acc=char::acc >}
+
+    method push_string str =
+      {< opening;
+         length = length + String.length str;
+         acc = explode str acc >}
+
+    (* The value of [thread#to_string] is a string of length
+       [thread#length] containing the [thread#length] characters in
+       the list [thread#acc], in reverse order. For instance,
+       [thread#to_string = "abc"] if [thread#length = 3] and
+       [thread#acc = ['c';'b';'a']]. *)
+
+    method to_string =
+      let bytes = Bytes.make length ' ' in
+      let rec fill i = function
+             [] -> bytes
+      | char::l -> Bytes.set bytes i char; fill (i-1) l
+      in fill (length-1) acc |> Bytes.to_string
+  end
+
+type file_path = string
+
+    (* STATE *)
+
+    (* Beyond tokens, the result of lexing is a state. The type
+       [state] represents the logical state of the lexing engine, that
+       is, a value which is threaded during scanning and which denotes
+       useful, high-level information beyond what the type
+       [Lexing.lexbuf] in the standard library already provides for
+       all generic lexers.
+
+         Tokens are the smallest units used by the parser to build the
+       abstract syntax tree. The state includes a queue of recognised
+       tokens, with the markup at the left of its lexeme until either
+       the start of the file or the end of the previously recognised
+       token.
+
+         The markup from the last recognised token or, if the first
+       token has not been recognised yet, from the beginning of the
+       file is stored in the field [markup] of the state because it is
+       a side-effect, with respect to the output token list, and we
+       use a record with a single field [units] because that record
+       may be easily extended during the future maintenance of this
+       lexer.
+
+         The state also includes a field [pos] which holds the current
+       position in the LIGO source file. The position is not always
+       updated after a single character has been matched: that depends
+       on the regular expression that matched the lexing buffer.
+
+         The field [window] is a two-token window, that is, a buffer
+       that contains the last recognised token, and the penultimate
+       (if any).
+
+         The fields [decoder] and [supply] offer the support needed
+       for the lexing of UTF-8 encoded characters in comments (the
+       only place where they are allowed in LIGO). The former is the
+       decoder proper and the latter is the effectful function
+       [supply] that takes a byte, a start index and a length and feed
+       it to [decoder]. See the documentation of the third-party
+       library Uutf.
+     *)
+
+    type line_comment  = string (* Opening of a line comment *)
+    type block_comment = <opening : string; closing : string>
+
+    let mk_block ~opening ~closing : block_comment =
+      object
+        method opening = opening
+        method closing = closing
+      end
+
+    type 'a state = <
+      units   : (Markup.t list * 'a) FQueue.t;
+      markup  : Markup.t list;
+      window  : 'a window;
+      last    : Region.t;
+      pos     : Pos.t;
+      decoder : Uutf.decoder;
+      supply  : Bytes.t -> int -> int -> unit;
+      block   : block_comment option;
+      line    : line_comment option;
+
+      enqueue      : 'a -> 'a state;
+      set_units    : (Markup.t list * 'a) FQueue.t -> 'a state;
+      set_last     : Region.t -> 'a state;
+      set_pos      : Pos.t -> 'a state;
+      slide_token  : 'a -> 'a state;
+
+      sync         : Lexing.lexbuf -> Region.t * lexeme * 'a state;
+
+      push_newline : Lexing.lexbuf -> 'a state;
+      push_line    : thread -> 'a state;
+      push_block   : thread -> 'a state;
+      push_space   : Lexing.lexbuf -> 'a state;
+      push_tabs    : Lexing.lexbuf -> 'a state;
+      push_bom     : Lexing.lexbuf -> 'a state;
+      push_markup  : Markup.t -> 'a state;
+    >
+
+    let mk_state ~units ~markup ~window ~last ~pos ~decoder ~supply
+                 ?block ?line () : _ state =
+      object (self)
+        val units = units
+        method units = units
+        val markup = markup
+        method markup = markup
+        val window = window
+        method window = window
+        val last = last
+        method last = last
+        val pos = pos
+        method pos = pos
+        method decoder = decoder
+        method supply = supply
+        method block = block
+        method line = line
+
+        (* The call [enqueue (token, state)] updates functionally the
+           state [state] by associating the token [token] with the
+           stored markup and enqueuing the pair into the units
+           queue. The field [markup] is then reset to the empty
+           list. *)
+
+        method enqueue token =
+          {< units  = FQueue.enq (markup, token) units;
+             markup = [] >}
+
+        method set_units units = {< units = units >}
+        method set_last region = {< last = region >}
+        method set_pos pos = {< pos = pos >}
+
+        method slide_token token =
+          {< window = slide token window >}
+
+        (* The call [sync state buffer] updates the current position
+           in accordance with the contents of the lexing buffer, more
+           precisely, depending on the length of the string which has
+           just been recognised by the scanner: that length is used as
+           a positive offset to the current column. *)
+
+        method sync buffer =
+          let lex   = Lexing.lexeme buffer in
+          let len   = String.length lex in
+          let start = pos in
+          let stop  = start#shift_bytes len in
+          let state = {< pos = stop >}
+          in Region.make ~start ~stop, lex, state
+
+        (* MARKUP *)
+
+        (* Committing markup to the current logical state *)
+
+        method push_markup unit = {< markup = unit :: markup >}
+
+        method push_newline buffer =
+          let ()     = Lexing.new_line buffer in
+          let value  = Lexing.lexeme buffer in
+          let start  = self#pos in
+          let stop   = start#new_line value in
+          let region = Region.make ~start ~stop in
+          let unit   = Markup.Newline Region.{region; value}
+          in {< pos = stop; markup = unit::markup >}
+
+        method push_line thread =
+          let start  = thread#opening#start in
+          let region = Region.make ~start ~stop:self#pos
+          and value  = thread#to_string in
+          let unit   = Markup.LineCom Region.{region; value}
+          in {< markup = unit::markup >}
+
+        method push_block thread =
+          let start  = thread#opening#start in
+          let region = Region.make ~start ~stop:self#pos
+          and value  = thread#to_string in
+          let unit   = Markup.BlockCom Region.{region; value}
+          in {< markup = unit::markup >}
+
+        method push_space buffer =
+          let region, lex, state = self#sync buffer in
+          let value  = String.length lex in
+          let unit   = Markup.Space Region.{region; value}
+          in state#push_markup unit
+
+        method push_tabs buffer =
+          let region, lex, state = self#sync buffer in
+          let value  = String.length lex in
+          let unit   = Markup.Tabs Region.{region; value}
+          in state#push_markup unit
+
+        method push_bom buffer =
+          let region, value, state = self#sync buffer in
+          let unit = Markup.BOM Region.{region; value}
+          in state#push_markup unit
+
+      end
diff --git a/src/passes/1-parser/shared/LexerLog.ml b/src/passes/1-parser/shared/LexerLog.ml
index 1f978f6b2..7f23ef0c6 100644
--- a/src/passes/1-parser/shared/LexerLog.ml
+++ b/src/passes/1-parser/shared/LexerLog.ml
@@ -4,7 +4,7 @@ module Region = Simple_utils.Region
 
 module type S =
   sig
-    module Lexer : Lexer.S
+    module Lexer : LexerLib.S
 
     val output_token :
       ?offsets:bool ->
@@ -20,13 +20,14 @@ module type S =
     val trace :
       ?offsets:bool ->
       [`Byte | `Point] ->
-      EvalOpt.language ->
+      ?block:EvalOpt.block_comment ->
+      ?line:EvalOpt.line_comment ->
       Lexer.input ->
       EvalOpt.command ->
       (unit, string Region.reg) Stdlib.result
   end
 
-module Make (Lexer: Lexer.S) : (S with module Lexer = Lexer) =
+module Make (Lexer: LexerLib.S) : (S with module Lexer = Lexer) =
   struct
     module Lexer = Lexer
     module Token = Lexer.Token
@@ -56,9 +57,9 @@ module Make (Lexer: Lexer.S) : (S with module Lexer = Lexer) =
 
     type file_path = string
 
-    let trace ?(offsets=true) mode lang input command :
+    let trace ?(offsets=true) mode ?block ?line input command :
           (unit, string Region.reg) Stdlib.result =
-      match Lexer.open_token_stream lang input with
+      match Lexer.open_token_stream ?line ?block input with
         Ok Lexer.{read; buffer; close; _} ->
           let log = output_token ~offsets mode command stdout
           and close_all () = flush_all (); close () in
diff --git a/src/passes/1-parser/shared/LexerLog.mli b/src/passes/1-parser/shared/LexerLog.mli
index e4bd05133..f433df44d 100644
--- a/src/passes/1-parser/shared/LexerLog.mli
+++ b/src/passes/1-parser/shared/LexerLog.mli
@@ -2,7 +2,7 @@ module Region = Simple_utils.Region
 
 module type S =
   sig
-    module Lexer : Lexer.S
+    module Lexer : LexerLib.S
 
     val output_token :
       ?offsets:bool ->
@@ -18,10 +18,11 @@ module type S =
     val trace :
       ?offsets:bool ->
       [`Byte | `Point] ->
-      EvalOpt.language ->
+      ?block:EvalOpt.block_comment ->
+      ?line:EvalOpt.line_comment ->
       Lexer.input ->
       EvalOpt.command ->
       (unit, string Region.reg) Stdlib.result
   end
 
-module Make (Lexer: Lexer.S) : S with module Lexer = Lexer
+module Make (Lexer: LexerLib.S) : S with module Lexer = Lexer
diff --git a/src/passes/1-parser/shared/LexerUnit.ml b/src/passes/1-parser/shared/LexerUnit.ml
index 07837766c..017c18286 100644
--- a/src/passes/1-parser/shared/LexerUnit.ml
+++ b/src/passes/1-parser/shared/LexerUnit.ml
@@ -9,7 +9,7 @@ module type IO =
     val options : EvalOpt.options (* CLI options *)
   end
 
-module Make (IO: IO) (Lexer: Lexer.S) =
+module Make (IO: IO) (Lexer: LexerLib.S) =
   struct
     (* Error printing and exception tracing *)
 
@@ -40,30 +40,42 @@ module Make (IO: IO) (Lexer: Lexer.S) =
            (* Running the lexer on the preprocessed input *)
 
             let source = Lexer.String (Buffer.contents pp_buffer) in
-              match Lexer.open_token_stream IO.options#lang source with
-                Ok Lexer.{read; buffer; close; _} ->
-                  let close_all () = flush_all (); close () in
-                  let rec read_tokens tokens =
-                    match read ~log:(fun _ _ -> ()) buffer with
-                      token ->
-                        if   Lexer.Token.is_eof token
-                        then Stdlib.Ok (List.rev tokens)
-                        else read_tokens (token::tokens)
-                    | exception Lexer.Error error ->
-                        let file =
-                          match IO.options#input with
-                            None | Some "-" -> false
-                          |         Some _  -> true in
-                        let () =
-                          Printf.eprintf "[LexerUnit] file = %b\n%!" file in
-                        let msg =
-                          Lexer.format_error ~offsets:IO.options#offsets
-                                             IO.options#mode ~file error
-                        in Stdlib.Error msg in
-                  let result = read_tokens []
-                  in close_all (); result
-              | Stdlib.Error (Lexer.File_opening msg) ->
-                  flush_all (); Stdlib.Error (Region.wrap_ghost msg) in
+            match Lexer.open_token_stream ?line:IO.options#line
+                                          ?block:IO.options#block
+                                          source with
+              Ok Lexer.{read; buffer; close; _} ->
+                let close_all () = flush_all (); close () in
+                let rec read_tokens tokens =
+                  match read ~log:(fun _ _ -> ()) buffer with
+                    token ->
+                      if   Lexer.Token.is_eof token
+                      then Stdlib.Ok (List.rev tokens)
+                      else read_tokens (token::tokens)
+(*                  | exception _ ->
+                              Printf.eprintf "Here\n%!"; exit 1
+ *)                  | exception Lexer.Token.Error error ->
+                      let file =
+                        match IO.options#input with
+                          None | Some "-" -> false
+                        |         Some _  -> true in
+                      let msg =
+                        Lexer.Token.format_error
+                          ~offsets:IO.options#offsets
+                          IO.options#mode ~file error
+                      in Stdlib.Error msg
+                  | exception Lexer.Error error ->
+                      let file =
+                        match IO.options#input with
+                          None | Some "-" -> false
+                        |         Some _  -> true in
+                      let msg =
+                        Lexer.format_error ~offsets:IO.options#offsets
+                                           IO.options#mode ~file error
+                      in Stdlib.Error msg in
+                let result = read_tokens []
+                in close_all (); result
+            | Stdlib.Error (Lexer.File_opening msg) ->
+                flush_all (); Stdlib.Error (Region.wrap_ghost msg) in
       match IO.options#input with
         None -> preproc stdin
       | Some file_path ->
@@ -101,7 +113,8 @@ module Make (IO: IO) (Lexer: Lexer.S) =
               end
             else Log.trace ~offsets:IO.options#offsets
                            IO.options#mode
-                           IO.options#lang
+                           ?block:IO.options#block
+                           ?line:IO.options#line
                            (Lexer.String preproc_str)
                            IO.options#cmd
       in match IO.options#input with
diff --git a/src/passes/1-parser/shared/LexerUnit.mli b/src/passes/1-parser/shared/LexerUnit.mli
index 804182515..950234e41 100644
--- a/src/passes/1-parser/shared/LexerUnit.mli
+++ b/src/passes/1-parser/shared/LexerUnit.mli
@@ -7,7 +7,7 @@ module type IO =
     val options : EvalOpt.options (* CLI options *)
   end
 
-module Make (IO: IO) (Lexer: Lexer.S) :
+module Make (IO: IO) (Lexer: LexerLib.S) :
   sig
     val scan  : unit -> (Lexer.token list, string Region.reg) Stdlib.result
     val trace : unit -> (unit, string Region.reg) Stdlib.result
diff --git a/src/passes/1-parser/shared/ParserAPI.ml b/src/passes/1-parser/shared/ParserAPI.ml
index 5d4eedbd4..99b9ef064 100644
--- a/src/passes/1-parser/shared/ParserAPI.ml
+++ b/src/passes/1-parser/shared/ParserAPI.ml
@@ -56,7 +56,7 @@ module type PARSER =
 (* Main functor *)
 
 module Make (IO: IO)
-            (Lexer: Lexer.S)
+            (Lexer: LexerLib.S)
             (Parser: PARSER with type token = Lexer.Token.token)
             (ParErr: sig val message : int -> string end) =
   struct
@@ -122,10 +122,10 @@ module Make (IO: IO)
         message
       in
       match get_win () with
-        Lexer.Nil -> assert false
-      | Lexer.One invalid ->
+        LexerLib.Nil -> assert false
+      | LexerLib.One invalid ->
           raise (Point (message, None, invalid))
-      | Lexer.Two (invalid, valid) ->
+      | LexerLib.Two (invalid, valid) ->
           raise (Point (message, Some valid, invalid))
 
     (* The monolithic API of Menhir *)
diff --git a/src/passes/1-parser/shared/ParserAPI.mli b/src/passes/1-parser/shared/ParserAPI.mli
index e801db79c..74390f5f0 100644
--- a/src/passes/1-parser/shared/ParserAPI.mli
+++ b/src/passes/1-parser/shared/ParserAPI.mli
@@ -55,7 +55,7 @@ module type PARSER =
   end
 
 module Make (IO: IO)
-            (Lexer: Lexer.S)
+            (Lexer: LexerLib.S)
             (Parser: PARSER with type token = Lexer.Token.token)
             (ParErr: sig val message : int -> string end) :
   sig
diff --git a/src/passes/1-parser/shared/ParserUnit.ml b/src/passes/1-parser/shared/ParserUnit.ml
index 3cc9022b4..fd860cd56 100644
--- a/src/passes/1-parser/shared/ParserUnit.ml
+++ b/src/passes/1-parser/shared/ParserUnit.ml
@@ -4,16 +4,15 @@ module Region  = Simple_utils.Region
 module Preproc = Preprocessor.Preproc
 module SSet    = Set.Make (String)
 
-type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
 module type SubIO =
   sig
     type options = <
       libs    : string list;
       verbose : SSet.t;
       offsets : bool;
-      lang    : language;
-      ext     : string;   (* ".ligo", ".mligo", ".religo" *)
+      block   : EvalOpt.block_comment option;
+      line    : EvalOpt.line_comment option;
+      ext     : string;
       mode    : [`Byte | `Point];
       cmd     : EvalOpt.command;
       mono    : bool
@@ -23,7 +22,7 @@ module type SubIO =
     val make : input:string option -> expr:bool -> EvalOpt.options
   end
 
-module type Pretty =
+module type Printer =
   sig
     type state
     type ast
@@ -38,14 +37,14 @@ module type Pretty =
     val print_expr   : state -> expr -> unit
   end
 
-module Make (Lexer: Lexer.S)
+module Make (Lexer: LexerLib.S)
             (AST: sig type t type expr end)
             (Parser: ParserAPI.PARSER
                      with type ast   = AST.t
                       and type expr  = AST.expr
                       and type token = Lexer.token)
             (ParErr: sig val message : int -> string end)
-            (ParserLog: Pretty with type ast  = AST.t
+            (ParserLog: Printer with type ast  = AST.t
                                 and type expr = AST.expr)
             (SubIO: SubIO) =
   struct
@@ -183,10 +182,10 @@ module Make (Lexer: Lexer.S)
       | exception Parser.Error ->
           let invalid, valid_opt =
             match lexer_inst.Lexer.get_win () with
-              Lexer.Nil ->
+              LexerLib.Nil ->
                   assert false (* Safe: There is always at least EOF. *)
-            | Lexer.One invalid -> invalid, None
-            | Lexer.Two (invalid, valid) -> invalid, Some valid in
+            | LexerLib.One invalid -> invalid, None
+            | LexerLib.Two (invalid, valid) -> invalid, Some valid in
             let point = "", valid_opt, invalid in
             let error =
               Front.format_error ~offsets:SubIO.options#offsets
@@ -226,11 +225,14 @@ module Make (Lexer: Lexer.S)
 
              let () = close () in
              let input' = Lexer.String (Buffer.contents buffer) in
-             match Lexer.open_token_stream options#lang input' with
+             match Lexer.open_token_stream ?line:options#line
+                                           ?block:options#block
+                                           input'
+             with
                Ok instance ->
                  let open Lexing in
                  instance.Lexer.buffer.lex_curr_p <-
-                   {instance.Lexer.buffer.lex_curr_p with pos_fname = file};
+                   {instance.Lexer.buffer.lex_curr_p with pos_fname=file};
                  apply instance parser
              | Stdlib.Error (Lexer.File_opening msg) ->
                  Stdlib.Error (Region.wrap_ghost msg)
diff --git a/src/passes/1-parser/shared/ParserUnit.mli b/src/passes/1-parser/shared/ParserUnit.mli
index ebf577331..90e43813a 100644
--- a/src/passes/1-parser/shared/ParserUnit.mli
+++ b/src/passes/1-parser/shared/ParserUnit.mli
@@ -2,18 +2,19 @@
 
 module Region = Simple_utils.Region
 
-type language = [`PascaLIGO | `CameLIGO | `ReasonLIGO]
-
 module SSet : Set.S with type elt = string and type t = Set.Make(String).t
 
+(* A subtype of [EvalOpt.options] *)
+
 module type SubIO =
   sig
     type options = <
       libs    : string list;
       verbose : SSet.t;
       offsets : bool;
-      lang    : language;
-      ext     : string;   (* ".ligo", ".mligo", ".religo" *)
+      block   : EvalOpt.block_comment option;
+      line    : EvalOpt.line_comment option;
+      ext     : string;
       mode    : [`Byte | `Point];
       cmd     : EvalOpt.command;
       mono    : bool
@@ -23,7 +24,9 @@ module type SubIO =
     val make : input:string option -> expr:bool -> EvalOpt.options
   end
 
-module type Pretty =
+(* Signature for the printers *)
+
+module type Printer =
   sig
     type state
     type ast
@@ -38,14 +41,16 @@ module type Pretty =
     val print_expr   : state -> expr -> unit
   end
 
-module Make (Lexer : Lexer.S)
+(* Main functor to make the parser *)
+
+module Make (Lexer : LexerLib.S)
             (AST : sig type t type expr end)
             (Parser : ParserAPI.PARSER
                       with type ast   = AST.t
                        and type expr  = AST.expr
                        and type token = Lexer.token)
             (ParErr : sig val message : int -> string end)
-            (ParserLog : Pretty with type ast  = AST.t
+            (ParserLog : Printer with type ast  = AST.t
                                  and type expr = AST.expr)
             (SubIO: SubIO) :
   sig
@@ -82,4 +87,4 @@ module Make (Lexer : Lexer.S)
 
     val preprocess :
       string -> (Buffer.t, message Region.reg) Stdlib.result
-end
+  end
diff --git a/src/passes/1-parser/shared/dune b/src/passes/1-parser/shared/dune
index 870ddb3c6..db0ce3e46 100644
--- a/src/passes/1-parser/shared/dune
+++ b/src/passes/1-parser/shared/dune
@@ -13,6 +13,7 @@
   (preprocess
     (pps bisect_ppx --conditional))
   (modules
+    LexerLib
     LexerUnit
     ParserUnit
     ParserAPI