Managed the parens in functions without argumentsHEADmaster

6 files changed, 104 insertions, 89 deletions

diff --git a/lib/qparser/analyzer.ml b/lib/qparser/analyzer.ml
index fc0ed6d..0337baf 100644
--- a/lib/qparser/analyzer.ml
+++ b/lib/qparser/analyzer.ml
@@ -26,7 +26,8 @@ let rec parse : type a context.
         and type context = context) ->
   let module Parser = Parser.Make (S) in
   let module IncrementalParser =
-    Interpreter.Interpreter (Parser.MenhirInterpreter) in
+    Interpreter.Interpreter (Parser.MenhirInterpreter)
+  in
   fun lexer_type l context ->
     let get_parser :
         lexer ->
diff --git a/lib/qparser/dune b/lib/qparser/dune
index eea3815..7edba9c 100644
--- a/lib/qparser/dune
+++ b/lib/qparser/dune
@@ -1,30 +1,28 @@
 (library
  (name qparser)
- (libraries 
-   str
-   menhirLib
-   qsp_syntax
-   sedlex
-   )
- (preprocess (pps 
-   sedlex.ppx
-   ))
- )
-
+ (libraries str menhirLib qsp_syntax sedlex)
+ (preprocess
+  (pps sedlex.ppx)))
 
 (rule
  (targets parser_messages.ml)
- (deps expression_parser.messages tokens.mly qsp_expression.mly qsp_instruction.mly qsp_single_line.mly parser.mly)
- (action  (with-stdout-to %{targets} (run menhir --base parser.mly --compile-errors %{deps}))))
+ (deps
+  expression_parser.messages
+  tokens.mly
+  qsp_expression.mly
+  qsp_instruction.mly
+  qsp_single_line.mly
+  parser.mly)
+ (action
+  (with-stdout-to
+   %{targets}
+   (run menhir --base parser.mly --compile-errors %{deps}))))
 
 (menhir
-  (modules tokens)
-  (flags --only-tokens)
-)
-
+ (modules tokens)
+ (flags --only-tokens))
 
-(menhir 
-  (modules tokens parser qsp_instruction qsp_expression qsp_single_line)
-  (flags --table --external-tokens Tokens)
-  (merge_into parser)
-)
+(menhir
+ (modules tokens parser qsp_instruction qsp_expression qsp_single_line)
+ (flags --table --external-tokens Tokens)
+ (merge_into parser))
diff --git a/lib/qparser/expression_parser.messages b/lib/qparser/expression_parser.messages
index 22ffd7d..8040f05 100644
--- a/lib/qparser/expression_parser.messages
+++ b/lib/qparser/expression_parser.messages
@@ -65,7 +65,6 @@ main: LOCATION_START EOL IF IDENT COLUMN EOL ELSE STAR
 main: LOCATION_START EOL IDENT DECR INTEGER SET
 main: LOCATION_START EOL SET IDENT DECR INTEGER SET
 main: LOCATION_START EOL LET IDENT DECR INTEGER SET
-main: LOCATION_START EOL KEYWORD INTEGER TEXT_MARKER
 main: LOCATION_START EOL KEYWORD IDENT COMA INTEGER TEXT_MARKER
 
     Missing separator between instructions
@@ -114,9 +113,10 @@ main: LOCATION_START EOL IDENT MINUS STAR
 
 dynamics: IDENT R_PAREN
 dynamics: TEXT_MARKER ENTER_EMBED FUNCTION_NOARGS TEXT_MARKER
+dynamics: TEXT_MARKER ENTER_EMBED INTEGER TEXT_MARKER
 
     Unbalanced paren
 
-dynamics: IDENT PLUS FUNCTION_NOARGS TEXT_MARKER
+dynamics: IDENT PLUS INTEGER TEXT_MARKER
 
     Missing operator before text
diff --git a/lib/qparser/idents.ml b/lib/qparser/idents.ml
index be3d76c..a74fce2 100644
--- a/lib/qparser/idents.ml
+++ b/lib/qparser/idents.ml
@@ -99,7 +99,7 @@ let _ =
       ("MIN", FUNCTION T.Min);
       ("$MIN", FUNCTION T.Min');
       ("MOD", MOD);
-      ("MSECSCOUNT", FUNCTION T.Msecscount);
+      ("MSECSCOUNT", FUNCTION_NOARGS T.Msecscount);
       ("MSG", KEYWORD T.Msg);
       ("NL", KEYWORD T.Nl);
       ("*NL", KEYWORD T.Nl');
diff --git a/lib/qparser/parser.mly b/lib/qparser/parser.mly
index 1caf962..55e729e 100644
--- a/lib/qparser/parser.mly
+++ b/lib/qparser/parser.mly
@@ -18,7 +18,7 @@
 %}
 
 %parameter<Analyzer: Qsp_syntax.Analyzer.T>
-%start <(Analyzer.context -> Analyzer.Location.t)>main
+%start<(Analyzer.context -> Analyzer.Location.t)>main
 %start<(Analyzer.context -> Analyzer.Location.t)>dynamics
 
 %on_error_reduce instruction unary_operator assignation_operator
diff --git a/lib/qparser/qsp_expression.mly b/lib/qparser/qsp_expression.mly
index f037051..0b8406c 100644
--- a/lib/qparser/qsp_expression.mly
+++ b/lib/qparser/qsp_expression.mly
@@ -1,93 +1,109 @@
 %%
 
 %public arguments(X):
-    (** This rule allow the difference between elements with a single argument 
-        (when the separator is required) which allow to write a spectif case when
-        we only have one element.
+  (** This rule allow the difference between elements with a single argument 
+      (when the separator is required) which allow to write a spectif case when
+      we only have one element.
      *)
-    | hd = X
-      COMA
-      tl = separated_nonempty_list(COMA, X)
-      { hd :: tl }
-    (** The case where we have nothing is easy to manage here *)
-    |
-      { [] }
-    (** The remaining case (only one argument) is handled outside of this
+  | hd = X COMA tl = separated_nonempty_list(COMA, X) { hd :: tl }
+  (** The case where we have nothing is easy to manage here *)
+  | { [] }
+
+(** The remaining case (only one argument) is handled outside of this
         block: if we have a single argument we don’t have to bother with the
         paren, they belongs to the expression.
      *)
 
 %inline argument(X):
-    | a = delimited(L_PAREN, arguments(X), R_PAREN) { a }
-    | a = X { [ a ] }
+  | a = delimited(L_PAREN, arguments(X), R_PAREN) { a }
+  | a = X { [ a ] }
 
 (** Declare an expression *)
 %public expression:
-    | ex = delimited(L_PAREN, expression, R_PAREN) 
-      { ex }
-    | op = unary_operator 
-      expr = expression 
-      { Analyzer.Expression.uoperator ~ctx:{f=(fun _ -> None)} $loc  op  expr }
-      %prec NO
-    | 
-      expr1 = expression 
-      op = binary_operator 
-      expr2 = expression 
-      { Analyzer.Expression.boperator ~ctx:{f=(fun _ -> None)} $loc op expr1 expr2 }
-    | v = delimited(TEXT_MARKER, literal*, TEXT_MARKER)
-      { Analyzer.Expression.literal ~ctx:{f=(fun _ -> None)} $loc v }
-    | i = INTEGER  { Analyzer.Expression.integer ~ctx:{f=(fun _ -> None)} $loc i }
-    | v = variable { Analyzer.Expression.ident ~ctx:{f=(fun _ -> None)} v }
+  | ex = delimited(L_PAREN, expression, R_PAREN) { ex }
+  | op = unary_operator expr = expression
+    {
+      Analyzer.Expression.uoperator ~ctx:{ f = (fun _ -> None) } $loc op expr
+    }
+    %prec NO
+  | expr1 = expression op = binary_operator expr2 = expression
+    {
+      Analyzer.Expression.boperator ~ctx:{ f = (fun _ -> None) } $loc op expr1 expr2
+    }
+  | v = delimited(TEXT_MARKER, list(literal), TEXT_MARKER)
+    {
+      Analyzer.Expression.literal ~ctx:{ f = (fun _ -> None) } $loc v
+    }
+  | i = INTEGER
+    {
+      Analyzer.Expression.integer ~ctx:{ f = (fun _ -> None) } $loc i
+    }
+  | v = variable
+    { Analyzer.Expression.ident ~ctx:{ f = (fun _ -> None) } v }
     %prec p_variable
-    | k = FUNCTION
-      arg = argument(expression)
+  | k = FUNCTION arg = argument(expression)
     {
-        (Analyzer.Expression.function_ ~ctx:{f=(fun _ -> None)} $loc k arg)
+      Analyzer.Expression.function_ ~ctx:{ f = (fun _ -> None) } $loc k arg
     }
-    | k = FUNCTION_NOARGS
+
+  (* Function without any argument can be used either
+    - without any parens
+    - or with parens but empty and with nothing inside
+  *)
+  | k = FUNCTION_NOARGS
     {
-        (Analyzer.Expression.function_ ~ctx:{f=(fun _ -> None)} $loc k [])
+      Analyzer.Expression.function_ ~ctx:{ f = (fun _ -> None) } $loc k []
     }
+  | k = FUNCTION_NOARGS L_PAREN R_PAREN
+    {
+      Analyzer.Expression.function_ ~ctx:{ f = (fun _ -> None) } $loc k []
+    }
+
 literal:
-    | v = LITERAL { Qsp_syntax.T.Text v }
-    | e = delimited(ENTER_EMBED, expression, LEAVE_EMBED) 
+  | v = LITERAL { Qsp_syntax.T.Text v }
+  | e = delimited(ENTER_EMBED, expression, LEAVE_EMBED)
     { Qsp_syntax.T.Expression e }
 
 unary_operator:
-    | OBJ
-    | NO    { T.No }
-    | MINUS { T.Neg }
-    | PLUS  { T.Add }
+  | OBJ
+    | NO
+    { T.No }
+  | MINUS { T.Neg }
+  | PLUS { T.Add }
 
 %inline binary_operator:
-    | EQUAL { T.Eq }
-    | LT GT { T.Neq }
-    | EXCLAMATION { T.Neq }
-    | PLUS  { T.Plus }
-    | MINUS { T.Minus }
-    | STAR { T.Product }
-    | DIV { T.Div }
-    | MOD { T.Mod }
-    | GT { T.Gt }
-    | LT { T.Lt }
-    | AND  { T.And }
-    | GT EQUAL { T.Gte }
-    | LT EQUAL { T.Lte }
-    | EQUAL GT { T.Gte }
-    | EQUAL LT { T.Lte }
-    | OR { T.Or }
+  | EQUAL { T.Eq }
+  | LT GT { T.Neq }
+  | EXCLAMATION { T.Neq }
+  | PLUS { T.Plus }
+  | MINUS { T.Minus }
+  | STAR { T.Product }
+  | DIV { T.Div }
+  | MOD { T.Mod }
+  | GT { T.Gt }
+  | LT { T.Lt }
+  | AND { T.And }
+  | GT EQUAL { T.Gte }
+  | LT EQUAL { T.Lte }
+  | EQUAL GT { T.Gte }
+  | EQUAL LT { T.Lte }
+  | OR { T.Or }
 
 (** Declare a variable, either in the assignation (let var = …) or as a
     reference is an expression 
  *)
 %public variable:
-    | name = IDENT
-      brackets = delimited(L_BRACKET, expression?, R_BRACKET)?
-    { 
-        let index = match brackets with 
-        | None -> 
+  | name = IDENT
+    brackets = option(
+      delimited(L_BRACKET, option(expression), R_BRACKET)
+    )
+    {
+      let index =
+        match brackets with
+        | None ->
             (* No declaration, consider index at 0 *)
             None
-        | Some other -> other in
-        Qsp_syntax.S.{ pos = $loc ; name ; index }
+        | Some other -> other
+      in
+      Qsp_syntax.S.{ pos = $loc; name; index }
     }