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
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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
#ifndef MACROS_HPP_INCLUDED
#define MACROS_HPP_INCLUDED
#include "parse/lex.hpp"
#include "parse/tokentree.hpp"
#include <common.hpp>
#include <map>
#include <memory>
#include <cstring>
class MacroExpander;
namespace AST {
class Module;
}
class MacroRuleEnt:
public Serialisable
{
friend class MacroExpander;
Token tok;
::std::string name;
::std::vector<MacroRuleEnt> subpats;
public:
MacroRuleEnt():
tok(TOK_NULL),
name("")
{
}
MacroRuleEnt(Token tok):
tok(tok),
name("")
{
}
MacroRuleEnt(::std::string name):
name(name)
{
}
MacroRuleEnt(Token tok, ::std::vector<MacroRuleEnt> subpats):
tok(tok),
subpats(subpats)
{
}
friend ::std::ostream& operator<<(::std::ostream& os, const MacroRuleEnt& x);
SERIALISABLE_PROTOTYPES();
};
struct MacroPatEnt:
public Serialisable
{
::std::string name;
Token tok;
::std::vector<MacroPatEnt> subpats;
enum Type {
PAT_TOKEN,
PAT_TT,
PAT_PAT,
PAT_IDENT,
PAT_PATH,
PAT_TYPE,
PAT_EXPR,
PAT_STMT,
PAT_BLOCK,
PAT_META,
PAT_LOOP, // Enables use of subpats
} type;
MacroPatEnt():
tok(TOK_NULL),
type(PAT_TOKEN)
{
}
MacroPatEnt(Token tok):
tok(tok),
type(PAT_TOKEN)
{
}
MacroPatEnt(::std::string name, Type type):
name(name),
tok(),
type(type)
{
}
MacroPatEnt(Token sep, bool need_once, ::std::vector<MacroPatEnt> ents):
name( need_once ? "+" : "*" ),
tok(sep),
subpats( move(ents) ),
type(PAT_LOOP)
{
}
friend ::std::ostream& operator<<(::std::ostream& os, const MacroPatEnt& x);
SERIALISABLE_PROTOTYPES();
};
/// A rule within a macro_rules! blcok
class MacroRule:
public Serialisable
{
public:
::std::vector<MacroPatEnt> m_pattern;
::std::vector<MacroRuleEnt> m_contents;
SERIALISABLE_PROTOTYPES();
};
/// A sigle 'macro_rules!' block
class MacroRules:
public Serialisable
{
public:
bool m_exported;
::std::vector<MacroRule> m_rules;
MacroRules()
{
}
MacroRules( ::std::vector<MacroRule> rules ):
m_rules( mv$(rules) )
{
}
SERIALISABLE_PROTOTYPES();
};
extern ::std::unique_ptr<TokenStream> Macro_InvokeRules(const char *name, const MacroRules& rules, TokenTree input);
extern ::std::unique_ptr<TokenStream> Macro_Invoke(const TokenStream& lex, const ::std::string& name, TokenTree input);
#endif // MACROS_HPP_INCLUDED
|
