Moved all the code to src directory

1 files changed, 0 insertions, 114 deletions

diff --git a/expression.ml b/expression.ml
deleted file mode 100755
index 20227ad..0000000
--- a/expression.ml
+++ /dev/null
@@ -1,114 +0,0 @@
-module Tuple2 = Tools.Tuple2

-

-let u = UTF8.from_utf8string

-

-type t =

-  | Basic: 'a ScTypes.types -> t           (** A direct type *)

-  | Formula: formula -> t               (** A formula *)

-  | Undefined: t                         (** The content is not defined *)

-

-and formula =

-  | Expression of ScTypes.expression  (** A valid expression *)

-  | Error of int * UTF8.t             (** When the expression cannot be parsed *)

-

-

-let is_defined = function

-  | Undefined -> false

-  | _ -> true

-

-let load content = begin

-  let content = UTF8.to_utf8string content in

-  if String.length content > 0 then (

-    if content.[0] = '=' then (

-      (* If the string start with a '=', load it as a formula *)

-      Formula (

-        try

-          Expression (

-               Lexing.from_string content

-            |> ExpressionParser.value ExpressionLexer.read)

-        with _ -> Error (1, UTF8.from_utf8string content)

-      )

-    ) else (

-      (* First try to load the data with basic types, and fallback with string *)

-      let content' =

-        try String.sub content 0 (String.index content '\000')

-        with Not_found -> content in

-        try

-          let ScTypes.Result r =

-               ExpressionParser.content ExpressionLexer.read

-            @@ Lexing.from_string content' in

-          Basic r

-        with _ -> Basic (ScTypes.string (UTF8.from_utf8string content'))

-    )

-  ) else (

-    (* If the string in empty, build an undefined value *)

-    Undefined

-  )

-end

-

-

-let load_expr expr = expr

-

-

-(** Extract the parameters to give to a function.

-    return an Error if one of them is an error

- *)

-let eval expr sources = begin

-

-  let eval_exp f = Evaluator.eval sources f in

-

-  begin try match expr with

-    | Basic value -> ScTypes.Result value

-    | Formula (Expression f) -> eval_exp f

-    | Formula (Error (i, s)) -> ScTypes.Error ScTypes.Error

-    | Undefined -> ScTypes.Error Not_found

-    with ex -> ScTypes.Error ex

-  end

-

-end

-

-let collect_sources expr = begin

-  let rec collect refs = function

-    | ScTypes.Ref r ->

-        begin match ScTypes.Refs.collect r with

-        | ScTypes.Refs.Single r -> Cell.Set.add r refs

-        | ScTypes.Refs.Array1 a1 ->

-            List.fold_left (fun set elt -> Cell.Set.add elt set) refs a1

-        | ScTypes.Refs.Array2 a2 ->

-            List.fold_left (List.fold_left (fun set elt -> Cell.Set.add elt set)) refs a2

-        end

-    | ScTypes.Call (ident, params) -> List.fold_left collect refs params

-    | ScTypes.Expression f -> collect refs f

-    | _ -> refs

-  in match expr with

-  | Formula (Expression f) -> collect Cell.Set.empty f

-  | _ -> Cell.Set.empty

-end

-

-let show e =

-  let buffer = UTF8.Buffer.create 16 in

-  begin match e with

-  | Formula (Expression f) ->

-      UTF8.Buffer.add_char buffer '=';

-      ScTypes.show_expr buffer f

-  | Basic b -> ScTypes.Type.show_full buffer b

-  | Formula (Error (i,s)) -> UTF8.Buffer.add_string buffer s

-  | Undefined -> ()

-  end;

-  UTF8.Buffer.contents buffer

-

-let shift vector =

-

-  let rec shift_exp: ScTypes.expression -> ScTypes.expression = function

-    | ScTypes.Value v -> ScTypes.Value v

-    | ScTypes.Call (ident, params) -> ScTypes.Call (ident, List.map shift_exp params)

-    | ScTypes.Ref r -> ScTypes.Ref (ScTypes.Refs.shift vector r)

-    | ScTypes.Expression expr -> ScTypes.Expression (shift_exp expr)

-

-  in function

-  | Formula (Expression f) -> Formula (Expression (shift_exp f))

-  | other -> other

-

-let (=) t1 t2 = match t1, t2 with

-  | Basic b1, Basic b2 -> ScTypes.Type.(=) b1 b2

-  | o1, o2 -> Pervasives.(=) o1 o2