simple basic parser

Author: gsvgit

Parsers.sln

@@ -0,0 +1,16 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{F2A71F9B-5D33-465A-A702-920D77279786}") = "Parsers", "Parsers\Parsers.fsproj", "{7068A710-F067-4654-876A-53D8CCB52451}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{7068A710-F067-4654-876A-53D8CCB52451}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{7068A710-F067-4654-876A-53D8CCB52451}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{7068A710-F067-4654-876A-53D8CCB52451}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{7068A710-F067-4654-876A-53D8CCB52451}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

Parsers/AST.fs

@@ -0,0 +1,19 @@
+module Parsers.AST
+
+type sourceExpr =
+    | Number of int
+    | Mult of list<sourceExpr>
+    | Add of list<sourceExpr>
+    | Var of string
+
+type sourceAst =
+    | Asgn of string*sourceExpr
+    | Print of sourceExpr
+
+type targetExpr =
+    | TNumber of int
+    | TAdd of list<targetExpr>
+    | TVar of string
+
+type targetAst =
+    | TStmt of string*targetExpr

Parsers/Combinators.fs

@@ -0,0 +1,59 @@
+module Parsers.Combinators
+
+type Parser<'result> = list<char> -> Option<list<char>*'result>
+
+let satisfy predicate: Parser<char> =
+    fun input ->
+        match input with
+        | hd::tl when predicate hd -> Some(tl, hd)
+        | _ -> None
+
+let p_char ch: Parser<char> =
+    satisfy (fun x -> ch = x)
+
+let p_epsilon:Parser<unit> = fun input -> Some(input,())
+
+let p_seq (p1: Parser<'r1>) (p2:'r1 -> Parser<'r2>): Parser<'r2> =
+    fun input ->
+        match p1 input with
+        | None -> None
+        | Some (rest, result) -> p2 result rest
+
+let p_alt (p1:Parser<'r>) (p2:Parser<'r>): Parser<'r> =
+    fun input ->
+        match p1 input with
+        | None -> p2 input
+        | x -> x
+
+let fmap (f:'r1 -> 'r2) (p:Parser<'r1>): Parser<'r2> =
+    fun input ->
+        match p input with
+        | None -> None
+        | Some(rest, res) -> Some(rest, f res)
+
+let rec p_many (p:Parser<'r>): Parser<list<'r>> =
+    p_alt (p_seq p (fun res -> fmap (fun tl -> res::tl) (p_many p)))
+          (fmap (fun _ -> []) p_epsilon)
+
+let p_some (p:Parser<'r>): Parser<list<'r>> =
+    p_seq p (fun res -> fmap (fun tl -> res::tl) (p_many p))
+
+let p_list (p_elem:Parser<'elem>) (p_sep:Parser<unit>) =
+    p_seq p_elem (fun res -> fmap (fun tl -> res :: tl)
+                                  (p_many (p_seq p_sep (fun _ -> p_elem))))
+
+let p_ignore p = fmap (fun _ -> ()) p
+
+let p_kw (kw:string): Parser<string> =
+    let chars = kw.ToCharArray()
+    Array.fold
+        (fun parser curChar ->
+            p_seq parser (fun res -> fmap (fun char -> char::res) (p_char curChar)))
+        (fmap (fun _ -> []) p_epsilon)
+        chars
+    |> fmap (fun charList -> charList |> List.rev |> Array.ofList |> System.String)
+
+
+let run =
+    fun (p: Parser<'r>) (input: string) ->
+        p (List.ofArray <| input.ToCharArray())

Parsers/ExprParser.fs

@@ -0,0 +1,32 @@
+module Parsers.ExprParser
+
+open Parsers.Combinators
+open Parsers.AST
+
+let p_ident: Parser<string> =
+    p_some (satisfy (fun x -> List.contains x ['a'..'z']))
+    |> fmap (fun res -> res |> Array.ofList |> System.String)
+
+let p_num =
+        p_seq (satisfy (fun x -> List.contains x ['1'..'9']))
+              (fun res -> fmap (fun tl -> res :: tl) (p_many (satisfy (fun x -> List.contains x ['0'..'9']))))
+        |> fmap (fun res -> res |> Array.ofList |> System.String |> int |> Number)
+
+let p_mult =
+    p_list (p_alt p_num (fmap Var p_ident)) (p_ignore (p_char '*'))
+    |> fmap Mult
+
+let p_add =
+    p_list p_mult (p_ignore (p_char '+'))
+    |> fmap Add
+
+let p_asgn = p_seq p_ident
+                   (fun ident_name -> p_seq (p_ignore (p_char '='))
+                                            (fun _ -> fmap (fun expr -> Asgn (ident_name, expr)) p_add))
+
+
+let p_kw_print = p_kw "print"
+
+let p_print = p_seq p_kw_print (fun _ -> p_seq (p_char ':') (fun res -> fmap Print p_add))
+
+let p_prog = p_list (p_alt p_print p_asgn) (p_ignore (p_char '\n'))

Parsers/Interpreter.fs

@@ -0,0 +1,40 @@
+module Parsers.Interpreter
+
+open System.Collections.Generic
+open Parsers.AST
+
+let rec eval (context:Dictionary<_,_>) expr =
+    match expr with
+    | Number n -> n
+    | Mult l -> l |> List.map (eval context) |> List.reduce (*)
+    | Add l ->  l |> List.map (eval context) |> List.reduce (+)
+    | Var v_name ->
+        if context.ContainsKey v_name
+        then context[v_name]
+        else failwithf $"Var with name {v_name} not declared."
+
+let rec eval_stmt context stmt =
+    match stmt with
+    | Asgn (v_name, expr) ->
+        Some (v_name, eval context expr)
+    | Print expr ->
+        printfn $"{eval context expr}"
+        None
+
+let eval_prog (statements:list<sourceAst>) =
+    let context = Dictionary<string, int>()
+    List.fold
+        (fun (context:Dictionary<_,_>) stmt ->
+                let res = eval_stmt context stmt
+                match res with
+                | Some (v_name, res) ->
+                    if context.ContainsKey v_name
+                    then context[v_name] <- res
+                    else context.Add(v_name, res)
+                | None -> ()
+                context)
+        context statements
+    |> ignore
+
+
+

Parsers/Parsers.fsproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net7.0</TargetFramework>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Compile Include="Combinators.fs" />
+        <Compile Include="AST.fs" />
+        <Compile Include="ExprParser.fs" />
+        <Compile Include="Translator.fs" />
+        <Compile Include="Interpreter.fs" />
+        <Compile Include="Program.fs" />
+    </ItemGroup>
+
+</Project>

Parsers/Program.fs

@@ -0,0 +1,37 @@
+// For more information see https://aka.ms/fsharp-console-apps
+
+open Parsers.Combinators
+open Parsers.Interpreter
+(*
+Parsers.Combinators.run Parsers.Combinators.ident "ab1cd"
+|> fun x -> printfn $"{x}"
+
+
+run (p_list (p_alt (p_char '3') (p_char '5')) (fmap (fun _ -> ()) (p_char ';'))) "5;3;5;3"
+|> fun x -> printfn $"{x}"
+
+*)
+
+
+let res = run Parsers.ExprParser.p_prog "x=2*10+2*3*4+20
+var=x+x
+print:var*2
+print=var*x
+print:print"
+
+match res with
+| None -> printfn "Incorrect input"
+| Some (rest,ast) ->
+    //printfn $"Res: {res}"
+    eval_prog ast
+
+
+(*
+let res = run Parsers.ExprParser.p_prog "x=2*10+2*3*4+20
+print=x+x
+print:print*2"
+
+match res with
+| None -> printfn "Incorrect input"
+| Some (rest,str) -> printfn $"Res:{str}, rest: {rest}"
+*)

Parsers/Translator.fs

@@ -0,0 +1,6 @@
+module Parsers.Translator
+open Parsers.AST
+
+let removeUnusedVars (statements:list<sourceAst>) =
+    //let usedVars =
+    0