From 97ab5c9a21166f0bffee482210d69877fd6809fa Mon Sep 17 00:00:00 2001
From: Chimrod <>
Date: Fri, 6 Oct 2023 08:35:56 +0200
Subject: Moved qparser and syntax in the library folder

---
 lib/qsp_expression.mly | 86 --------------------------------------------------
 1 file changed, 86 deletions(-)
 delete mode 100644 lib/qsp_expression.mly

(limited to 'lib/qsp_expression.mly')

diff --git a/lib/qsp_expression.mly b/lib/qsp_expression.mly
deleted file mode 100644
index 06cfadd..0000000
--- a/lib/qsp_expression.mly
+++ /dev/null
@@ -1,86 +0,0 @@
-(* %start <(Elements.pos) Elements.exppression>expression  *)
-
-%%
-
-%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.
-     *)
-    | 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 ] }
-
-(** Declare an expression *)
-%public expression:
-    | ex = delimited(L_PAREN, expression, R_PAREN) 
-      { ex }
-    | op = unary_operator 
-      expr = expression 
-      { Analyzer.Expression.uoperator $loc  op  expr }
-      %prec NO
-    | 
-      expr1 = expression 
-      op = binary_operator 
-      expr2 = expression 
-      { Analyzer.Expression.boperator $loc op expr1 expr2 }
-    | v = LITERAL  { Analyzer.Expression.literal $loc v }
-    | i = INTEGER  { Analyzer.Expression.integer $loc i }
-    | v = variable { Analyzer.Expression.ident v }
-    %prec p_variable
-    | k = FUNCTION
-      arg = argument(expression)
-    {
-        (Analyzer.Expression.function_ $loc k arg)
-    }
-
-unary_operator:
-    | 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 }
-
-(** 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 -> 
-            (* No declaration, consider index at 0 *)
-            None
-        | Some other -> other in
-        Analyzer.Expression.{ pos = $loc ; name ; index }
-    }
-- 
cgit v1.2.3