try at math syntax

Author: giltho

src/ast.ml

@@ -22,7 +22,8 @@ type inline_element =
   | `Styled of style * inline_element with_location list
   | `Reference of
     reference_kind * string with_location * inline_element with_location list
-  | `Link of string * inline_element with_location list ]
+  | `Link of string * inline_element with_location list
+  | `Math of bool * string ]
 (** Inline elements are equivalent to what would be found in a [span] in HTML.
     Mostly these are straightforward. The [`Reference] constructor takes a triple
     whose second element is the reference itself, and the third the replacement

src/lexer.mll

@@ -262,6 +262,8 @@ let raw_markup =
 let raw_markup_target =
   ([^ ':' '%'] | '%'+ [^ ':' '%' '}'])* '%'*
 
+let math_block = raw_markup
+
 let language_tag_char =
   ['a'-'z' 'A'-'Z' '0'-'9' '_' '-' ]
 
@@ -320,6 +322,9 @@ rule token input = parse
 
   | "{_"
     { emit input (`Begin_style `Subscript) }
+  
+  | "{m" horizontal_space
+    { inline_math (Buffer.create 1024) 0 (Lexing.lexeme_start lexbuf) input lexbuf }
 
   | "{!modules:" ([^ '}']* as modules) '}'
     { emit input (`Modules modules) }
@@ -361,6 +366,16 @@ rule token input = parse
     { verbatim
         (Buffer.create 1024) None (Lexing.lexeme_start lexbuf) input lexbuf }
 
+  | "{%math" horizontal_space (raw_markup as s) ("%}" | eof as e)
+    { let token  = `Math (true, s) in
+      if e <> "%}" then
+        warning
+          input
+          ~start_offset:(Lexing.lexeme_end lexbuf)
+          (Parse_error.not_allowed
+            ~what:(Token.describe `End)
+            ~in_what:(Token.describe token));
+      emit input token }
   | "{%" ((raw_markup_target as target) ':')? (raw_markup as s)
     ("%}" | eof as e)
     { let token = `Raw_markup (target, s) in
@@ -372,7 +387,7 @@ rule token input = parse
             ~what:(Token.describe `End)
             ~in_what:(Token.describe token));
       emit input token }
-
+  
   | "{ul"
     { emit input (`Begin_list `Unordered) }
 
@@ -538,7 +553,40 @@ and code_span buffer nesting_level start_offset input = parse
     { Buffer.add_char buffer c;
       code_span buffer nesting_level start_offset input lexbuf }
 
+and inline_math buffer nesting_level start_offset input = parse
+  | '}'
+    { if nesting_level == 0 then
+        emit input (`Math (false, Buffer.contents buffer)) ~start_offset
+      else begin
+        Buffer.add_char buffer '}';
+        inline_math buffer (nesting_level - 1) start_offset input lexbuf
+      end
+      }
+  | '{'
+    { Buffer.add_char buffer '{';
+      inline_math buffer (nesting_level + 1) start_offset input lexbuf }
+  | ("\\{" | "\\}") as s
+    { Buffer.add_string buffer s;
+      inline_math buffer nesting_level start_offset input lexbuf }
+  | newline newline
+    { warning
+        input
+        (Parse_error.not_allowed
+          ~what:(Token.describe (`Blank_line "\n\n"))
+          ~in_what:(Token.describe (`Math (false, ""))));
+      Buffer.add_char buffer '\n';
+      inline_math buffer nesting_level start_offset input lexbuf }
 
+  | eof
+    { warning
+        input
+        (Parse_error.not_allowed
+          ~what:(Token.describe `End)
+          ~in_what:(Token.describe (`Math (false, ""))));
+      emit input (`Math (false, Buffer.contents buffer)) ~start_offset }
+  | _ as c
+    { Buffer.add_char buffer c;
+      inline_math buffer nesting_level start_offset input lexbuf }
 
 and verbatim buffer last_false_terminator start_offset input = parse
   | (space_char as c) "v}"

src/syntax.ml

@@ -54,7 +54,8 @@ type token_that_always_begins_an_inline_element =
   | `Simple_reference of string
   | `Begin_reference_with_replacement_text of string
   | `Simple_link of string
-  | `Begin_link_with_replacement_text of string ]
+  | `Begin_link_with_replacement_text of string
+  | `Math of bool * string ]
 
 (* Check that the token constructors above actually are all in [Token.t]. *)
 let _check_subset : token_that_always_begins_an_inline_element -> Token.t =
@@ -105,6 +106,9 @@ let rec inline_element :
   | `Raw_markup (raw_markup_target, s) ->
       junk input;
       Loc.at location (`Raw_markup (raw_markup_target, s))
+  | `Math s ->
+      junk input;
+      Loc.at location (`Math s)
   | `Begin_style s as parent_markup ->
       junk input;
 

src/token.ml

@@ -53,6 +53,8 @@ type t =
     string
   | `Code_span of string
   | `Raw_markup of string option * string
+  | `Math of bool * string
+    (* The boolean is true iff the math is a block *)
   | `Begin_style of style
   | `Begin_paragraph_style of paragraph_style
   | (* Other inline element markup. *)
@@ -123,6 +125,7 @@ let describe : [< t | `Comment ] -> string = function
   | `Begin_style `Emphasis -> "'{e ...}' (emphasized text)"
   | `Begin_style `Superscript -> "'{^...}' (superscript)"
   | `Begin_style `Subscript -> "'{_...}' (subscript)"
+  | `Math (b, _) -> if b then "'{%math ...%}' (math block)" else "'{m ...}' (inline math)"
   | `Simple_reference _ -> "'{!...}' (cross-reference)"
   | `Begin_reference_with_replacement_text _ ->
       "'{{!...} ...}' (cross-reference)"

test/test.ml

@@ -41,6 +41,9 @@ module Ast_to_sexp = struct
     | `Code_span c -> List [ Atom "code_span"; Atom c ]
     | `Raw_markup (target, s) ->
         List [ Atom "raw_markup"; opt str target; Atom s ]
+    | `Math (b, s) ->
+      let b_descr = if b then Atom "block" else Atom "inline" in 
+      List [Atom "math"; b_descr; Atom s]
     | `Styled (s, es) ->
         List [ style s; List (List.map (at.at (inline_element at)) es) ]
     | `Reference (kind, r, es) ->
@@ -1279,8 +1282,8 @@ let%expect_test _ =
           ( "File \"f.ml\", line 1, characters 0-4:\
            \n'{^...}' (superscript) should not be empty."))) |}]
   end in
-  ()
-
+  ()  
+  
 let%expect_test _ =
   let module Subscript = struct
     let basic =
@@ -5303,3 +5306,65 @@ let%expect_test _ =
            (warnings ())) |}]
   end in
   ()
+
+let%expect_test _ =
+  let module Math = struct
+    let block =
+      test "{%math \\sum_{i=0}^n x^i%}";
+      [%expect {|
+        ((output
+          (((f.ml (1 0) (1 25))
+            (paragraph (((f.ml (1 0) (1 25)) (math block "\\sum_{i=0}^n x^i")))))))
+         (warnings ())) |}]
+      
+    let complex_block =
+      test {|{%math
+      \alpha(x)=\left\{
+                \begin{array}{ll}                 % beginning of the array
+                  x \% 4\\                        % some variable modulo 4
+                  \frac{1}{1+e^{-kx}}\\           % something else
+                  \frac{e^x-e^{-x}}{e^x+e^{-x}}   % another action
+                \end{array}                       % end of the array
+              \right.
+      %}|}
+    
+    let inline =
+      test "{m x + 4}";
+      [%expect {|
+        ((output
+          (((f.ml (1 0) (9 8))
+            (paragraph
+             (((f.ml (1 0) (9 8))
+               (raw_markup ()
+                 "math\
+                \n      \\alpha(x)=\\left\\{\
+                \n                \\begin{array}{ll}                 % beginning of the array\
+                \n                  x \\% 4\\\\                        % some variable modulo 4\
+                \n                  \\frac{1}{1+e^{-kx}}\\\\           % something else\
+                \n                  \\frac{e^x-e^{-x}}{e^x+e^{-x}}   % another action\
+                \n                \\end{array}                       % end of the array\
+                \n              \\right.\
+                \n      ")))))))
+         (warnings ()))((output
+          (((f.ml (1 0) (1 9))
+            (paragraph (((f.ml (1 0) (1 9)) (math inline "x + 4")))))))
+         (warnings ())) |}]
+    
+    let inline_nested =
+      test "{m \\sub_{i=0}^n x^i}";
+      [%expect {|
+        ((output
+          (((f.ml (1 0) (1 20))
+            (paragraph (((f.ml (1 0) (1 20)) (math inline "\\sub_{i=0}^n x^i")))))))
+         (warnings ())) |}]
+    
+    let inline_false_terminator =
+      test "{m \\{ \\mathbb{only_left}}";
+      [%expect {|
+        ((output
+          (((f.ml (1 0) (1 25))
+            (paragraph
+             (((f.ml (1 0) (1 25)) (math inline "\\{ \\mathbb{only_left}")))))))
+         (warnings ())) |}]
+  end in
+  ()