blob: 9d9fdb7da51def247f72ed579ff396dd0f04ecb6 (
plain)
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
|
// slang-ast-support-types.cpp
#include "slang-ast-support-types.h"
#include "slang-ast-base.h"
#include "slang-ast-expr.h"
#include "slang-ast-type.h"
#include "slang-check-impl.h"
namespace Slang
{
QualType::QualType(Type* type)
: type(type), isLeftValue(false)
{
if (auto refType = as<ExplicitRefType>(type))
{
if (auto optAccessQualifier = refType->tryGetAccessQualifierValue())
{
auto accessQualifier = *optAccessQualifier;
switch (accessQualifier)
{
case AccessQualifier::ReadWrite:
isLeftValue = true;
break;
case AccessQualifier::Read:
isLeftValue = false;
break;
default:
SLANG_UNEXPECTED("unhandled access qualifier");
break;
}
}
}
}
void removeModifier(ModifiableSyntaxNode* syntax, Modifier* toRemove)
{
Modifier* prev = nullptr;
for (auto modifier = syntax->modifiers.first; modifier; modifier = modifier->next)
{
if (modifier == toRemove)
{
if (prev)
{
prev->next = modifier->next;
}
else
{
syntax->modifiers.first = syntax->modifiers.first->next;
}
break;
}
prev = modifier;
}
}
Expr* getInnerMostExprFromHigherOrderExpr(Expr* expr, FunctionDifferentiableLevel& outLevel)
{
HashSet<Expr*> workListSet;
outLevel = FunctionDifferentiableLevel::None;
while (auto higherOrder = as<HigherOrderInvokeExpr>(expr))
{
if (as<BackwardDifferentiateExpr>(expr))
outLevel = FunctionDifferentiableLevel::Backward;
else if (
as<ForwardDifferentiateExpr>(expr) && outLevel == FunctionDifferentiableLevel::None)
outLevel = FunctionDifferentiableLevel::Forward;
if (workListSet.add(higherOrder))
{
expr = higherOrder->baseFunction;
}
else
{
// Circularity, return null.
return nullptr;
}
}
return expr;
}
UnownedStringSlice getHigherOrderOperatorName(HigherOrderInvokeExpr* expr)
{
if (as<ForwardDifferentiateExpr>(expr))
return UnownedStringSlice("fwd_diff");
else if (as<BackwardDifferentiateExpr>(expr))
return UnownedStringSlice("bwd_diff");
return UnownedStringSlice();
}
void printDiagnosticArg(StringBuilder& sb, ParameterDirection direction)
{
switch (direction)
{
case kParameterDirection_In:
sb << "in";
break;
case kParameterDirection_Out:
sb << "out";
break;
case kParameterDirection_Ref:
sb << "ref";
break;
case kParameterDirection_InOut:
sb << "inout";
break;
case kParameterDirection_ConstRef:
sb << "constref";
break;
default:
sb << "(" << int(direction) << ")";
break;
}
}
} // namespace Slang
|
