0xDFFF))):
12 | yield(0xE0|((c>>12)&0xF), 0x80|((c>>6)&0x3F), 0x80|(c&0x3F)); //three octets
13 | case (!H&&(0xD800<=c)&&(c<=0xDBFF)): H:=true; r:=c&3; //high surrogate
14 | yield (0xF0|(((1+((c>>6)&0xF))>>2)&7),(0x80|(((1+((c>>6)&0xF))&3)<<4))|((c>>2)&0xF));
15 | case (H&&(0xDC00<=c)&&(c<=0xDFFF)): H:=false; r:=0; //low surrogate
16 | yield((0x80|(r << 4))|((c>>6)&0xF), 0x80|(c&0x3F));
17 | case (true): raise InvalidInput;
18 | end case (H): raise InvalidInput;
19 | };
20 | }
21 |
22 | /*
23 | program UTF8Encode(input){
24 | return iter(c in input)[HS:=false; hs:=0;]
25 | {
26 | case (HS): //the previous character was a high surrogate
27 | //(!IsLowSurrogate(c))
28 | if (!((c >= 0xdc00) && (c <= 0xdfff))) { raise InvalidSurrogatePairException; }
29 | else {
30 | yield ((0x80|(hs << 4))|((c>>6)&0xF), 0x80|(c&0x3F));
31 | HS:=false; hs:=0;
32 | }
33 | case (!HS): //the previous character was not a high surrogate
34 | if (c <= 0x7F) { yield(c); } //one byte: ASCII case
35 | else if (c <= 0x7FF) { //two bytes
36 | yield(0xC0 | ((c>>6) & 0x1F), 0x80 | (c & 0x3F));
37 | }
38 | else if (!((c >= 0xd800) && (c <= 0xdbff))) { //!IsHighSurrogate(c)
39 | //(IsLowSurrogate(c))
40 | if ((c >= 0xdc00) && (c <= 0xdfff)) { raise InvalidSurrogatePairException; }
41 | else { //three bytes
42 | yield(0xE0| ((c>>12) & 0xF), 0x80 | ((c>>6) & 0x3F), 0x80 | (c&0x3F));
43 | }
44 | }
45 | else {
46 | yield (0xF0|(((1+((c>>6)&0xF))>>2)&7), (0x80|(((1+((c>>6)&0xF))&3)<<4))|((c>>2) & 0xF));
47 | HS:=true; hs:=c&3; }
48 | } end {
49 | case (HS): raise InvalidSurrogatePairException;
50 | case (true): yield();
51 | };
52 | }
53 | */
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bek/decode.bek:
--------------------------------------------------------------------------------
1 | program decode(input) {
2 | return iter(c in input)[pc := 0;]{
3 | case (pc == 0) : //initial state
4 | if (c == '&') { pc := 1; }
5 | else { yield (c); }
6 | case (pc == 1) : //memorized &
7 | if (c == '&') { yield ('&'); }
8 | else if (c == 'l') { pc := 2; }
9 | else if (c == 'g') { pc := 3; }
10 | else { yield ('&',c); pc := 0; }
11 | case (pc == 2) : //memorized &l
12 | if (c == 't') { pc := 4; }
13 | else { yield ('&','l',c); pc := 0; }
14 | case (pc == 3) : //memorized &g
15 | if (c == 't') { pc := 5; }
16 | else { yield ('&','g',c); pc := 0; }
17 | case (pc == 4) : //memorized <
18 | if (c == ';')
19 | { yield ('<'); pc := 0; } //finished <
20 | else
21 | { yield ('&','l','t',c); pc := 0; }
22 | case (true) : //memorized >
23 | if (c == ';')
24 | { yield ('>'); pc := 0; } //finished >
25 | else
26 | { yield ('&','g','t',c); pc := 0; }
27 | } end {//final nonempty yields are unfinished patterns
28 | case (pc == 0) : yield ();
29 | case (pc == 1) : yield ('&');
30 | case (pc == 2) : yield ('&','l');
31 | case (pc == 3) : yield ('&','g');
32 | case (pc == 4) : yield ('&','l','t');
33 | case (true) : yield ('&','g','t');
34 | };
35 | }
36 |
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bek/escapeBrackets.bek:
--------------------------------------------------------------------------------
1 |
2 | //replace all occurrences of "<" by "<" and ">" by ">"
3 | program escapeBrackets(input) {
4 | return iter(c in input)
5 | {
6 | case (c == '<') :
7 | yield ('&');
8 | yield ('l');
9 | yield ('t');
10 | yield (';');
11 |
12 | case (c == '>') :
13 | yield ('&');
14 | yield ('g');
15 | yield ('t');
16 | yield (';');
17 |
18 | case(true):
19 | yield(c);
20 |
21 | };}
22 |
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bek/escapeString.bek:
--------------------------------------------------------------------------------
1 | program escapeString(t);
2 | string s1;
3 | string s2;
4 | string s3;
5 | string s4;
6 | string s5;
7 | s1 := iter(c in t){b := false;}
8 | {
9 | case (c == '&') :
10 | yield ('&');
11 | yield ('a');
12 | yield ('m');
13 | yield ('p');
14 | yield (';');
15 |
16 | case (true) :
17 | yield (c);
18 | };
19 | s2 := iter(c in s1){b := false;}
20 | {
21 | case (c == '<') :
22 | yield ('&');
23 | yield ('l');
24 | yield ('t');
25 | yield (';');
26 | case (true) :
27 | yield (c);
28 | };
29 | s3 := iter(c in s2){b := false;}
30 | {
31 | case (c == '>') :
32 | yield ('&');
33 | yield ('g');
34 | yield ('t');
35 | yield (';');
36 | case (true) :
37 | yield (c);
38 | };
39 | s4 := iter(c in s3){b := false;}
40 | {
41 | case (c == '\"') :
42 | yield ('&');
43 | yield ('q');
44 | yield ('u');
45 | yield ('o');
46 | yield ('t');
47 | yield (';');
48 | case (true) :
49 | yield (c);
50 | };
51 | s5 := iter(c in s4){b := false;}
52 | {
53 | case (c == '\'') :
54 | yield ('&');
55 | yield ('#');
56 | yield ('3');
57 | yield ('9');
58 | yield (';');
59 | case (true) :
60 | yield (c);
61 | };
62 |
63 |
64 | return s5;
65 |
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bek/identity.bek:
--------------------------------------------------------------------------------
1 | program trivial(t) {
2 | return iter(c in t) {
3 | case (true):
4 | yield (c);
5 | };
6 | }
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bek/test3.bek:
--------------------------------------------------------------------------------
1 |
2 | program test3(t);
3 | string s;
4 | s := iter(c in t){b := false;}
5 | {
6 | case (!(b) && ((c == '\'') || (c == '\"'))) :
7 | b := false;
8 | yield ('\\');
9 | yield (c);
10 |
11 | case (c == '\\') :
12 | b := !(b);
13 | yield (c);
14 |
15 | case (true) :
16 | b := false;
17 | yield (c);
18 |
19 | };
20 | return s;
21 |
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bek/test3b.bek:
--------------------------------------------------------------------------------
1 |
2 | program test3b(t);
3 | string s;
4 | s := iter(c in t){b := false;}
5 | {
6 | case (!(b) && ((c == '\'') || (c == '\"'))) :
7 | b := false;
8 | yield ('\\');
9 | yield (c);
10 |
11 | case (c == '\\') :
12 | b := !(b);
13 | yield (c);
14 | yield (c); // <-- bug
15 |
16 | case (true) :
17 | b := false;
18 | yield (c);
19 |
20 | };
21 | return s;
22 |
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bex/Base64Encode.bek:
--------------------------------------------------------------------------------
1 | /*
2 | function base64 maps x to the following base64-digit
3 | 0..25 ==> 'A'..'Z'
4 | 26..51 ==> 'a'..'z'
5 | 52..61 ==> '0'..'9'
6 | 62 ==> '+'
7 | 63 ==> '/'
8 | */
9 | function E(x)=(ite(x<=25,x+65,ite(x<=51,x+71,ite(x<=61,x-4,ite(x==62,'+','/')))));
10 |
11 | /*
12 | Base64 encoder of an input of bytes. For example base64encode("Man") = "TWFu".
13 | Any value > 0xFF raises an exception.
14 | */
15 | program base64encode(_){
16 | replace {
17 | "..." ==> [E(Bits(7,2,#0)), E((Bits(1,0,#0)<<4)|Bits(7,4,#1)), E((Bits(3,0,#1)<<2)|Bits(7,6,#2)), E(Bits(5,0,#2))];
18 | "..$" ==> [E(Bits(7,2,#0)), E((Bits(1,0,#0)<<4)|Bits(7,4,#1)), E(Bits(3,0,#1)<<2), '='];
19 | ".$" ==> [E(Bits(7,2,#0)), E((Bits(1,0,#0)<<4), '=', '='];
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bex/a2b.bek:
--------------------------------------------------------------------------------
1 |
2 | //replace "a" by "b"
3 |
4 | program a2b(_){
5 | replace {
6 | "a" ==> "b";
7 | };
8 | }
9 |
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bex/base16decode.bek:
--------------------------------------------------------------------------------
1 | function D(x)=ite(x < 58, x - 48, x - 55);
2 | program base16decode(input){
3 | replace {
4 | "[A-Z0-9]{2}" ==> [(D(#0) << 4) + D(#1)];
5 | }
6 | };
7 |
8 | /*
9 |
10 |
11 | function E(x)=ite(x < 10, x + 48, x + 55);
12 | function D(x)=ite(x < 58, x - 48, x - 55);
13 |
14 | program base16encode(input){
15 | replace {
16 | @"[\0-\xFF]" ==> [E(#0 >> 4),E(#0 & 0xF)];
17 | }
18 | }
19 |
20 | program base16decode(input){
21 | replace {
22 | "[A-Z0-9]{2}" ==> [(D(#0) << 4) + D(#1)];
23 | }
24 | }
25 | // Identity Encoder
26 | program ID(_){replace { "." ==> [#0];}}
27 | ==
28 | js(base16encode);
29 | BYTES = regex(@"^[\0-\xFF]*$"); //domain of sequences of bytes
30 | ID_BYTES = restrict(ID,BYTES); //identity over sequences of bytes
31 | ed = join(base16encode, base16decode); //composition, first encode then decode
32 | eq(ID_BYTES, ed);
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 | */
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bex/base16encode.bek:
--------------------------------------------------------------------------------
1 | function E(x)=ite(x < 10, x + 48, x + 55);
2 | program base16encode(input){
3 | replace {
4 | @"[\0-\xFF]" ==> [E(#0 >> 4),E(#0 & 0xF)];
5 | }
6 | };
7 |
--------------------------------------------------------------------------------
/src/Bek.Tests/Samples/Bex/encode_decode.bek:
--------------------------------------------------------------------------------
1 | program encode(input){ replace { "<" ==> "<"; ">" ==> ">"; else ==> [#0]; }} //. matches any character
2 |
3 | program decode(input){ replace { "<" ==> "<"; ">" ==> ">"; else ==> []; }}
4 |
5 | program id(input){ replace { "." ==> [#0]; }}
6 |
7 | /*
8 |
9 | ==
10 | //Is encode idempotent ?
11 | eq(join(encode,encode),encode);
12 | //Is decode idempotent ?
13 | eq(join(decode,decode),decode);
14 | //Is it true that for all inputs decode(encode(input)) = input ?
15 | eq(join(encode,decode),id);
16 | //Is it true that for all inputs encode(decode(input)) = input ?
17 | eq(join(decode,encode),id);
18 | //generate JavaScript for decode
19 | js(decode);
20 |
21 | */
22 |
--------------------------------------------------------------------------------
/src/Bek.Tests/bek_master.html:
--------------------------------------------------------------------------------
1 |
2 | Enter any text into the textbox below to see what the bek JavaScript outputs.
3 |
4 |
5 |
22 |
23 |
24 | Input is assumed to be an escaped JavaScript string. Example: OŒE and OŒE
25 | both represent OŒE
26 |
27 |
28 | type text in the textbox above...
29 |
30 |
--------------------------------------------------------------------------------
/src/Bek.Tests/packages.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/src/Bek/App.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
--------------------------------------------------------------------------------
/src/Bek/AutomataKey.snk:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/AutomataDotNet/Automata/0242132fdbe9687bea22b7144afa0784d7cd927b/src/Bek/AutomataKey.snk
--------------------------------------------------------------------------------
/src/Bek/Frontend/Meta.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Text;
4 | using Microsoft.Bek.Frontend.AST;
5 | using Microsoft.Bek.Frontend.TreeOps;
6 |
7 | namespace Microsoft.Bek.Frontend.Meta
8 | {
9 | public enum BekCharModes
10 | {
11 | //Unicode: code points are always < 2^16; all others are addressed using surrogate pairs as in .NET
12 | //BV32: only valid code points; surrogate pairs are consumed eagerly and converted to their target code point
13 |
14 | ///
15 | /// 7 bit ASCII encoding
16 | ///
17 | BV7 = 7,
18 | ///
19 | /// 8 bit Extended ASCII encoding
20 | ///
21 | BV8 = 8,
22 | ///
23 | /// 16 bit bit-vector encoding
24 | ///
25 | BV16 = 16,
26 | ///
27 | /// 32 bit bit-vector encoding
28 | ///
29 | BV32 = 32
30 | }
31 |
32 | public enum BekTypes
33 | {
34 | CHAR,
35 | STR,
36 | BOOL,
37 | ANY
38 | }
39 |
40 | public class AllowBekTypes : AllowTypes
41 | {
42 | public AllowBekTypes(params BekTypes[] allowed)
43 | {
44 | this.whichtypes = new List