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
137
138
139
140
141
142
143
144
|
/*
*/
#include "crate.hpp"
#include "ast.hpp"
#include "../parse/parseerror.hpp"
#include <serialiser_texttree.hpp>
namespace {
void iterate_module(::AST::Module& mod, ::std::function<void(::AST::Module& mod)> fcn)
{
fcn(mod);
for( auto& sm : mod.items() )
{
TU_MATCH_DEF(::AST::Item, (sm.data), (e),
( ),
(Module,
iterate_module(e, fcn);
)
)
}
}
}
namespace AST {
Crate::Crate():
m_root_module(::AST::Path("",{})),
m_load_std(LOAD_STD)
{
}
void Crate::load_externs()
{
auto cb = [this](Module& mod) {
for( const auto& it : mod.items() )
{
if( it.data.is_Crate() ) {
const auto& name = it.data.as_Crate().name;
throw ::std::runtime_error( FMT("TODO: Load crate '" << name << "' as '" << it.name << "'") );
}
}
};
iterate_module(m_root_module, cb);
}
Module& Crate::get_root_module(const ::std::string& name) {
return const_cast<Module&>( const_cast<const Crate*>(this)->get_root_module(name) );
}
const Module& Crate::get_root_module(const ::std::string& name) const {
if( name == "" )
return m_root_module;
auto it = m_extern_crates.find(name);
if( it != m_extern_crates.end() )
throw ::std::runtime_error("TODO: Get root module for extern crate");
// return it->second.root_module();
throw ParseError::Generic("crate name unknown");
}
void Crate::load_extern_crate(::std::string name)
{
::std::ifstream is("output/"+name+".ast");
if( !is.is_open() )
{
throw ParseError::Generic("Can't open crate '" + name + "'");
}
Deserialiser_TextTree ds(is);
Deserialiser& d = ds;
ExternCrate ret;
ret.deserialise( d );
m_extern_crates.insert( make_pair(::std::move(name), ::std::move(ret)) );
}
SERIALISE_TYPE(Crate::, "AST_Crate", {
unsigned ls = m_load_std;
s.item(ls);
s.item(m_extern_crates);
s.item(m_root_module);
},{
unsigned ls = m_load_std;
s.item(ls);
m_load_std = (::AST::Crate::LoadStd)ls;
s.item(m_extern_crates);
s.item(m_root_module);
})
ExternCrate::ExternCrate()
{
}
ExternCrate::ExternCrate(const char *path)
{
throw ParseError::Todo( FMT("Load extern crate from a file - '" << path << "'") );
}
// Fill runtime-generated structures in the crate
#if 0
void ExternCrate::prescan()
{
TRACE_FUNCTION;
Crate& cr = m_crate;
cr.m_root_module.prescan();
for( const auto& mi : cr.m_root_module.macro_imports_res() )
{
DEBUG("Macro (I) '"<<mi.name<<"' is_pub="<<mi.is_pub);
if( mi.is_pub )
{
m_crate.m_exported_macros.insert( ::std::make_pair(mi.name, mi.data) );
}
}
for( const auto& mi : cr.m_root_module.macros() )
{
DEBUG("Macro '"<<mi.name<<"' is_pub="<<mi.is_pub);
if( mi.is_pub )
{
m_crate.m_exported_macros.insert( ::std::make_pair(mi.name, &mi.data) );
}
}
}
#endif
const MacroRules* ExternCrate::find_macro_rules(const ::std::string& name)
{
auto i = m_mr_macros.find(name);
if(i != m_mr_macros.end())
return &*i->second;
return nullptr;
}
SERIALISE_TYPE(ExternCrate::, "AST_ExternCrate", {
(void)s;
},{
(void)s;
})
} // namespace AST
|
