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
|
/*
* Copyright 2021 Google LLC.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SKSL_DSL_FUNCTION
#define SKSL_DSL_FUNCTION
#include "include/sksl/DSLBlock.h"
#include "include/sksl/DSLExpression.h"
#include "include/sksl/DSLType.h"
#include "include/sksl/DSLVar.h"
#include "include/sksl/DSLWrapper.h"
namespace SkSL {
class Block;
class FunctionDeclaration;
class Variable;
namespace dsl {
class DSLType;
class DSLFunction {
public:
template<class... Parameters>
DSLFunction(const DSLType& returnType, skstd::string_view name, Parameters&... parameters)
: DSLFunction(DSLModifiers(), returnType, name, parameters...) {}
template<class... Parameters>
DSLFunction(const DSLModifiers& modifiers, const DSLType& returnType, skstd::string_view name,
Parameters&... parameters) {
SkTArray<DSLParameter*> parameterArray;
parameterArray.reserve_back(sizeof...(parameters));
// in C++17, we could just do:
// (parameterArray.push_back(¶meters), ...);
int unused[] = {0, (static_cast<void>(parameterArray.push_back(¶meters)), 0)...};
static_cast<void>(unused);
// We can't have a default parameter and a template parameter pack at the same time, so
// unfortunately we can't capture position info from this overload.
this->init(modifiers, returnType, name, std::move(parameterArray), PositionInfo());
}
DSLFunction(const DSLType& returnType, skstd::string_view name,
SkTArray<DSLParameter*> parameters, PositionInfo pos = PositionInfo::Capture()) {
this->init(DSLModifiers(), returnType, name, std::move(parameters), pos);
}
DSLFunction(const DSLModifiers& modifiers, const DSLType& returnType, skstd::string_view name,
SkTArray<DSLParameter*> parameters, PositionInfo pos = PositionInfo::Capture()) {
this->init(modifiers, returnType, name, std::move(parameters), pos);
}
DSLFunction(const SkSL::FunctionDeclaration* decl)
: fDecl(decl) {}
virtual ~DSLFunction() = default;
template<class... Stmt>
void define(Stmt... stmts) {
DSLBlock block = DSLBlock(DSLStatement(std::move(stmts))...);
this->define(std::move(block));
}
void define(DSLBlock block, PositionInfo pos = PositionInfo::Capture());
/**
* Invokes the function with the given arguments.
*/
template<class... Args>
DSLExpression operator()(Args&&... args) {
ExpressionArray argArray;
argArray.reserve_back(sizeof...(args));
this->collectArgs(argArray, std::forward<Args>(args)...);
return this->call(std::move(argArray));
}
/**
* Invokes the function with the given arguments.
*/
DSLExpression call(SkTArray<DSLWrapper<DSLExpression>> args,
PositionInfo pos = PositionInfo::Capture());
DSLExpression call(ExpressionArray args, PositionInfo pos = PositionInfo::Capture());
private:
void collectArgs(ExpressionArray& args) {}
template<class... RemainingArgs>
void collectArgs(ExpressionArray& args, DSLVar& var, RemainingArgs&&... remaining) {
args.push_back(DSLExpression(var).release());
collectArgs(args, std::forward<RemainingArgs>(remaining)...);
}
template<class... RemainingArgs>
void collectArgs(ExpressionArray& args, DSLExpression expr, RemainingArgs&&... remaining) {
args.push_back(expr.release());
collectArgs(args, std::forward<RemainingArgs>(remaining)...);
}
void init(DSLModifiers modifiers, const DSLType& returnType, skstd::string_view name,
SkTArray<DSLParameter*> params, PositionInfo pos);
const SkSL::FunctionDeclaration* fDecl = nullptr;
SkSL::PositionInfo fPosition;
};
} // namespace dsl
} // namespace SkSL
#endif
|
