]> git.tdb.fi Git - libs/gl.git/blob - source/glsl/debug.cpp
Check the flat qualifier from the correct member
[libs/gl.git] / source / glsl / debug.cpp
1 #include <msp/stringcodec/utf8.h>
2 #include <msp/strings/format.h>
3 #include "debug.h"
4
5 using namespace std;
6
7 namespace Msp {
8 namespace GL {
9 namespace SL {
10
11 const DumpTree::Colors DumpTree::no_colors =
12 { "", "", "", "", "", "", "" };
13
14 const DumpTree::Colors DumpTree::default_colors =
15 {
16         "\033[0m",         // default
17         "\033[38;5;250m",  // tree
18         "\033[38;5;244m",  // location
19         "\033[38;5;146m",  // label
20         "\033[38;5;194m",  // type
21         "\033[38;5;230m",  // name
22         "\033[38;5;210m"   // error
23 };
24
25 DumpTree::DumpTree(bool use_colors):
26         colors(use_colors ? default_colors : no_colors)
27 { }
28
29 string DumpTree::apply(Stage &stage)
30 {
31         formatted = format("Stage: %s\n", Stage::get_stage_name(stage.type));
32         begin_sub();
33         append(format("Version: %d.%02d", stage.required_features.glsl_version.major, stage.required_features.glsl_version.minor));
34
35         for(const auto &kvp: stage.types)
36                 append(format("Type: %s %s%s%s", get_label(*kvp.second), colors.type_color, kvp.first, colors.default_color));
37
38         for(const auto &kvp: stage.interface_blocks)
39                 append(format("Interface block: %s %s", get_label(*kvp.second), format_name(kvp.first)));
40
41         for(const auto &kvp: stage.functions)
42                 append(format("Function: %s %s", get_label(*kvp.second), format_name(kvp.first)));
43
44         last_branch();
45         stage.content.visit(*this);
46         return formatted;
47 }
48
49 void DumpTree::append(const string &line)
50 {
51         formatted += colors.tree_color;
52         StringCodec::Utf8::Encoder enc;
53         for(auto i=tree.begin(); i!=tree.end(); )
54         {
55                 enc.encode_char(*i++, formatted);
56                 enc.encode_char((i==tree.end() ? REACH : EMPTY), formatted);
57         }
58         formatted += colors.default_color;
59         formatted += line;
60         formatted += '\n';
61 }
62
63 void DumpTree::append(const Node &node, const string &line)
64 {
65         string location;
66         if(node.source==BUILTIN_SOURCE)
67                 location = "builtin";
68         else if(node.source==INTERNAL_SOURCE)
69                 location = "internal";
70         else if(node.source==GENERATED_SOURCE)
71                 location = "generated";
72         else
73                 location = format("%s:%s", node.source, node.line);
74         append(format("%s<%s>%s %s", colors.location_color, location, colors.default_color, line));
75 }
76
77 void DumpTree::append_subtree(const vector<Branch> &branches)
78 {
79         begin_sub();
80         for(auto i=branches.begin(); i!=branches.end(); )
81         {
82                 auto j = increment(i, branches);
83                 if(!j->text.empty())
84                 {
85                         append(j->text);
86                         if(j->node)
87                         {
88                                 begin_sub();
89                                 last_branch();
90                                 j->node->visit(*this);
91                                 end_sub();
92                         }
93                 }
94                 else
95                         j->node->visit(*this);
96         }
97         end_sub();
98 }
99
100 void DumpTree::append_subtree(Node &node)
101 {
102         begin_sub();
103         last_branch();
104         node.visit(*this);
105         end_sub();
106 }
107
108 void DumpTree::begin_sub()
109 {
110         if(!tree.empty())
111                 tree.back() = (tree.back()==BRANCH_LAST ? EMPTY : STRAIGHT);
112         tree.push_back(BRANCH);
113 }
114
115 void DumpTree::last_branch()
116 {
117         tree.back() = BRANCH_LAST;
118 }
119
120 void DumpTree::end_sub()
121 {
122         tree.pop_back();
123         if(!tree.empty() && tree.back()==STRAIGHT)
124                 tree.back() = BRANCH;
125 }
126
127 std::string DumpTree::get_label(const Node &node)
128 {
129         unsigned &label = node_labels[&node];
130         if(!label)
131                 label = node_labels.size();
132         return format("%s%%%d%s", colors.label_color, label, colors.default_color);
133 }
134
135 string DumpTree::format_type(TypeDeclaration *type)
136 {
137         return type ? format_type(type->name) : format("%s?%s", colors.error_color, colors.default_color);
138 }
139
140 string DumpTree::format_type(const string &type)
141 {
142         return format("%s%s%s", colors.type_color, type, colors.default_color);
143 }
144
145 string DumpTree::format_name(const string &name)
146 {
147         return format("%s%s%s", colors.name_color, name, colors.default_color);
148 }
149
150 template<typename T>
151 typename T::const_iterator DumpTree::increment(typename T::const_iterator &iter, const T &container)
152 {
153         auto ret = iter++;
154         if(iter==container.end())
155                 last_branch();
156         return ret;
157 }
158
159 void DumpTree::visit(Block &block)
160 {
161         append(block, format("Block %s", (block.use_braces ? "{}" : "(inline)")));
162         begin_sub();
163
164         for(const auto &kvp: block.variables)
165                 append(format("Variable: %s %s %s", get_label(*kvp.second), format_type(kvp.second->type), format_name(kvp.first)));
166
167         for(auto i=block.body.cbegin(); i!=block.body.cend(); )
168         {
169                 auto j = increment(i, block.body);
170                 (*j)->visit(*this);
171         }
172
173         end_sub();
174 }
175
176 void DumpTree::visit(Literal &literal)
177 {
178         append(literal, format("Literal: %s -> %s", literal.token, format_type(literal.type)));
179 }
180
181 void DumpTree::visit(VariableReference &var)
182 {
183         string text;
184         if(var.declaration)
185                 text += format("%s ", get_label(*var.declaration));
186         text += format("%s -> %s", format_name(var.name), format_type(var.type));
187         append(var, text);
188 }
189
190 void DumpTree::visit(MemberAccess &memacc)
191 {
192         string text = "Member access:";
193         if(memacc.declaration)
194                 text += format(" %s", get_label(*memacc.declaration));
195         text += format(" .%s (%d) -> %s", format_name(memacc.member), memacc.index, format_type(memacc.type));
196         append(memacc, text);
197         append_subtree(*memacc.left);
198 }
199
200 void DumpTree::visit(Swizzle &swizzle)
201 {
202         static const char components[4] = { 'x', 'y', 'z', 'w' };
203         string text = "Swizzle: .";
204         for(unsigned i=0; i<swizzle.count; ++i)
205                 text += components[swizzle.components[i]];
206         text += format(" -> %s", format_type(swizzle.type));
207         append(swizzle, text);
208         append_subtree(*swizzle.left);
209 }
210
211 void DumpTree::visit(UnaryExpression &unary)
212 {
213         string text = format("Unary: %s, %sfix -> %s", unary.oper->token, (unary.oper->type==Operator::PREFIX ? "pre" : "post"), format_type(unary.type));
214         append(unary, text);
215         append_subtree(*unary.expression);
216 }
217
218 void DumpTree::visit(BinaryExpression &binary)
219 {
220         append(binary, format("Binary: %s%s -> %s", binary.oper->token, binary.oper->token2, format_type(binary.type)));
221         begin_sub();
222         binary.left->visit(*this);
223         last_branch();
224         binary.right->visit(*this);
225         end_sub();
226 }
227
228 void DumpTree::visit(Assignment &assign)
229 {
230         append(assign, format("Assignment: %s%s -> %s", assign.oper->token, (assign.self_referencing ? " (self-referencing)" : ""), format_type(assign.type)));
231         begin_sub();
232         if(assign.target.declaration)
233         {
234                 string text = format("Target: %s", get_label(*assign.target.declaration));
235
236                 static const char swizzle[4] = { 'x', 'y', 'z', 'w' };
237                 for(unsigned i=0; i<assign.target.chain_len; ++i)
238                 {
239                         unsigned component = assign.target.chain[i];
240                         switch(static_cast<Assignment::Target::ChainType>(component&0xC0))
241                         {
242                         case Assignment::Target::MEMBER:
243                                 text += format(" .%d", component&0x3F);
244                                 break;
245                         case Assignment::Target::SWIZZLE:
246                                 text += " .";
247                                 for(unsigned j=0; j<4; ++j)
248                                         if(component&(1<<j))
249                                                 text += swizzle[j];
250                                 break;
251                         case Assignment::Target::ARRAY:
252                                 text += format(" [%d]", component&0x3F);
253                                 break;
254                         }
255                 }
256                 append(text);
257         }
258         assign.left->visit(*this);
259         last_branch();
260         assign.right->visit(*this);
261         end_sub();
262 }
263
264 void DumpTree::visit(TernaryExpression &ternary)
265 {
266         append(ternary, format("Ternary: %s%s -> %s", ternary.oper->token, ternary.oper->token2, format_type(ternary.type)));
267         begin_sub();
268         ternary.condition->visit(*this);
269         ternary.true_expr->visit(*this);
270         last_branch();
271         ternary.false_expr->visit(*this);
272         end_sub();
273 }
274
275 void DumpTree::visit(FunctionCall &call)
276 {
277         string head = "Function call: ";
278         if(call.declaration)
279                 head += format("%s ", get_label(*call.declaration));
280         head += format_name(call.name);
281         if(call.constructor)
282                 head += " (constructor)";
283         head += format(" -> %s", format_type(call.type));
284         append(call, head);
285
286         begin_sub();
287         for(auto i=call.arguments.cbegin(); i!=call.arguments.cend(); )
288         {
289                 auto j = increment(i, call.arguments);
290                 (*j)->visit(*this);
291         }
292         end_sub();
293 }
294
295 void DumpTree::visit(ExpressionStatement &expr)
296 {
297         append(expr, "expr;");
298         append_subtree(*expr.expression);
299 }
300
301 void DumpTree::visit(Import &import)
302 {
303         append(import, format("import %s", import.module));
304 }
305
306 void DumpTree::visit(Precision &prec)
307 {
308         append(prec, format("precision %s %s", prec.precision, prec.type));
309 }
310
311 void DumpTree::visit(Layout &layout)
312 {
313         append(layout, "Layout");
314         begin_sub();
315         for(auto i=layout.qualifiers.cbegin(); i!=layout.qualifiers.cend(); )
316         {
317                 auto j = increment(i, layout.qualifiers);
318                 string qualifier = j->name;
319                 if(j->has_value)
320                         qualifier += format("=%d", j->value);
321                 append(qualifier);
322         }
323         end_sub();
324 }
325
326 void DumpTree::visit(InterfaceLayout &layout)
327 {
328         append(layout, format("Layout: %s", layout.interface));
329         append_subtree(layout.layout);
330 }
331
332 void DumpTree::visit(BasicTypeDeclaration &type)
333 {
334         append(type, format("%s typedef %s", get_label(type), format_type(type.name)));
335
336         vector<Branch> branches;
337         if(type.base_type)
338                 branches.emplace_back(format("%s: %s %s", (type.kind==BasicTypeDeclaration::ALIAS ? "Alias of" : "Base"), get_label(*type.base_type), format_type(type.base_type->name)));
339         if(type.kind==BasicTypeDeclaration::VECTOR)
340                 branches.emplace_back(format("Vector: %d", type.size));
341         else if(type.kind==BasicTypeDeclaration::MATRIX)
342                 branches.emplace_back(format("Matrix: %dx%d", type.size&0xFFFF, type.size>>16));
343         if(type.extended_alignment)
344                 branches.emplace_back("Extended alignment");
345         append_subtree(branches);
346 }
347
348 void DumpTree::visit(ImageTypeDeclaration &type)
349 {
350         static const char *const dims[] = { "1D", "2D", "3D", "Cube" };
351
352         append(type, format("%s typedef %s", get_label(type), format_type(type.name)));
353
354         vector<Branch> branches;
355         branches.emplace_back(format("Dimensions: %s%s", dims[type.dimensions-1], (type.array ? " array" : "")));
356         if(type.base_type)
357                 branches.emplace_back(format("Element type: %s %s", get_label(*type.base_type), format_type(type.base_type->name)));
358         if(!type.format.empty())
359                 branches.emplace_back(format("Texel format: %s", type.format));
360         if(type.sampled)
361                 branches.emplace_back("Sampled");
362         if(type.shadow)
363                 branches.emplace_back("Shadow");
364         if(type.multisample)
365                 branches.emplace_back("Multisample");
366         append_subtree(branches);
367 }
368
369 void DumpTree::visit(StructDeclaration &strct)
370 {
371         append(strct, format("%s struct %s", get_label(strct), strct.name));
372         vector<Branch> branches;
373         if(!strct.block_name.empty())
374                 branches.emplace_back(format("Interface block: %s", format_name(strct.block_name)));
375         if(strct.extended_alignment)
376                 branches.emplace_back("Extended alignment");
377         branches.emplace_back(&strct.members);
378         append_subtree(branches);
379 }
380
381 void DumpTree::visit(VariableDeclaration &var)
382 {
383         string decl = format("%s ", get_label(var));
384         if(var.constant)
385                 decl += "const ";
386         if(!var.interpolation.empty())
387                 decl += format("%s ", var.interpolation);
388         if(!var.sampling.empty())
389                 decl += format("%s ", var.sampling);
390         if(!var.interface.empty())
391                 decl += format("%s ", var.interface);
392         if(!var.precision.empty())
393                 decl += format("%s ", var.precision);
394         decl += format("%s %s", format_type(var.type), format_name(var.name));
395         if(var.source==BUILTIN_SOURCE)
396                 decl += " (builtin)";
397         else if(var.linked_declaration)
398                 decl += " (linked)";
399         append(var, decl);
400
401         vector<Branch> branches;
402         if(var.type_declaration)
403                 branches.emplace_back(format("Type: %s %s", get_label(*var.type_declaration), format_type(var.type_declaration->name)));
404         if(var.block_declaration)
405                 branches.emplace_back(format("Interface block: %s", format_name(var.block_declaration->block_name)));
406         if(var.layout)
407                 branches.emplace_back(var.layout.get());
408         if(var.array)
409         {
410                 if(var.array_size)
411                         branches.emplace_back("Array []", var.array_size.get());
412                 else
413                         branches.emplace_back("Array []");
414         }
415         if(var.init_expression)
416                 branches.emplace_back(var.init_expression.get());
417         append_subtree(branches);
418 }
419
420 void DumpTree::visit(FunctionDeclaration &func)
421 {
422         string text = format("%s %s %s%s", get_label(func), format_type(func.return_type), format_name(func.name), (func.signature.empty() ? "(?)" : func.signature));
423         if(func.source==BUILTIN_SOURCE)
424                 text += " (builtin)";
425         else if(!func.definition)
426                 text += " (undefined)";
427         append(func, text);
428
429         begin_sub();
430         if(func.return_type_declaration)
431                 append(format("Return type: %s %s", get_label(*func.return_type_declaration), format_type(func.return_type_declaration)));
432         for(const RefPtr<VariableDeclaration> &p: func.parameters)
433                 p->visit(*this);
434         last_branch();
435         if(func.definition==&func)
436                 func.body.visit(*this);
437         else if(func.definition)
438                 append(format("Definition: %s", get_label(*func.definition)));
439         end_sub();
440 }
441
442 void DumpTree::visit(Conditional &cond)
443 {
444         append(cond, "if()");
445
446         vector<Branch> branches;
447         branches.emplace_back(cond.condition.get());
448         branches.emplace_back("then", &cond.body);
449         if(!cond.else_body.body.empty())
450                 branches.emplace_back("else", &cond.else_body);
451         append_subtree(branches);
452 }
453
454 void DumpTree::visit(Iteration &iter)
455 {
456         append(iter, "for()");
457
458         vector<Branch> branches;
459         if(iter.init_statement)
460                 branches.emplace_back("Initialization", iter.init_statement.get());
461         if(iter.condition)
462                 branches.emplace_back("Condition", iter.condition.get());
463         if(iter.loop_expression)
464                 branches.emplace_back("Loop", iter.loop_expression.get());
465         branches.emplace_back(&iter.body);
466         append_subtree(branches);
467 }
468
469 void DumpTree::visit(Passthrough &pass)
470 {
471         append(pass, (pass.subscript ? "passthrough[]" : "passthrough"));
472         if(pass.subscript)
473                 append_subtree(*pass.subscript);
474 }
475
476 void DumpTree::visit(Return &ret)
477 {
478         append(ret, (ret.expression ? "return" : "return;"));
479         if(ret.expression)
480                 append_subtree(*ret.expression);
481 }
482
483 void DumpTree::visit(Jump &jump)
484 {
485         append(jump, format("%s;", jump.keyword));
486 }
487
488 } // namespace SL
489 } // namespace GL
490 } // namespace Msp