OILS / _gen / display / pretty.asdl.cc View on Github | oils.pub

262 lines, 172 significant
1// _gen/display/pretty.asdl.cc is generated by asdl_main.py
2
3#include "_gen/display/pretty.asdl.h"
4#include <assert.h>
5#include "prebuilt/asdl/runtime.mycpp.h" // from mycpp
6
7// Generated code uses these types
8using hnode_asdl::hnode;
9using hnode_asdl::Field;
10using hnode_asdl::color_e;
11
12namespace pretty_asdl {
13
14
15hnode_t* MeasuredDoc::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
16 seen = seen ? seen : Alloc<Dict<int, bool>>();
17 int heap_id = ObjectId(this);
18 if (dict_contains(seen, heap_id)) {
19 return Alloc<hnode::AlreadySeen>(heap_id);
20 }
21 seen->set(heap_id, true);
22
23 hnode::Record* out_node = runtime::NewRecord(StrFromC("MeasuredDoc"));
24 List<Field*>* L = out_node->fields;
25
26 hnode_t* x0 = this->doc->PrettyTree(do_abbrev, seen);
27 L->append(Alloc<Field>(StrFromC("doc"), x0));
28
29 hnode_t* x1 = this->measure->PrettyTree(do_abbrev, seen);
30 L->append(Alloc<Field>(StrFromC("measure"), x1));
31
32 return out_node;
33}
34
35
36hnode_t* Measure::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
37 seen = seen ? seen : Alloc<Dict<int, bool>>();
38 int heap_id = ObjectId(this);
39 if (dict_contains(seen, heap_id)) {
40 return Alloc<hnode::AlreadySeen>(heap_id);
41 }
42 seen->set(heap_id, true);
43
44 hnode::Record* out_node = runtime::NewRecord(StrFromC("Measure"));
45 List<Field*>* L = out_node->fields;
46
47 hnode_t* x0 = ToPretty(this->flat);
48 L->append(Alloc<Field>(StrFromC("flat"), x0));
49
50 hnode_t* x1 = ToPretty(this->nonflat);
51 L->append(Alloc<Field>(StrFromC("nonflat"), x1));
52
53 return out_node;
54}
55
56
57hnode_t* List_Measured::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
58 seen = seen ? seen : Alloc<Dict<int, bool>>();
59 int heap_id = ObjectId(this);
60 if (dict_contains(seen, heap_id)) {
61 return Alloc<hnode::AlreadySeen>(heap_id);
62 }
63 seen->set(heap_id, true);
64
65 hnode::Array* out_node = Alloc<hnode::Array>(Alloc<List<hnode_t*>>());
66 for (ListIter<MeasuredDoc*> it(this); !it.Done(); it.Next()) {
67 MeasuredDoc* v_ = it.Value();
68 hnode_t* h = (v_ == nullptr) ? Alloc<hnode::Leaf>(StrFromC("_"),
69 color_e::OtherConst) : v_->PrettyTree(do_abbrev, seen);
70 out_node->children->append(h);
71 }
72 return out_node;
73}
74
75BigStr* doc_str(int tag, bool dot) {
76 char buf[32];
77 const char* v = nullptr;
78 switch (tag) {
79 case doc_e::Break:
80 v = "Break"; break;
81 case doc_e::Text:
82 v = "Text"; break;
83 case doc_e::Indent:
84 v = "Indent"; break;
85 case doc_e::Group:
86 v = "Group"; break;
87 case doc_e::Flat:
88 v = "Flat"; break;
89 case doc_e::IfFlat:
90 v = "IfFlat"; break;
91 case doc_e::Concat:
92 v = "Concat"; break;
93 default:
94 assert(0);
95 }
96 if (dot) {
97 snprintf(buf, 32, "doc.%s", v);
98 return StrFromC(buf);
99 } else {
100 return StrFromC(v);
101 }
102}
103
104hnode_t* doc__Break::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
105 seen = seen ? seen : Alloc<Dict<int, bool>>();
106 int heap_id = ObjectId(this);
107 if (dict_contains(seen, heap_id)) {
108 return Alloc<hnode::AlreadySeen>(heap_id);
109 }
110 seen->set(heap_id, true);
111
112 hnode::Record* out_node = runtime::NewRecord(doc_str(this->tag()));
113 List<Field*>* L = out_node->fields;
114
115 hnode_t* x0 = ToPretty(this->string);
116 L->append(Alloc<Field>(StrFromC("string"), x0));
117
118 return out_node;
119}
120
121
122hnode_t* doc__Text::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
123 seen = seen ? seen : Alloc<Dict<int, bool>>();
124 int heap_id = ObjectId(this);
125 if (dict_contains(seen, heap_id)) {
126 return Alloc<hnode::AlreadySeen>(heap_id);
127 }
128 seen->set(heap_id, true);
129
130 hnode::Record* out_node = runtime::NewRecord(doc_str(this->tag()));
131 List<Field*>* L = out_node->fields;
132
133 hnode_t* x0 = ToPretty(this->string);
134 L->append(Alloc<Field>(StrFromC("string"), x0));
135
136 return out_node;
137}
138
139
140hnode_t* doc__Indent::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
141 seen = seen ? seen : Alloc<Dict<int, bool>>();
142 int heap_id = ObjectId(this);
143 if (dict_contains(seen, heap_id)) {
144 return Alloc<hnode::AlreadySeen>(heap_id);
145 }
146 seen->set(heap_id, true);
147
148 hnode::Record* out_node = runtime::NewRecord(doc_str(this->tag()));
149 List<Field*>* L = out_node->fields;
150
151 hnode_t* x0 = ToPretty(this->indent);
152 L->append(Alloc<Field>(StrFromC("indent"), x0));
153
154 hnode_t* x1 = this->mdoc->PrettyTree(do_abbrev, seen);
155 L->append(Alloc<Field>(StrFromC("mdoc"), x1));
156
157 return out_node;
158}
159
160
161hnode_t* doc__Flat::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
162 seen = seen ? seen : Alloc<Dict<int, bool>>();
163 int heap_id = ObjectId(this);
164 if (dict_contains(seen, heap_id)) {
165 return Alloc<hnode::AlreadySeen>(heap_id);
166 }
167 seen->set(heap_id, true);
168
169 hnode::Record* out_node = runtime::NewRecord(doc_str(this->tag()));
170 List<Field*>* L = out_node->fields;
171
172 hnode_t* x0 = this->mdoc->PrettyTree(do_abbrev, seen);
173 L->append(Alloc<Field>(StrFromC("mdoc"), x0));
174
175 return out_node;
176}
177
178
179hnode_t* doc__IfFlat::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
180 seen = seen ? seen : Alloc<Dict<int, bool>>();
181 int heap_id = ObjectId(this);
182 if (dict_contains(seen, heap_id)) {
183 return Alloc<hnode::AlreadySeen>(heap_id);
184 }
185 seen->set(heap_id, true);
186
187 hnode::Record* out_node = runtime::NewRecord(doc_str(this->tag()));
188 List<Field*>* L = out_node->fields;
189
190 hnode_t* x0 = this->flat_mdoc->PrettyTree(do_abbrev, seen);
191 L->append(Alloc<Field>(StrFromC("flat_mdoc"), x0));
192
193 hnode_t* x1 = this->nonflat_mdoc->PrettyTree(do_abbrev, seen);
194 L->append(Alloc<Field>(StrFromC("nonflat_mdoc"), x1));
195
196 return out_node;
197}
198
199
200hnode_t* doc_t::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
201 switch (this->tag()) {
202 case doc_e::Break: {
203 doc__Break* obj = static_cast<doc__Break*>(this);
204 return obj->PrettyTree(do_abbrev, seen);
205 }
206 case doc_e::Text: {
207 doc__Text* obj = static_cast<doc__Text*>(this);
208 return obj->PrettyTree(do_abbrev, seen);
209 }
210 case doc_e::Indent: {
211 doc__Indent* obj = static_cast<doc__Indent*>(this);
212 return obj->PrettyTree(do_abbrev, seen);
213 }
214 case doc_e::Group: {
215 MeasuredDoc* obj = static_cast<MeasuredDoc*>(this);
216 return obj->PrettyTree(do_abbrev, seen);
217 }
218 case doc_e::Flat: {
219 doc__Flat* obj = static_cast<doc__Flat*>(this);
220 return obj->PrettyTree(do_abbrev, seen);
221 }
222 case doc_e::IfFlat: {
223 doc__IfFlat* obj = static_cast<doc__IfFlat*>(this);
224 return obj->PrettyTree(do_abbrev, seen);
225 }
226 case doc_e::Concat: {
227 List_Measured* obj = static_cast<List_Measured*>(this);
228 return obj->PrettyTree(do_abbrev, seen);
229 }
230 default:
231 assert(0);
232 }
233}
234
235hnode_t* DocFragment::PrettyTree(bool do_abbrev, Dict<int, bool>* seen) {
236 seen = seen ? seen : Alloc<Dict<int, bool>>();
237 int heap_id = ObjectId(this);
238 if (dict_contains(seen, heap_id)) {
239 return Alloc<hnode::AlreadySeen>(heap_id);
240 }
241 seen->set(heap_id, true);
242
243 hnode::Record* out_node = runtime::NewRecord(StrFromC("DocFragment"));
244 List<Field*>* L = out_node->fields;
245
246 hnode_t* x0 = this->mdoc->PrettyTree(do_abbrev, seen);
247 L->append(Alloc<Field>(StrFromC("mdoc"), x0));
248
249 hnode_t* x1 = ToPretty(this->indent);
250 L->append(Alloc<Field>(StrFromC("indent"), x1));
251
252 hnode_t* x2 = ToPretty(this->is_flat);
253 L->append(Alloc<Field>(StrFromC("is_flat"), x2));
254
255 hnode_t* x3 = this->measure->PrettyTree(do_abbrev, seen);
256 L->append(Alloc<Field>(StrFromC("measure"), x3));
257
258 return out_node;
259}
260
261
262} // namespace pretty_asdl