Skip to content

Commit 567f018

Browse files
RomanSoloweowRomanSoloweow
committed
Some
Some
1 parent b679128 commit 567f018

File tree

5 files changed

+106
-35
lines changed

5 files changed

+106
-35
lines changed

‎src/SimpleStateMachine.StructuralSearch.Sandbox/Common.cs‎

Lines changed: 17 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,24 @@
1-
using Pidgin;
1+
using System;
2+
using Pidgin;
23
using static Pidgin.Parser;
34
namespace SimpleStateMachine.StructuralSearch.Sandbox
45
{
56
public static class Common
67
{
7-
8+
public static string _placeholderSeparator = "$";
9+
public static char _underScore = '_';
10+
11+
12+
public static readonly Parser<char, char> Symbol
13+
= LetterOrDigit.Or(Char(_underScore));
14+
public static Parser<char, T> Tok<T>(Parser<char, T> token)
15+
=> Try(token).Before(SkipWhitespaces);
16+
static Parser<char, string> Name(Parser<char, char> firstLetter)
17+
=> Tok(
18+
from first in firstLetter
19+
from rest in OneOf(Letter, Digit, Char('_')).ManyString()
20+
select first + rest
21+
);
22+
// public static Parser<char, string> AnyString { get; } = Parser<string>(_ => true);
823
}
924
}

‎src/SimpleStateMachine.StructuralSearch.Sandbox/Extensions/CharExtensions.cs‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
using Pidgin;
2+
using Pidgin.TokenStreams;
3+
4+
namespace SimpleStateMachine.StructuralSearch.Sandbox.Extensions
5+
{
6+
public static class CharExtensions
7+
{
8+
// public static void Except<Ttoken>(this Parser<Ttoken, char> parser)
9+
// {
10+
// parser.AtLeastOnce()
11+
// }
12+
}
13+
}

‎src/SimpleStateMachine.StructuralSearch.Sandbox/Extensions/ParserExtensions.cs‎

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
using System;
22
using Pidgin;
3+
using Pidgin.Configuration;
34

45
namespace SimpleStateMachine.StructuralSearch.Sandbox.Extensions
56
{
@@ -11,5 +12,21 @@ public static class ParserExtensions
1112
// parser.Select()
1213
// return this.Select<U>((Func<T, U>)(_ => result));
1314
// }
15+
16+
public static Parser<TToken, T> Test<TToken, T, U, V>(this Parser<TToken, T> parser, Parser<TToken, U> parser1, Parser<TToken, V> parser2)
17+
{
18+
if (parser1 == null)
19+
throw new ArgumentNullException(nameof (parser1));
20+
if (parser2 == null)
21+
throw new ArgumentNullException(nameof (parser2));
22+
return Parser.Map((Func<U, T, V, T>) ((_, t, _) => t), parser1, parser, parser2);
23+
}
24+
25+
// public static T ParseOrThrow<T>(this Parser<char, T> parser,
26+
// string input,
27+
// IConfiguration<char>? configuration = null)
28+
// {
29+
// return ParserExtensions.GetValueOrThrow<char, T>(parser.Parse<T>(input, configuration));
30+
// }
1431
}
1532
}

‎src/SimpleStateMachine.StructuralSearch.Sandbox/PlaceholderParser.cs‎

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -7,17 +7,16 @@ namespace SimpleStateMachine.StructuralSearch.Sandbox
77

88
public static class PlaceholderParser
99
{
10-
static string _placeholderSeparator = "$";
11-
static char _underScore = '_';
1210

13-
private static readonly Parser<char, string> Identifier
14-
= Letter.Then(LetterOrDigit.Or(Char(_underScore)).ManyString(), (h, t) => h + t);
11+
12+
public static readonly Parser<char, string> Identifier
13+
= Letter.Then(Symbol.ManyString(), (h, t) => h + t);
1514

1615
private static Parser<char, T> PlaceholderSeparator<T>(Parser<char, T> parser)
17-
=> parser.Between(String(_placeholderSeparator), String(_placeholderSeparator));
18-
16+
=> parser.Between(String(Common._placeholderSeparator), String(Common._placeholderSeparator));
17+
1918
public static Parser<char, string> Placeholder()
2019
=> PlaceholderSeparator(Identifier);
21-
20+
2221
}
2322
}

‎src/SimpleStateMachine.StructuralSearch.Sandbox/Program.cs‎

Lines changed: 53 additions & 26 deletions
Original file line numberDiff line numberDiff line change
@@ -1,54 +1,81 @@
11
using System;
22
using System.Collections.Generic;
3+
using System.Linq;
34
using Pidgin;
45
using Pidgin.Expression;
6+
using SimpleStateMachine.StructuralSearch.Sandbox.Extensions;
57
using static Pidgin.Parser;
68
using static Pidgin.Parser<char>;
79

810
namespace SimpleStateMachine.StructuralSearch.Sandbox
911
{
1012
internal static class Program
1113
{
12-
public class Test
14+
public class Placeholder
1315
{
16+
public Placeholder(bool isCorrect, string value)
17+
{
18+
IsCorrect = isCorrect;
19+
Value = value;
20+
}
1421

22+
public bool IsCorrect { get; set; }
23+
public string Value { get; set; }
1524
}
1625
static void Main(string[] args)
1726
{
18-
Parser<char, double> r1 = Real;
19-
Parser<char, double> r2 = Real;
20-
Parser<char, IEnumerable<char>> r1r2 = Whitespaces.Then(Char('+')).Then(Whitespaces);
21-
Parser<char, double> rParser = Map((foo, _, bar) => bar + foo, r1, r1r2, r2);
22-
Parser<char, string> rParser2 = rParser.Select(x=>x.ToString());
2327

28+
// var abv = Common.Symbol.ManyString();
29+
// // AnyCharExcept(' ', '$')
30+
// // var any = Parser<TToken>.Token((Func<TToken, bool>) (_ => true)).Labelled("any character")
31+
// var any = Common.Symbol.ManyString();
32+
// var placeholder = PlaceholderParser.Identifier.Between(Char('$'));
33+
// // var token = Char("$").Then(AnyCharExcept(' ', '$').Many())
34+
// // var parser = placeholder.Separated(any).Many();
35+
//
36+
// var parser = Common.Tok(placeholder).Or(Common.Tok(any));
37+
38+
var any = AnyCharExcept('$').ManyString();
39+
var token = Try(PlaceholderParser.Identifier.Between(Char('$')));
40+
var testpar = token.Or(any).Many();
2441

25-
Parser<char, string> Var = Letter.Then(LetterOrDigit.ManyString(), (h, t) => h + t);
26-
Parser<char, string> sParser = Map((foo, _, bar) => foo + bar, Var, r1r2, Var);
2742

43+
44+
// var str = Any.Many().Select(x => new string(x.ToArray()));
45+
// var parser = placeholder.Or(str);
46+
47+
var template =
48+
"if($condition$)\n" +
49+
"return $value1$;\n" +
50+
"else\n" +
51+
"return $value2$;";
2852

29-
var js = String("js").ThenReturn(rParser2);
30-
var other = Whitespaces.ThenReturn(sParser);
31-
32-
var result = js.Or(other).Then(CurrentPos);
33-
var ds = r1r2.Select(x=>x);
34-
var tds = CurrentOffset;
53+
var test = testpar.Parse("abdsfdasf $ 2323");
3554

36-
var input = " + ";
37-
// var t2 = result.ParseOrThrow("55 + 25").WithResult(x => x);
38-
var dsdfsdf = ds.ParseOrThrow(input);
39-
var t2 = r1r2.ParseOrThrow(input);
40-
var t = result.ParseOrThrow("js foo + bar");
4155

42-
var t23 = PlaceholderParser.Placeholder().ParseOrThrow("$test$");
43-
44-
// Parser<char, IEnumerable<char>> parser3 = Whitespaces.Then(Char('+')).Then(Whitespaces);
45-
// Parser<char, double> sequencedParser = Map((foo, _,bar) => bar + foo, parser1, parser3, parser2);
56+
// // var token = Try(PlaceholderParser.Identifier.Between(Char('$').Then(Digit));
57+
// // var testpar = token.Or(Any).Then.Many();
58+
//
59+
// var token = Try(PlaceholderParser.Identifier.Between(Char('$').Then(Digit)));
60+
// Parser<char, string> expr = null;
61+
// var parenthesised = Any
62+
// .Then(Rec(() => expr), (c, c1) =>c + c1 );
63+
//
64+
//
65+
// expr = Real.Select(x=>x.ToString()).Or(parenthesised);
66+
//
67+
// // var any = Any.Select(x=> new string(x.ToArray()));
68+
// // var token = Try(PlaceholderParser.Identifier.Between(Char('$')).Then(Digit, (s, c) => s + c).Select(x=> ));
69+
// // var testpar = token.Or(any).Select().Many();
4670
//
47-
// var or = String("")
71+
// var test = Any.Then(CurrentPos, (c, pos) => (c, pos.Col)).Many();
4872
//
73+
// var teest2 = PlaceholderParser.Identifier.Test(Char('$'), Char('$'));
4974
//
50-
// var t = sequencedParser.ParseOrThrow("5+5");
51-
// var g = t.Invoke();
75+
//
76+
// // var gh = Any.Many().Then(String("from")).ParseOrThrow("fsdkfdsfkJFLDKJFfrom");
77+
//
78+
// var gf = expr.Many().ParseOrThrow("$test$ 4 52");
5279
}
5380
}
5481
}

0 commit comments

Comments
 (0)