emileclarkb/hammer
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Got action and attr_bool working

Browse source
This commit is contained in:
Dan Hirsch 2014-01-04 23:08:44 +01:00
parent ebb7b677ba
commit 3da3e70f65
5 changed files with 111 additions and 65 deletions
Download patch file Download diff file Expand all files Collapse all files

2
lib/tsgencsharp.pl
View file

@ -151,7 +151,7 @@ pp_byte_seq_r([X|Xs]) --> !,
pp_byte_seq_r(Xs). pp_byte_seq_r(Xs).
pp_parse_result(char(C)) --> !, pp_parse_result(char(C)) --> !,
"(System.UInt64)", %"(System.UInt64)",
pp_parser(char(C)). pp_parser(char(C)).
pp_parse_result(seq(Args)) --> !, pp_parse_result(seq(Args)) --> !,
"new object[]{ ", pp_result_seq(Args), "}". "new object[]{ ", pp_result_seq(Args), "}".

33
src/bindings/dotnet/ext/hammer.cs
View file

@ -122,12 +122,17 @@ namespace Hammer
public class Hammer public class Hammer
{ {
internal static IDictionary tag_to_action; internal static IDictionary tag_to_action;
internal static ulong charify_action;
internal static HTokenType tt_dotnet; internal static HTokenType tt_dotnet;
static Hammer() static Hammer()
{ {
tt_dotnet = hammer.h_allocate_token_type("com.upstandinghackers.hammer.dotnet.tagged"); tt_dotnet = hammer.h_allocate_token_type("com.upstandinghackers.hammer.dotnet.tagged");
hammer.h_set_dotnet_tagged_token_type(tt_dotnet); hammer.h_set_dotnet_tagged_token_type(tt_dotnet);
tag_to_action = new System.Collections.Hashtable(); tag_to_action = new System.Collections.Hashtable();
charify_action = RegisterAction(x => {
//System.Console.WriteLine(x.GetType());
return char.ConvertFromUtf32((int)(ulong)x)[0];
});
} }
internal static ulong RegisterAction(HAction action) internal static ulong RegisterAction(HAction action)
@ -137,6 +142,18 @@ namespace Hammer
return newAction; return newAction;
} }
internal static ulong RegisterPredicate(HPredicate predicate)
{
ulong newPredicate = (ulong)tag_to_action.Count;
tag_to_action[newPredicate] = predicate;
return newPredicate;
}
internal static Parser CharParser(Parser p)
{
return new Parser(hammer.h_tag(p.wrapped, charify_action)).Pin(p);
}
internal static byte[] ToBytes(string s) internal static byte[] ToBytes(string s)
{ {
// Probably not what you want unless you're parsing binary data. // Probably not what you want unless you're parsing binary data.
@ -192,7 +209,7 @@ namespace Hammer
public static Parser Ch(byte ch) public static Parser Ch(byte ch)
{ {
return new Parser(hammer.h_ch(ch)); return CharParser(new Parser(hammer.h_ch(ch)));
} }
public static Parser Ch(char ch) public static Parser Ch(char ch)
@ -202,12 +219,12 @@ namespace Hammer
public static Parser Ch_range(byte c1, byte c2) public static Parser Ch_range(byte c1, byte c2)
{ {
return new Parser(hammer.h_ch_range(c1, c2)); return CharParser(new Parser(hammer.h_ch_range(c1, c2)));
} }
public static Parser Ch_range(char c1, char c2) public static Parser Ch_range(char c1, char c2)
{ {
return new Parser(hammer.h_ch_range((byte)c1, (byte)c2)); return CharParser(new Parser(hammer.h_ch_range((byte)c1, (byte)c2)));
} }
public static Parser Int_range(Parser p, System.Int64 i1, System.Int64 i2) public static Parser Int_range(Parser p, System.Int64 i1, System.Int64 i2)
@ -230,7 +247,7 @@ namespace Hammer
unsafe { unsafe {
fixed(byte* b = &charset[0]) fixed(byte* b = &charset[0])
{ {
return new Parser(hammer.h_in((IntPtr)b, (uint)charset.Length)); return CharParser(new Parser(hammer.h_in((IntPtr)b, (uint)charset.Length)));
} }
} }
} }
@ -240,7 +257,7 @@ namespace Hammer
unsafe { unsafe {
fixed(byte* b = &charset[0]) fixed(byte* b = &charset[0])
{ {
return new Parser(hammer.h_not_in((IntPtr)b, (uint)charset.Length)); return CharParser(new Parser(hammer.h_not_in((IntPtr)b, (uint)charset.Length)));
} }
} }
} }
@ -277,7 +294,6 @@ namespace Hammer
public static Parser Nothing_p() {return new Parser(hammer.h_nothing_p());} public static Parser Nothing_p() {return new Parser(hammer.h_nothing_p());}
public static Parser Epsilon_p() {return new Parser(hammer.h_epsilon_p());} public static Parser Epsilon_p() {return new Parser(hammer.h_epsilon_p());}
// 1-arg parsers // 1-arg parsers
public static Parser Ignore(Parser p) public static Parser Ignore(Parser p)
{ {
@ -362,6 +378,11 @@ namespace Hammer
ulong actionNo = Hammer.RegisterAction(action); ulong actionNo = Hammer.RegisterAction(action);
return new Parser(hammer.h_tag(p.wrapped, actionNo)).Pin(p).Pin(action); return new Parser(hammer.h_tag(p.wrapped, actionNo)).Pin(p).Pin(action);
} }
public static Parser AttrBool(Parser p, HPredicate predicate)
{
ulong predNo = Hammer.RegisterPredicate(predicate);
return new Parser(hammer.h_tag(p.wrapped, predNo)).Pin(p).Pin(predicate);
}
} }
} }

27
src/bindings/dotnet/test/hammer_hand_tests.cs
View file

@ -7,11 +7,28 @@ namespace Hammer.Test
[Test] [Test]
public void TestAction() public void TestAction()
{ {
Parser parser = Hammer.Action(Hammer.Sequence(Hammer.Choice(Hammer.Token("a"), Parser parser = Hammer.Action(Hammer.Sequence(Hammer.Choice(Hammer.Ch('a'),
Hammer.Token("A")), Hammer.Ch('A')),
Hammer.Choice(Hammer.Token("b"), Hammer.Choice(Hammer.Ch('b'),
Hammer.Token("B"))), Hammer.Ch('B'))),
(HAction)(x => char.ToUpper(((string)x)[0]))); (HAction)(x => string.Join(",",(object[])x)));
CheckParseOK(parser, "ab", "a,b");
CheckParseOK(parser, "AB", "A,B");
CheckParseFail(parser, "XX");
}
[Test]
public void TestAttrBool()
{
Parser parser = Hammer.AttrBool(Hammer.Many1(Hammer.Choice(Hammer.Ch('a'),
Hammer.Ch('b'))),
(HPredicate)(x => {
object[] elems = (object[])x;
return elems.Length > 1 && (char)elems[0] == (char)elems[1];
}));
CheckParseOK(parser, "aa", new object[]{ 'a','a' });
CheckParseOK(parser, "bb", new object[]{ 'b','b' });
CheckParseFail(parser, "ab");
} }
} }

106
src/bindings/dotnet/test/hammer_tests.cs
View file

@ -13,14 +13,14 @@ namespace Hammer.Test {
public void TestCh() { public void TestCh() {
Parser parser; Parser parser;
parser = Hammer.Ch(0xa2); parser = Hammer.Ch(0xa2);
CheckParseOK(parser, "\xa2", (System.UInt64)'\xa2'); CheckParseOK(parser, "\xa2", '\xa2');
CheckParseFail(parser, "\xa3"); CheckParseFail(parser, "\xa3");
} }
[Test] [Test]
public void TestCh_range() { public void TestCh_range() {
Parser parser; Parser parser;
parser = Hammer.Ch_range(0x61, 0x63); parser = Hammer.Ch_range(0x61, 0x63);
CheckParseOK(parser, "b", (System.UInt64)'b'); CheckParseOK(parser, "b", 'b');
CheckParseFail(parser, "d"); CheckParseFail(parser, "d");
} }
[Test] [Test]
@ -94,10 +94,10 @@ namespace Hammer.Test {
public void TestWhitespace() { public void TestWhitespace() {
Parser parser; Parser parser;
parser = Hammer.Whitespace(Hammer.Ch(0x61)); parser = Hammer.Whitespace(Hammer.Ch(0x61));
CheckParseOK(parser, "a", (System.UInt64)'a'); CheckParseOK(parser, "a", 'a');
CheckParseOK(parser, " a", (System.UInt64)'a'); CheckParseOK(parser, " a", 'a');
CheckParseOK(parser, " a", (System.UInt64)'a'); CheckParseOK(parser, " a", 'a');
CheckParseOK(parser, "\x09a", (System.UInt64)'a'); CheckParseOK(parser, "\x09a", 'a');
CheckParseFail(parser, "_a"); CheckParseFail(parser, "_a");
parser = Hammer.Whitespace(Hammer.End_p()); parser = Hammer.Whitespace(Hammer.End_p());
CheckParseOK(parser, "", null); CheckParseOK(parser, "", null);
@ -108,7 +108,7 @@ namespace Hammer.Test {
public void TestLeft() { public void TestLeft() {
Parser parser; Parser parser;
parser = Hammer.Left(Hammer.Ch(0x61), Hammer.Ch(0x20)); parser = Hammer.Left(Hammer.Ch(0x61), Hammer.Ch(0x20));
CheckParseOK(parser, "a ", (System.UInt64)'a'); CheckParseOK(parser, "a ", 'a');
CheckParseFail(parser, "a"); CheckParseFail(parser, "a");
CheckParseFail(parser, " "); CheckParseFail(parser, " ");
CheckParseFail(parser, "ba"); CheckParseFail(parser, "ba");
@ -117,7 +117,7 @@ namespace Hammer.Test {
public void TestMiddle() { public void TestMiddle() {
Parser parser; Parser parser;
parser = Hammer.Middle(Hammer.Ch(' '), Hammer.Ch('a'), Hammer.Ch(' ')); parser = Hammer.Middle(Hammer.Ch(' '), Hammer.Ch('a'), Hammer.Ch(' '));
CheckParseOK(parser, " a ", (System.UInt64)'a'); CheckParseOK(parser, " a ", 'a');
CheckParseFail(parser, "a"); CheckParseFail(parser, "a");
CheckParseFail(parser, " a"); CheckParseFail(parser, " a");
CheckParseFail(parser, "a "); CheckParseFail(parser, "a ");
@ -129,21 +129,21 @@ namespace Hammer.Test {
public void TestIn() { public void TestIn() {
Parser parser; Parser parser;
parser = Hammer.In("abc"); parser = Hammer.In("abc");
CheckParseOK(parser, "b", (System.UInt64)'b'); CheckParseOK(parser, "b", 'b');
CheckParseFail(parser, "d"); CheckParseFail(parser, "d");
} }
[Test] [Test]
public void TestNot_in() { public void TestNot_in() {
Parser parser; Parser parser;
parser = Hammer.Not_in("abc"); parser = Hammer.Not_in("abc");
CheckParseOK(parser, "d", (System.UInt64)'d'); CheckParseOK(parser, "d", 'd');
CheckParseFail(parser, "a"); CheckParseFail(parser, "a");
} }
[Test] [Test]
public void TestEnd_p() { public void TestEnd_p() {
Parser parser; Parser parser;
parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.End_p()); parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.End_p());
CheckParseOK(parser, "a", new object[]{ (System.UInt64)'a'}); CheckParseOK(parser, "a", new object[]{ 'a'});
CheckParseFail(parser, "aa"); CheckParseFail(parser, "aa");
} }
[Test] [Test]
@ -156,32 +156,32 @@ namespace Hammer.Test {
public void TestSequence() { public void TestSequence() {
Parser parser; Parser parser;
parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Ch('b')); parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Ch('b'));
CheckParseOK(parser, "ab", new object[]{ (System.UInt64)'a', (System.UInt64)'b'}); CheckParseOK(parser, "ab", new object[]{ 'a', 'b'});
CheckParseFail(parser, "a"); CheckParseFail(parser, "a");
CheckParseFail(parser, "b"); CheckParseFail(parser, "b");
parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Whitespace(Hammer.Ch('b'))); parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Whitespace(Hammer.Ch('b')));
CheckParseOK(parser, "ab", new object[]{ (System.UInt64)'a', (System.UInt64)'b'}); CheckParseOK(parser, "ab", new object[]{ 'a', 'b'});
CheckParseOK(parser, "a b", new object[]{ (System.UInt64)'a', (System.UInt64)'b'}); CheckParseOK(parser, "a b", new object[]{ 'a', 'b'});
CheckParseOK(parser, "a b", new object[]{ (System.UInt64)'a', (System.UInt64)'b'}); CheckParseOK(parser, "a b", new object[]{ 'a', 'b'});
} }
[Test] [Test]
public void TestChoice() { public void TestChoice() {
Parser parser; Parser parser;
parser = Hammer.Choice(Hammer.Ch('a'), Hammer.Ch('b')); parser = Hammer.Choice(Hammer.Ch('a'), Hammer.Ch('b'));
CheckParseOK(parser, "a", (System.UInt64)'a'); CheckParseOK(parser, "a", 'a');
CheckParseOK(parser, "b", (System.UInt64)'b'); CheckParseOK(parser, "b", 'b');
CheckParseOK(parser, "ab", (System.UInt64)'a'); CheckParseOK(parser, "ab", 'a');
CheckParseFail(parser, "c"); CheckParseFail(parser, "c");
} }
[Test] [Test]
public void TestButnot() { public void TestButnot() {
Parser parser; Parser parser;
parser = Hammer.Butnot(Hammer.Ch('a'), Hammer.Token("ab")); parser = Hammer.Butnot(Hammer.Ch('a'), Hammer.Token("ab"));
CheckParseOK(parser, "a", (System.UInt64)'a'); CheckParseOK(parser, "a", 'a');
CheckParseFail(parser, "ab"); CheckParseFail(parser, "ab");
CheckParseOK(parser, "aa", (System.UInt64)'a'); CheckParseOK(parser, "aa", 'a');
parser = Hammer.Butnot(Hammer.Ch_range('0', '9'), Hammer.Ch('6')); parser = Hammer.Butnot(Hammer.Ch_range('0', '9'), Hammer.Ch('6'));
CheckParseOK(parser, "5", (System.UInt64)'5'); CheckParseOK(parser, "5", '5');
CheckParseFail(parser, "6"); CheckParseFail(parser, "6");
} }
[Test] [Test]
@ -195,8 +195,8 @@ namespace Hammer.Test {
public void TestXor() { public void TestXor() {
Parser parser; Parser parser;
parser = Hammer.Xor(Hammer.Ch_range('0', '6'), Hammer.Ch_range('5', '9')); parser = Hammer.Xor(Hammer.Ch_range('0', '6'), Hammer.Ch_range('5', '9'));
CheckParseOK(parser, "0", (System.UInt64)'0'); CheckParseOK(parser, "0", '0');
CheckParseOK(parser, "9", (System.UInt64)'9'); CheckParseOK(parser, "9", '9');
CheckParseFail(parser, "5"); CheckParseFail(parser, "5");
CheckParseFail(parser, "a"); CheckParseFail(parser, "a");
} }
@ -205,18 +205,18 @@ namespace Hammer.Test {
Parser parser; Parser parser;
parser = Hammer.Many(Hammer.Choice(Hammer.Ch('a'), Hammer.Ch('b'))); parser = Hammer.Many(Hammer.Choice(Hammer.Ch('a'), Hammer.Ch('b')));
CheckParseOK(parser, "", new object[]{ }); CheckParseOK(parser, "", new object[]{ });
CheckParseOK(parser, "a", new object[]{ (System.UInt64)'a'}); CheckParseOK(parser, "a", new object[]{ 'a'});
CheckParseOK(parser, "b", new object[]{ (System.UInt64)'b'}); CheckParseOK(parser, "b", new object[]{ 'b'});
CheckParseOK(parser, "aabbaba", new object[]{ (System.UInt64)'a', (System.UInt64)'a', (System.UInt64)'b', (System.UInt64)'b', (System.UInt64)'a', (System.UInt64)'b', (System.UInt64)'a'}); CheckParseOK(parser, "aabbaba", new object[]{ 'a', 'a', 'b', 'b', 'a', 'b', 'a'});
} }
[Test] [Test]
public void TestMany1() { public void TestMany1() {
Parser parser; Parser parser;
parser = Hammer.Many1(Hammer.Choice(Hammer.Ch('a'), Hammer.Ch('b'))); parser = Hammer.Many1(Hammer.Choice(Hammer.Ch('a'), Hammer.Ch('b')));
CheckParseFail(parser, ""); CheckParseFail(parser, "");
CheckParseOK(parser, "a", new object[]{ (System.UInt64)'a'}); CheckParseOK(parser, "a", new object[]{ 'a'});
CheckParseOK(parser, "b", new object[]{ (System.UInt64)'b'}); CheckParseOK(parser, "b", new object[]{ 'b'});
CheckParseOK(parser, "aabbaba", new object[]{ (System.UInt64)'a', (System.UInt64)'a', (System.UInt64)'b', (System.UInt64)'b', (System.UInt64)'a', (System.UInt64)'b', (System.UInt64)'a'}); CheckParseOK(parser, "aabbaba", new object[]{ 'a', 'a', 'b', 'b', 'a', 'b', 'a'});
CheckParseFail(parser, "daabbabadef"); CheckParseFail(parser, "daabbabadef");
} }
[Test] [Test]
@ -224,16 +224,16 @@ namespace Hammer.Test {
Parser parser; Parser parser;
parser = Hammer.Repeat_n(Hammer.Choice(Hammer.Ch('a'), Hammer.Ch('b')), 0x2); parser = Hammer.Repeat_n(Hammer.Choice(Hammer.Ch('a'), Hammer.Ch('b')), 0x2);
CheckParseFail(parser, "adef"); CheckParseFail(parser, "adef");
CheckParseOK(parser, "abdef", new object[]{ (System.UInt64)'a', (System.UInt64)'b'}); CheckParseOK(parser, "abdef", new object[]{ 'a', 'b'});
CheckParseFail(parser, "dabdef"); CheckParseFail(parser, "dabdef");
} }
[Test] [Test]
public void TestOptional() { public void TestOptional() {
Parser parser; Parser parser;
parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Optional(Hammer.Choice(Hammer.Ch('b'), Hammer.Ch('c'))), Hammer.Ch('d')); parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Optional(Hammer.Choice(Hammer.Ch('b'), Hammer.Ch('c'))), Hammer.Ch('d'));
CheckParseOK(parser, "abd", new object[]{ (System.UInt64)'a', (System.UInt64)'b', (System.UInt64)'d'}); CheckParseOK(parser, "abd", new object[]{ 'a', 'b', 'd'});
CheckParseOK(parser, "acd", new object[]{ (System.UInt64)'a', (System.UInt64)'c', (System.UInt64)'d'}); CheckParseOK(parser, "acd", new object[]{ 'a', 'c', 'd'});
CheckParseOK(parser, "ad", new object[]{ (System.UInt64)'a', null, (System.UInt64)'d'}); CheckParseOK(parser, "ad", new object[]{ 'a', null, 'd'});
CheckParseFail(parser, "aed"); CheckParseFail(parser, "aed");
CheckParseFail(parser, "ab"); CheckParseFail(parser, "ab");
CheckParseFail(parser, "ac"); CheckParseFail(parser, "ac");
@ -242,51 +242,51 @@ namespace Hammer.Test {
public void TestIgnore() { public void TestIgnore() {
Parser parser; Parser parser;
parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Ignore(Hammer.Ch('b')), Hammer.Ch('c')); parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Ignore(Hammer.Ch('b')), Hammer.Ch('c'));
CheckParseOK(parser, "abc", new object[]{ (System.UInt64)'a', (System.UInt64)'c'}); CheckParseOK(parser, "abc", new object[]{ 'a', 'c'});
CheckParseFail(parser, "ac"); CheckParseFail(parser, "ac");
} }
[Test] [Test]
public void TestSepBy() { public void TestSepBy() {
Parser parser; Parser parser;
parser = Hammer.SepBy(Hammer.Choice(Hammer.Ch('1'), Hammer.Ch('2'), Hammer.Ch('3')), Hammer.Ch(',')); parser = Hammer.SepBy(Hammer.Choice(Hammer.Ch('1'), Hammer.Ch('2'), Hammer.Ch('3')), Hammer.Ch(','));
CheckParseOK(parser, "1,2,3", new object[]{ (System.UInt64)'1', (System.UInt64)'2', (System.UInt64)'3'}); CheckParseOK(parser, "1,2,3", new object[]{ '1', '2', '3'});
CheckParseOK(parser, "1,3,2", new object[]{ (System.UInt64)'1', (System.UInt64)'3', (System.UInt64)'2'}); CheckParseOK(parser, "1,3,2", new object[]{ '1', '3', '2'});
CheckParseOK(parser, "1,3", new object[]{ (System.UInt64)'1', (System.UInt64)'3'}); CheckParseOK(parser, "1,3", new object[]{ '1', '3'});
CheckParseOK(parser, "3", new object[]{ (System.UInt64)'3'}); CheckParseOK(parser, "3", new object[]{ '3'});
CheckParseOK(parser, "", new object[]{ }); CheckParseOK(parser, "", new object[]{ });
} }
[Test] [Test]
public void TestSepBy1() { public void TestSepBy1() {
Parser parser; Parser parser;
parser = Hammer.SepBy1(Hammer.Choice(Hammer.Ch('1'), Hammer.Ch('2'), Hammer.Ch('3')), Hammer.Ch(',')); parser = Hammer.SepBy1(Hammer.Choice(Hammer.Ch('1'), Hammer.Ch('2'), Hammer.Ch('3')), Hammer.Ch(','));
CheckParseOK(parser, "1,2,3", new object[]{ (System.UInt64)'1', (System.UInt64)'2', (System.UInt64)'3'}); CheckParseOK(parser, "1,2,3", new object[]{ '1', '2', '3'});
CheckParseOK(parser, "1,3,2", new object[]{ (System.UInt64)'1', (System.UInt64)'3', (System.UInt64)'2'}); CheckParseOK(parser, "1,3,2", new object[]{ '1', '3', '2'});
CheckParseOK(parser, "1,3", new object[]{ (System.UInt64)'1', (System.UInt64)'3'}); CheckParseOK(parser, "1,3", new object[]{ '1', '3'});
CheckParseOK(parser, "3", new object[]{ (System.UInt64)'3'}); CheckParseOK(parser, "3", new object[]{ '3'});
CheckParseFail(parser, ""); CheckParseFail(parser, "");
} }
[Test] [Test]
public void TestAnd() { public void TestAnd() {
Parser parser; Parser parser;
parser = Hammer.Sequence(Hammer.And(Hammer.Ch('0')), Hammer.Ch('0')); parser = Hammer.Sequence(Hammer.And(Hammer.Ch('0')), Hammer.Ch('0'));
CheckParseOK(parser, "0", new object[]{ (System.UInt64)'0'}); CheckParseOK(parser, "0", new object[]{ '0'});
CheckParseFail(parser, "1"); CheckParseFail(parser, "1");
parser = Hammer.Sequence(Hammer.And(Hammer.Ch('0')), Hammer.Ch('1')); parser = Hammer.Sequence(Hammer.And(Hammer.Ch('0')), Hammer.Ch('1'));
CheckParseFail(parser, "0"); CheckParseFail(parser, "0");
CheckParseFail(parser, "1"); CheckParseFail(parser, "1");
parser = Hammer.Sequence(Hammer.Ch('1'), Hammer.And(Hammer.Ch('2'))); parser = Hammer.Sequence(Hammer.Ch('1'), Hammer.And(Hammer.Ch('2')));
CheckParseOK(parser, "12", new object[]{ (System.UInt64)'1'}); CheckParseOK(parser, "12", new object[]{ '1'});
CheckParseFail(parser, "13"); CheckParseFail(parser, "13");
} }
[Test] [Test]
public void TestNot() { public void TestNot() {
Parser parser; Parser parser;
parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Choice(Hammer.Token("+"), Hammer.Token("++")), Hammer.Ch('b')); parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Choice(Hammer.Token("+"), Hammer.Token("++")), Hammer.Ch('b'));
CheckParseOK(parser, "a+b", new object[]{ (System.UInt64)'a', new byte[]{ 0x2b}, (System.UInt64)'b'}); CheckParseOK(parser, "a+b", new object[]{ 'a', new byte[]{ 0x2b}, 'b'});
CheckParseFail(parser, "a++b"); CheckParseFail(parser, "a++b");
parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Choice(Hammer.Sequence(Hammer.Token("+"), Hammer.Not(Hammer.Ch('+'))), Hammer.Token("++")), Hammer.Ch('b')); parser = Hammer.Sequence(Hammer.Ch('a'), Hammer.Choice(Hammer.Sequence(Hammer.Token("+"), Hammer.Not(Hammer.Ch('+'))), Hammer.Token("++")), Hammer.Ch('b'));
CheckParseOK(parser, "a+b", new object[]{ (System.UInt64)'a', new object[]{ new byte[]{ 0x2b}}, (System.UInt64)'b'}); CheckParseOK(parser, "a+b", new object[]{ 'a', new object[]{ new byte[]{ 0x2b}}, 'b'});
CheckParseOK(parser, "a++b", new object[]{ (System.UInt64)'a', new byte[]{ 0x2b, 0x2b}, (System.UInt64)'b'}); CheckParseOK(parser, "a++b", new object[]{ 'a', new byte[]{ 0x2b, 0x2b}, 'b'});
} }
[Test] [Test]
public void TestRightrec() { public void TestRightrec() {
@ -294,9 +294,9 @@ namespace Hammer.Test {
IndirectParser sp_rr = Hammer.Indirect(); IndirectParser sp_rr = Hammer.Indirect();
sp_rr.Bind(Hammer.Choice(Hammer.Sequence(Hammer.Ch('a'), sp_rr), Hammer.Epsilon_p())); sp_rr.Bind(Hammer.Choice(Hammer.Sequence(Hammer.Ch('a'), sp_rr), Hammer.Epsilon_p()));
parser = sp_rr; parser = sp_rr;
CheckParseOK(parser, "a", new object[]{ (System.UInt64)'a'}); CheckParseOK(parser, "a", new object[]{ 'a'});
CheckParseOK(parser, "aa", new object[]{ (System.UInt64)'a', new object[]{ (System.UInt64)'a'}}); CheckParseOK(parser, "aa", new object[]{ 'a', new object[]{ 'a'}});
CheckParseOK(parser, "aaa", new object[]{ (System.UInt64)'a', new object[]{ (System.UInt64)'a', new object[]{ (System.UInt64)'a'}}}); CheckParseOK(parser, "aaa", new object[]{ 'a', new object[]{ 'a', new object[]{ 'a'}}});
} }
[Test] [Test]
public void TestAmbiguous() { public void TestAmbiguous() {
@ -308,9 +308,9 @@ namespace Hammer.Test {
sp_p.Bind(Hammer.Ch('+')); sp_p.Bind(Hammer.Ch('+'));
sp_e.Bind(Hammer.Choice(Hammer.Sequence(sp_e, sp_p, sp_e), sp_d)); sp_e.Bind(Hammer.Choice(Hammer.Sequence(sp_e, sp_p, sp_e), sp_d));
parser = sp_e; parser = sp_e;
CheckParseOK(parser, "d", (System.UInt64)'d'); CheckParseOK(parser, "d", 'd');
CheckParseOK(parser, "d+d", new object[]{ (System.UInt64)'d', (System.UInt64)'+', (System.UInt64)'d'}); CheckParseOK(parser, "d+d", new object[]{ 'd', '+', 'd'});
CheckParseOK(parser, "d+d+d", new object[]{ new object[]{ (System.UInt64)'d', (System.UInt64)'+', (System.UInt64)'d'}, (System.UInt64)'+', (System.UInt64)'d'}); CheckParseOK(parser, "d+d+d", new object[]{ new object[]{ 'd', '+', 'd'}, '+', 'd'});
} }
} }
} }

8
src/bindings/dotnet/test/test_support.cs
View file

@ -80,6 +80,14 @@ namespace Hammer.Test
System.UInt64 i = (System.UInt64)o; System.UInt64 i = (System.UInt64)o;
return "u0x" + i.ToString("X"); return "u0x" + i.ToString("X");
} }
else if (o is System.String)
{
return "\"" + o.ToString() + "\"";
}
else if (o is System.Char)
{
return "\'" + o.ToString() + "\'";
}
else else
return "WAT(" + o.GetType() + ")"; return "WAT(" + o.GetType() + ")";
} }