Goose  Check-in [3acca150d3]

Many hyperlinks are disabled.
Use anonymous login to enable hyperlinks.

Overview
Comment:ir, lexer: defined a new term type for block delimiters.
Downloads: Tarball | ZIP archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 3acca150d3da7157eb4155c0ccb7a846fad637f4c8493d653d77ff9647d21dad
User & Date: achavasse 2019-01-23 13:48:31.047
Context
2019-01-23
15:51
Parser: parenthese blocks. check-in: 13f2fade56 user: achavasse tags: trunk
13:48
ir, lexer: defined a new term type for block delimiters. check-in: 3acca150d3 user: achavasse tags: trunk
13:35
Parser: fixed a couple of error handling issues. check-in: 81d676111f user: achavasse tags: trunk
Changes
Unified Diff Ignore Whitespace Patch
Changes to bs/ir/graphviz.inl.
︙︙
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

        for( auto&& [k,v] : trie.m_branches )
        {
            GraphVizBuilder::Row row( builder );

            {
                GraphVizBuilder::Cell cell( builder );
                GraphVizBuilder::Color col( builder );
                builder.output() << k;
            }

            next( v );
        }
    }

    //--------------------------------------------------------------------------------------------








|








17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

        for( auto&& [k,v] : trie.m_branches )
        {
            GraphVizBuilder::Row row( builder );

            {
                GraphVizBuilder::Cell cell( builder );
                GraphVizBuilder::Color col( builder );
                ToString( builder.output(), k );
            }

            next( v );
        }
    }

    //--------------------------------------------------------------------------------------------
︙︙
Changes to bs/ir/term.h. 
1
2
3
4
5
6










7
8
9
10
11
12

13
14
15
16
17
18
19

#ifndef EMPATHY_IR_TERM_H
#define EMPATHY_IR_TERM_H

namespace empathy::ir
{
    class Vector;











    using TermVariant = variant
    <
        uint64_t,
        string,
        StringId,

        AnyTerm,
        VecOfLength,
        ptr< void >,
        pvec
    >;

    class Term







>
>
>
>
>
>
>
>
>
>






>








1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#ifndef EMPATHY_IR_TERM_H
#define EMPATHY_IR_TERM_H

namespace empathy::ir
{
    class Vector;

    enum class Delimiter
    {
        OpenParen,
        CloseParen,
        OpenBrace,
        CloseBrace,
        OpenBracket,
        CloseBracket
    };

    using TermVariant = variant
    <
        uint64_t,
        string,
        StringId,
        Delimiter,
        AnyTerm,
        VecOfLength,
        ptr< void >,
        pvec
    >;

    class Term
︙︙
Changes to bs/ir/tostring.cpp.
︙︙
12
13
14
15
16
17
18


































19
20
21
22
23
24
25

        return out << '"' << x << '"';
    }

    ostream& ToString( ostream& out, const StringId& x )
    {
        return out << x;
    }



































    ostream& ToString( ostream& out, const ptr< void >& x )
    {
        return out << "pvoid(" << x << ')';
    }

    ostream& ToString( ostream& out, const AnyTerm& v )








>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>








12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

        return out << '"' << x << '"';
    }

    ostream& ToString( ostream& out, const StringId& x )
    {
        return out << x;
    }

    ostream& ToString( ostream& out, const Delimiter& x )
    {
        const char* name = "";

        switch( x )
        {
            case Delimiter::OpenParen:
                name = "OpenParen";
                break;

            case Delimiter::CloseParen:
                name = "CloseParen";
                break;

            case Delimiter::OpenBrace:
                name = "OpenBrace";
                break;

            case Delimiter::CloseBrace:
                name = "CloseBrace";
                break;

            case Delimiter::OpenBracket:
                name = "OpenBracket";
                break;

            case Delimiter::CloseBracket:
                name = "CloseBracket";
                break;
        }

        return out << name;
    }

    ostream& ToString( ostream& out, const ptr< void >& x )
    {
        return out << "pvoid(" << x << ')';
    }

    ostream& ToString( ostream& out, const AnyTerm& v )
︙︙
Changes to bs/ir/tostring.h. 
1
2
3
4
5
6
7

8
9
10
11

12
13
14
15
16
17

#ifndef EMPATHY_IR_TOSTRING_H
#define EMPATHY_IR_TOSTRING_H

namespace empathy::ir
{
    class Vector;
    class Term;


    extern ostream& ToString( ostream& out, const uint64_t& x );
    extern ostream& ToString( ostream& out, const string& x );
    extern ostream& ToString( ostream& out, const StringId& x );

    extern ostream& ToString( ostream& out, const ptr< void >& x );
    extern ostream& ToString( ostream& out, const ptr< Vector >& v );
    extern ostream& ToString( ostream& out, const Term& t );
}

#endif








>




>







1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#ifndef EMPATHY_IR_TOSTRING_H
#define EMPATHY_IR_TOSTRING_H

namespace empathy::ir
{
    class Vector;
    class Term;
    enum class Delimiter;

    extern ostream& ToString( ostream& out, const uint64_t& x );
    extern ostream& ToString( ostream& out, const string& x );
    extern ostream& ToString( ostream& out, const StringId& x );
    extern ostream& ToString( ostream& out, const Delimiter& x );
    extern ostream& ToString( ostream& out, const ptr< void >& x );
    extern ostream& ToString( ostream& out, const ptr< Vector >& v );
    extern ostream& ToString( ostream& out, const Term& t );
}

#endif
Changes to bs/ir/trie.h. 
1
2
3
4
5


6
7
8
9
10
11
12

#ifndef EMPATHY_IR_TRIE_H
#define EMPATHY_IR_TRIE_H

namespace empathy::ir
{


    class AnyTerm;
    using pvec = ptr< Vector >;

    template< typename T, typename U >
    struct TrieNode
    {};







>
>








1
2
3
4
5
6
7
8
9
10
11
12
13
14

#ifndef EMPATHY_IR_TRIE_H
#define EMPATHY_IR_TRIE_H

namespace empathy::ir
{
    enum class Delimiter;

    class AnyTerm;
    using pvec = ptr< Vector >;

    template< typename T, typename U >
    struct TrieNode
    {};
︙︙
23
24
25
26
27
28
29




30
31
32
33
34
35
36

    template< typename U >
    struct TrieNode< string, U > : public ValueTrieNode< string, U >
    {};

    template< typename U >
    struct TrieNode< StringId, U > : public ValueTrieNode< StringId, U >
    {};





    template< typename U >
    struct TrieNode< AnyTerm, U > : public ValueTrieNode< AnyTerm, U >
    {};

    template< typename U >
    struct TrieNode< VecOfLength, U > : public ValueTrieNode< VecOfLength, U >








>
>
>
>








25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

    template< typename U >
    struct TrieNode< string, U > : public ValueTrieNode< string, U >
    {};

    template< typename U >
    struct TrieNode< StringId, U > : public ValueTrieNode< StringId, U >
    {};

    template< typename U >
    struct TrieNode< Delimiter, U > : public ValueTrieNode< Delimiter, U >
    {};

    template< typename U >
    struct TrieNode< AnyTerm, U > : public ValueTrieNode< AnyTerm, U >
    {};

    template< typename U >
    struct TrieNode< VecOfLength, U > : public ValueTrieNode< VecOfLength, U >
︙︙
58
59
60
61
62
63
64

65
66
67
68
69
70
71

    {
        public:
            using BranchesTuple = tuple
            <
                ptr< TrieNode< uint64_t, U > >,
                ptr< TrieNode< string, U > >,
                ptr< TrieNode< StringId, U > >,

                ptr< TrieNode< AnyTerm, U > >,
                ptr< TrieNode< VecOfLength, U > >,
                ptr< TrieNode< ptr< void >, U > >,
                ptr< TrieNode< pvec, U > >
            >;

            const auto& branches() const { return m_branches; }








>








64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

    {
        public:
            using BranchesTuple = tuple
            <
                ptr< TrieNode< uint64_t, U > >,
                ptr< TrieNode< string, U > >,
                ptr< TrieNode< StringId, U > >,
                ptr< TrieNode< Delimiter, U > >,
                ptr< TrieNode< AnyTerm, U > >,
                ptr< TrieNode< VecOfLength, U > >,
                ptr< TrieNode< ptr< void >, U > >,
                ptr< TrieNode< pvec, U > >
            >;

            const auto& branches() const { return m_branches; }
︙︙
Changes to bs/lex/lexer.cpp.
︙︙
205
206
207
208
209
210
211








212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241

        return readIntegerLiteral( move( loc ) );

    if( isalpha( c ) || c == '_' )
        return readAlphanumericIdentifier( move( loc ) );

    switch( c )
    {








        case '{':
            m_input.get();
            return Term( move( loc ), "{"_sid );

        case '}':
            m_input.get();
            return Term( move( loc ), "}"_sid );

        case '(':
            m_input.get();
            return Term( move( loc ), "("_sid );

        case ')':
            m_input.get();
            return Term( move( loc ), ")"_sid );

        case '[':
            m_input.get();
            return Term( move( loc ), "["_sid );

        case ']':
            m_input.get();
            return Term( move( loc ), "]"_sid );

        case '"':
            m_input.get();
            return readStringLiteral( move( loc ) );

        case ';':
            return readSemicolon( move( loc ) );








>
>
>
>
>
>
>
>


|



|
<
<
<
<
<
<
<
<



|



|








205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226








227
228
229
230
231
232
233
234
235
236
237
238
239
240
241

        return readIntegerLiteral( move( loc ) );

    if( isalpha( c ) || c == '_' )
        return readAlphanumericIdentifier( move( loc ) );

    switch( c )
    {
        case '(':
            m_input.get();
            return Term( move( loc ), Delimiter::OpenParen );

        case ')':
            m_input.get();
            return Term( move( loc ), Delimiter::CloseParen );

        case '{':
            m_input.get();
            return Term( move( loc ), Delimiter::OpenBrace );

        case '}':
            m_input.get();
            return Term( move( loc ), Delimiter::CloseBrace );









        case '[':
            m_input.get();
            return Term( move( loc ), Delimiter::OpenBracket );

        case ']':
            m_input.get();
            return Term( move( loc ), Delimiter::CloseBracket );

        case '"':
            m_input.get();
            return readStringLiteral( move( loc ) );

        case ';':
            return readSemicolon( move( loc ) );
︙︙
Fossil 2.26 [1205ec86cb] 2025-04-30 16:57:32
This page was generated in about 0.019s