1 /*
2  * Copyright 2016 Google Inc.
3  *
4  * Use of this source code is governed by a BSD-style license that can be
5  * found in the LICENSE file.
6  */
7 
8 #ifndef SKSL_CONTEXT
9 #define SKSL_CONTEXT
10 
11 #include "src/sksl/ir/SkSLExpression.h"
12 #include "src/sksl/ir/SkSLType.h"
13 
14 namespace SkSL {
15 
16 /**
17  * Contains compiler-wide objects, which currently means the core types.
18  */
19 class Context {
20 public:
Context()21     Context()
22     : fInvalid_Type(new Type("<INVALID>"))
23     , fVoid_Type(new Type("void"))
24     , fNull_Type(new Type("null"))
25     , fFloatLiteral_Type(new Type("$floatLiteral", Type::kFloat_NumberKind, 3))
26     , fIntLiteral_Type(new Type("$intLiteral", Type::kSigned_NumberKind, 1))
27     , fDouble_Type(new Type("double", Type::kFloat_NumberKind, 6, true))
28     , fDouble2_Type(new Type("double2", *fDouble_Type, 2))
29     , fDouble3_Type(new Type("double3", *fDouble_Type, 3))
30     , fDouble4_Type(new Type("double4", *fDouble_Type, 4))
31     , fFloat_Type(new Type("float", Type::kFloat_NumberKind, 5, true))
32     , fFloat2_Type(new Type("float2", *fFloat_Type, 2))
33     , fFloat3_Type(new Type("float3", *fFloat_Type, 3))
34     , fFloat4_Type(new Type("float4", *fFloat_Type, 4))
35     , fHalf_Type(new Type("half", Type::kFloat_NumberKind, 4))
36     , fHalf2_Type(new Type("half2", *fHalf_Type, 2))
37     , fHalf3_Type(new Type("half3", *fHalf_Type, 3))
38     , fHalf4_Type(new Type("half4", *fHalf_Type, 4))
39     , fUInt_Type(new Type("uint", Type::kUnsigned_NumberKind, 2, true))
40     , fUInt2_Type(new Type("uint2", *fUInt_Type, 2))
41     , fUInt3_Type(new Type("uint3", *fUInt_Type, 3))
42     , fUInt4_Type(new Type("uint4", *fUInt_Type, 4))
43     , fInt_Type(new Type("int", Type::kSigned_NumberKind, 2, true))
44     , fInt2_Type(new Type("int2", *fInt_Type, 2))
45     , fInt3_Type(new Type("int3", *fInt_Type, 3))
46     , fInt4_Type(new Type("int4", *fInt_Type, 4))
47     , fUShort_Type(new Type("ushort", Type::kUnsigned_NumberKind, 0))
48     , fUShort2_Type(new Type("ushort2", *fUShort_Type, 2))
49     , fUShort3_Type(new Type("ushort3", *fUShort_Type, 3))
50     , fUShort4_Type(new Type("ushort4", *fUShort_Type, 4))
51     , fShort_Type(new Type("short", Type::kSigned_NumberKind, 0))
52     , fShort2_Type(new Type("short2", *fShort_Type, 2))
53     , fShort3_Type(new Type("short3", *fShort_Type, 3))
54     , fShort4_Type(new Type("short4", *fShort_Type, 4))
55     , fUByte_Type(new Type("ubyte", Type::kUnsigned_NumberKind, 0))
56     , fUByte2_Type(new Type("ubyte2", *fUByte_Type, 2))
57     , fUByte3_Type(new Type("ubyte3", *fUByte_Type, 3))
58     , fUByte4_Type(new Type("ubyte4", *fUByte_Type, 4))
59     , fByte_Type(new Type("byte", Type::kSigned_NumberKind, 0))
60     , fByte2_Type(new Type("byte2", *fByte_Type, 2))
61     , fByte3_Type(new Type("byte3", *fByte_Type, 3))
62     , fByte4_Type(new Type("byte4", *fByte_Type, 4))
63     , fBool_Type(new Type("bool", Type::kNonnumeric_NumberKind, -1))
64     , fBool2_Type(new Type("bool2", *fBool_Type, 2))
65     , fBool3_Type(new Type("bool3", *fBool_Type, 3))
66     , fBool4_Type(new Type("bool4", *fBool_Type, 4))
67     , fFloat2x2_Type(new Type("float2x2", *fFloat_Type, 2, 2))
68     , fFloat2x3_Type(new Type("float2x3", *fFloat_Type, 2, 3))
69     , fFloat2x4_Type(new Type("float2x4", *fFloat_Type, 2, 4))
70     , fFloat3x2_Type(new Type("float3x2", *fFloat_Type, 3, 2))
71     , fFloat3x3_Type(new Type("float3x3", *fFloat_Type, 3, 3))
72     , fFloat3x4_Type(new Type("float3x4", *fFloat_Type, 3, 4))
73     , fFloat4x2_Type(new Type("float4x2", *fFloat_Type, 4, 2))
74     , fFloat4x3_Type(new Type("float4x3", *fFloat_Type, 4, 3))
75     , fFloat4x4_Type(new Type("float4x4", *fFloat_Type, 4, 4))
76     , fHalf2x2_Type(new Type("half2x2", *fHalf_Type, 2, 2))
77     , fHalf2x3_Type(new Type("half2x3", *fHalf_Type, 2, 3))
78     , fHalf2x4_Type(new Type("half2x4", *fHalf_Type, 2, 4))
79     , fHalf3x2_Type(new Type("half3x2", *fHalf_Type, 3, 2))
80     , fHalf3x3_Type(new Type("half3x3", *fHalf_Type, 3, 3))
81     , fHalf3x4_Type(new Type("half3x4", *fHalf_Type, 3, 4))
82     , fHalf4x2_Type(new Type("half4x2", *fHalf_Type, 4, 2))
83     , fHalf4x3_Type(new Type("half4x3", *fHalf_Type, 4, 3))
84     , fHalf4x4_Type(new Type("half4x4", *fHalf_Type, 4, 4))
85     , fDouble2x2_Type(new Type("double2x2", *fDouble_Type, 2, 2))
86     , fDouble2x3_Type(new Type("double2x3", *fDouble_Type, 2, 3))
87     , fDouble2x4_Type(new Type("double2x4", *fDouble_Type, 2, 4))
88     , fDouble3x2_Type(new Type("double3x2", *fDouble_Type, 3, 2))
89     , fDouble3x3_Type(new Type("double3x3", *fDouble_Type, 3, 3))
90     , fDouble3x4_Type(new Type("double3x4", *fDouble_Type, 3, 4))
91     , fDouble4x2_Type(new Type("double4x2", *fDouble_Type, 4, 2))
92     , fDouble4x3_Type(new Type("double4x3", *fDouble_Type, 4, 3))
93     , fDouble4x4_Type(new Type("double4x4", *fDouble_Type, 4, 4))
94     , fTexture1D_Type(new Type("texture1D", SpvDim1D, false, false, false, true))
95     , fTexture2D_Type(new Type("texture2D", SpvDim2D, false, false, false, true))
96     , fTexture3D_Type(new Type("texture3D", SpvDim3D, false, false, false, true))
97     , fTextureExternalOES_Type(new Type("textureExternalOES", SpvDim2D, false, false, false, true))
98     , fTextureCube_Type(new Type("textureCube", SpvDimCube, false, false, false, true))
99     , fTexture2DRect_Type(new Type("texture2DRect", SpvDimRect, false, false, false, true))
100     , fTextureBuffer_Type(new Type("textureBuffer", SpvDimBuffer, false, false, false, true))
101     , fITexture2D_Type(new Type("itexture2D", SpvDim2D, false, false, false, true))
102     , fSampler1D_Type(new Type("sampler1D", *fTexture1D_Type))
103     , fSampler2D_Type(new Type("sampler2D", *fTexture2D_Type))
104     , fSampler3D_Type(new Type("sampler3D", *fTexture3D_Type))
105     , fSamplerExternalOES_Type(new Type("samplerExternalOES", *fTextureExternalOES_Type))
106     , fSamplerCube_Type(new Type("samplerCube", *fTextureCube_Type))
107     , fSampler2DRect_Type(new Type("sampler2DRect", *fTexture2DRect_Type))
108     , fSampler1DArray_Type(new Type("sampler1DArray"))
109     , fSampler2DArray_Type(new Type("sampler2DArray"))
110     , fSamplerCubeArray_Type(new Type("samplerCubeArray"))
111     , fSamplerBuffer_Type(new Type("samplerBuffer", *fTextureBuffer_Type))
112     , fSampler2DMS_Type(new Type("sampler2DMS"))
113     , fSampler2DMSArray_Type(new Type("sampler2DMSArray"))
114     , fSampler1DShadow_Type(new Type("sampler1DShadow"))
115     , fSampler2DShadow_Type(new Type("sampler2DShadow"))
116     , fSamplerCubeShadow_Type(new Type("samplerCubeShadow"))
117     , fSampler2DRectShadow_Type(new Type("sampler2DRectShadow"))
118     , fSampler1DArrayShadow_Type(new Type("sampler1DArrayShadow"))
119     , fSampler2DArrayShadow_Type(new Type("sampler2DArrayShadow"))
120     , fSamplerCubeArrayShadow_Type(new Type("samplerCubeArrayShadow"))
121 
122     // Related to below FIXME, gsampler*s don't currently expand to cover integer case.
123     , fISampler2D_Type(new Type("isampler2D", *fITexture2D_Type))
124 
125     , fSampler_Type(new Type("sampler", Type::kSeparateSampler_Kind))
126     // FIXME express these as "gimage2D" that expand to image2D, iimage2D, and uimage2D.
127     , fImage2D_Type(new Type("image2D", SpvDim2D, false, false, false, true))
128     , fIImage2D_Type(new Type("iimage2D", SpvDim2D, false, false, false, true))
129 
130     // FIXME express these as "gsubpassInput" that expand to subpassInput, isubpassInput,
131     // and usubpassInput.
132     , fSubpassInput_Type(new Type("subpassInput", SpvDimSubpassData, false, false,
133                                   false, false))
134     , fSubpassInputMS_Type(new Type("subpassInputMS", SpvDimSubpassData, false, false,
135                                     true, false))
136 
137     // FIXME figure out what we're supposed to do with the gsampler et al. types)
138     , fGSampler1D_Type(new Type("$gsampler1D", static_type(*fSampler1D_Type)))
139     , fGSampler2D_Type(new Type("$gsampler2D", static_type(*fSampler2D_Type)))
140     , fGSampler3D_Type(new Type("$gsampler3D", static_type(*fSampler3D_Type)))
141     , fGSamplerCube_Type(new Type("$gsamplerCube", static_type(*fSamplerCube_Type)))
142     , fGSampler2DRect_Type(new Type("$gsampler2DRect", static_type(*fSampler2DRect_Type)))
143     , fGSampler1DArray_Type(new Type("$gsampler1DArray",
144                                      static_type(*fSampler1DArray_Type)))
145     , fGSampler2DArray_Type(new Type("$gsampler2DArray",
146                                      static_type(*fSampler2DArray_Type)))
147     , fGSamplerCubeArray_Type(new Type("$gsamplerCubeArray",
148                                        static_type(*fSamplerCubeArray_Type)))
149     , fGSamplerBuffer_Type(new Type("$gsamplerBuffer", static_type(*fSamplerBuffer_Type)))
150     , fGSampler2DMS_Type(new Type("$gsampler2DMS", static_type(*fSampler2DMS_Type)))
151     , fGSampler2DMSArray_Type(new Type("$gsampler2DMSArray",
152                                        static_type(*fSampler2DMSArray_Type)))
153     , fGSampler2DArrayShadow_Type(new Type("$gsampler2DArrayShadow",
154                                            static_type(*fSampler2DArrayShadow_Type)))
155     , fGSamplerCubeArrayShadow_Type(new Type("$gsamplerCubeArrayShadow",
156                                              static_type(*fSamplerCubeArrayShadow_Type)))
157     , fGenType_Type(new Type("$genType", { fFloat_Type.get(), fFloat2_Type.get(),
158                                            fFloat3_Type.get(), fFloat4_Type.get() }))
159     , fGenHType_Type(new Type("$genHType", { fHalf_Type.get(), fHalf2_Type.get(),
160                                              fHalf3_Type.get(), fHalf4_Type.get() }))
161     , fGenDType_Type(new Type("$genDType", { fDouble_Type.get(), fDouble2_Type.get(),
162                                              fDouble3_Type.get(), fDouble4_Type.get() }))
163     , fGenIType_Type(new Type("$genIType", { fInt_Type.get(), fInt2_Type.get(),
164                                              fInt3_Type.get(), fInt4_Type.get() }))
165     , fGenUType_Type(new Type("$genUType", { fUInt_Type.get(), fUInt2_Type.get(),
166                                              fUInt3_Type.get(), fUInt4_Type.get() }))
167     , fGenBType_Type(new Type("$genBType", { fBool_Type.get(), fBool2_Type.get(),
168                                              fBool3_Type.get(), fBool4_Type.get() }))
169     , fMat_Type(new Type("$mat", { fFloat2x2_Type.get(),  fFloat2x3_Type.get(),
170                                    fFloat2x4_Type.get(),  fFloat3x2_Type.get(),
171                                    fFloat3x3_Type.get(),  fFloat3x4_Type.get(),
172                                    fFloat4x2_Type.get(),  fFloat4x3_Type.get(),
173                                    fFloat4x4_Type.get(),  fHalf2x2_Type.get(),
174                                    fHalf2x3_Type.get(),   fHalf2x4_Type.get(),
175                                    fHalf3x2_Type.get(),   fHalf3x3_Type.get(),
176                                    fHalf3x4_Type.get(),   fHalf4x2_Type.get(),
177                                    fHalf4x3_Type.get(),   fHalf4x4_Type.get(),
178                                    fDouble2x2_Type.get(), fDouble2x3_Type.get(),
179                                    fDouble2x4_Type.get(), fDouble3x2_Type.get(),
180                                    fDouble3x3_Type.get(), fDouble3x4_Type.get(),
181                                    fDouble4x2_Type.get(), fDouble4x3_Type.get(),
182                                    fDouble4x4_Type.get() }))
183     , fVec_Type(new Type("$vec", { fInvalid_Type.get(), fFloat2_Type.get(),
184                                            fFloat3_Type.get(), fFloat4_Type.get() }))
185     , fGVec_Type(new Type("$gvec"))
186     , fGVec2_Type(new Type("$gfloat2"))
187     , fGVec3_Type(new Type("$gfloat3"))
188     , fGVec4_Type(new Type("$gfloat4", static_type(*fFloat4_Type)))
189     , fHVec_Type(new Type("$hvec", { fInvalid_Type.get(), fHalf2_Type.get(),
190                                      fHalf3_Type.get(), fHalf4_Type.get() }))
191     , fDVec_Type(new Type("$dvec", { fInvalid_Type.get(), fDouble2_Type.get(),
192                                      fDouble3_Type.get(), fDouble4_Type.get() }))
193     , fIVec_Type(new Type("$ivec", { fInvalid_Type.get(), fInt2_Type.get(),
194                                      fInt3_Type.get(), fInt4_Type.get() }))
195     , fUVec_Type(new Type("$uvec", { fInvalid_Type.get(), fUInt2_Type.get(),
196                                      fUInt3_Type.get(), fUInt4_Type.get() }))
197     , fSVec_Type(new Type("$svec", { fInvalid_Type.get(), fShort2_Type.get(),
198                                      fShort3_Type.get(), fShort4_Type.get() }))
199     , fUSVec_Type(new Type("$usvec", { fInvalid_Type.get(), fUShort2_Type.get(),
200                                        fUShort3_Type.get(), fUShort4_Type.get() }))
201     , fByteVec_Type(new Type("$bytevec", { fInvalid_Type.get(), fByte2_Type.get(),
202                                      fByte3_Type.get(), fByte4_Type.get() }))
203     , fUByteVec_Type(new Type("$ubytevec", { fInvalid_Type.get(), fUByte2_Type.get(),
204                                        fUByte3_Type.get(), fUByte4_Type.get() }))
205     , fBVec_Type(new Type("$bvec", { fInvalid_Type.get(), fBool2_Type.get(),
206                                      fBool3_Type.get(), fBool4_Type.get() }))
207     , fSkCaps_Type(new Type("$sk_Caps"))
208     , fSkArgs_Type(new Type("$sk_Args"))
209     , fFragmentProcessor_Type(fp_type(fInt_Type.get(), fBool_Type.get()))
210     , fDefined_Expression(new Defined(*fInvalid_Type)) {}
211 
static_type(const Type & t)212     static std::vector<const Type*> static_type(const Type& t) {
213         return { &t, &t, &t, &t };
214     }
215 
216     const std::unique_ptr<Type> fInvalid_Type;
217     const std::unique_ptr<Type> fVoid_Type;
218     const std::unique_ptr<Type> fNull_Type;
219     const std::unique_ptr<Type> fFloatLiteral_Type;
220     const std::unique_ptr<Type> fIntLiteral_Type;
221 
222     const std::unique_ptr<Type> fDouble_Type;
223     const std::unique_ptr<Type> fDouble2_Type;
224     const std::unique_ptr<Type> fDouble3_Type;
225     const std::unique_ptr<Type> fDouble4_Type;
226 
227     const std::unique_ptr<Type> fFloat_Type;
228     const std::unique_ptr<Type> fFloat2_Type;
229     const std::unique_ptr<Type> fFloat3_Type;
230     const std::unique_ptr<Type> fFloat4_Type;
231 
232     const std::unique_ptr<Type> fHalf_Type;
233     const std::unique_ptr<Type> fHalf2_Type;
234     const std::unique_ptr<Type> fHalf3_Type;
235     const std::unique_ptr<Type> fHalf4_Type;
236 
237     const std::unique_ptr<Type> fUInt_Type;
238     const std::unique_ptr<Type> fUInt2_Type;
239     const std::unique_ptr<Type> fUInt3_Type;
240     const std::unique_ptr<Type> fUInt4_Type;
241 
242     const std::unique_ptr<Type> fInt_Type;
243     const std::unique_ptr<Type> fInt2_Type;
244     const std::unique_ptr<Type> fInt3_Type;
245     const std::unique_ptr<Type> fInt4_Type;
246 
247     const std::unique_ptr<Type> fUShort_Type;
248     const std::unique_ptr<Type> fUShort2_Type;
249     const std::unique_ptr<Type> fUShort3_Type;
250     const std::unique_ptr<Type> fUShort4_Type;
251 
252     const std::unique_ptr<Type> fShort_Type;
253     const std::unique_ptr<Type> fShort2_Type;
254     const std::unique_ptr<Type> fShort3_Type;
255     const std::unique_ptr<Type> fShort4_Type;
256 
257     const std::unique_ptr<Type> fUByte_Type;
258     const std::unique_ptr<Type> fUByte2_Type;
259     const std::unique_ptr<Type> fUByte3_Type;
260     const std::unique_ptr<Type> fUByte4_Type;
261 
262     const std::unique_ptr<Type> fByte_Type;
263     const std::unique_ptr<Type> fByte2_Type;
264     const std::unique_ptr<Type> fByte3_Type;
265     const std::unique_ptr<Type> fByte4_Type;
266 
267     const std::unique_ptr<Type> fBool_Type;
268     const std::unique_ptr<Type> fBool2_Type;
269     const std::unique_ptr<Type> fBool3_Type;
270     const std::unique_ptr<Type> fBool4_Type;
271 
272     const std::unique_ptr<Type> fFloat2x2_Type;
273     const std::unique_ptr<Type> fFloat2x3_Type;
274     const std::unique_ptr<Type> fFloat2x4_Type;
275     const std::unique_ptr<Type> fFloat3x2_Type;
276     const std::unique_ptr<Type> fFloat3x3_Type;
277     const std::unique_ptr<Type> fFloat3x4_Type;
278     const std::unique_ptr<Type> fFloat4x2_Type;
279     const std::unique_ptr<Type> fFloat4x3_Type;
280     const std::unique_ptr<Type> fFloat4x4_Type;
281 
282     const std::unique_ptr<Type> fHalf2x2_Type;
283     const std::unique_ptr<Type> fHalf2x3_Type;
284     const std::unique_ptr<Type> fHalf2x4_Type;
285     const std::unique_ptr<Type> fHalf3x2_Type;
286     const std::unique_ptr<Type> fHalf3x3_Type;
287     const std::unique_ptr<Type> fHalf3x4_Type;
288     const std::unique_ptr<Type> fHalf4x2_Type;
289     const std::unique_ptr<Type> fHalf4x3_Type;
290     const std::unique_ptr<Type> fHalf4x4_Type;
291 
292     const std::unique_ptr<Type> fDouble2x2_Type;
293     const std::unique_ptr<Type> fDouble2x3_Type;
294     const std::unique_ptr<Type> fDouble2x4_Type;
295     const std::unique_ptr<Type> fDouble3x2_Type;
296     const std::unique_ptr<Type> fDouble3x3_Type;
297     const std::unique_ptr<Type> fDouble3x4_Type;
298     const std::unique_ptr<Type> fDouble4x2_Type;
299     const std::unique_ptr<Type> fDouble4x3_Type;
300     const std::unique_ptr<Type> fDouble4x4_Type;
301 
302     const std::unique_ptr<Type> fTexture1D_Type;
303     const std::unique_ptr<Type> fTexture2D_Type;
304     const std::unique_ptr<Type> fTexture3D_Type;
305     const std::unique_ptr<Type> fTextureExternalOES_Type;
306     const std::unique_ptr<Type> fTextureCube_Type;
307     const std::unique_ptr<Type> fTexture2DRect_Type;
308     const std::unique_ptr<Type> fTextureBuffer_Type;
309     const std::unique_ptr<Type> fITexture2D_Type;
310 
311     const std::unique_ptr<Type> fSampler1D_Type;
312     const std::unique_ptr<Type> fSampler2D_Type;
313     const std::unique_ptr<Type> fSampler3D_Type;
314     const std::unique_ptr<Type> fSamplerExternalOES_Type;
315     const std::unique_ptr<Type> fSamplerCube_Type;
316     const std::unique_ptr<Type> fSampler2DRect_Type;
317     const std::unique_ptr<Type> fSampler1DArray_Type;
318     const std::unique_ptr<Type> fSampler2DArray_Type;
319     const std::unique_ptr<Type> fSamplerCubeArray_Type;
320     const std::unique_ptr<Type> fSamplerBuffer_Type;
321     const std::unique_ptr<Type> fSampler2DMS_Type;
322     const std::unique_ptr<Type> fSampler2DMSArray_Type;
323     const std::unique_ptr<Type> fSampler1DShadow_Type;
324     const std::unique_ptr<Type> fSampler2DShadow_Type;
325     const std::unique_ptr<Type> fSamplerCubeShadow_Type;
326     const std::unique_ptr<Type> fSampler2DRectShadow_Type;
327     const std::unique_ptr<Type> fSampler1DArrayShadow_Type;
328     const std::unique_ptr<Type> fSampler2DArrayShadow_Type;
329     const std::unique_ptr<Type> fSamplerCubeArrayShadow_Type;
330 
331     const std::unique_ptr<Type> fISampler2D_Type;
332     const std::unique_ptr<Type> fSampler_Type;
333 
334     const std::unique_ptr<Type> fImage2D_Type;
335     const std::unique_ptr<Type> fIImage2D_Type;
336 
337     const std::unique_ptr<Type> fSubpassInput_Type;
338     const std::unique_ptr<Type> fSubpassInputMS_Type;
339 
340     const std::unique_ptr<Type> fGSampler1D_Type;
341     const std::unique_ptr<Type> fGSampler2D_Type;
342     const std::unique_ptr<Type> fGSampler3D_Type;
343     const std::unique_ptr<Type> fGSamplerCube_Type;
344     const std::unique_ptr<Type> fGSampler2DRect_Type;
345     const std::unique_ptr<Type> fGSampler1DArray_Type;
346     const std::unique_ptr<Type> fGSampler2DArray_Type;
347     const std::unique_ptr<Type> fGSamplerCubeArray_Type;
348     const std::unique_ptr<Type> fGSamplerBuffer_Type;
349     const std::unique_ptr<Type> fGSampler2DMS_Type;
350     const std::unique_ptr<Type> fGSampler2DMSArray_Type;
351     const std::unique_ptr<Type> fGSampler2DArrayShadow_Type;
352     const std::unique_ptr<Type> fGSamplerCubeArrayShadow_Type;
353 
354     const std::unique_ptr<Type> fGenType_Type;
355     const std::unique_ptr<Type> fGenHType_Type;
356     const std::unique_ptr<Type> fGenDType_Type;
357     const std::unique_ptr<Type> fGenIType_Type;
358     const std::unique_ptr<Type> fGenUType_Type;
359     const std::unique_ptr<Type> fGenBType_Type;
360 
361     const std::unique_ptr<Type> fMat_Type;
362 
363     const std::unique_ptr<Type> fVec_Type;
364 
365     const std::unique_ptr<Type> fGVec_Type;
366     const std::unique_ptr<Type> fGVec2_Type;
367     const std::unique_ptr<Type> fGVec3_Type;
368     const std::unique_ptr<Type> fGVec4_Type;
369     const std::unique_ptr<Type> fHVec_Type;
370     const std::unique_ptr<Type> fDVec_Type;
371     const std::unique_ptr<Type> fIVec_Type;
372     const std::unique_ptr<Type> fUVec_Type;
373     const std::unique_ptr<Type> fSVec_Type;
374     const std::unique_ptr<Type> fUSVec_Type;
375     const std::unique_ptr<Type> fByteVec_Type;
376     const std::unique_ptr<Type> fUByteVec_Type;
377 
378     const std::unique_ptr<Type> fBVec_Type;
379 
380     const std::unique_ptr<Type> fSkCaps_Type;
381     const std::unique_ptr<Type> fSkArgs_Type;
382     const std::unique_ptr<Type> fFragmentProcessor_Type;
383 
384     // dummy expression used to mark that a variable has a value during dataflow analysis (when it
385     // could have several different values, or the analyzer is otherwise unable to assign it a
386     // specific expression)
387     const std::unique_ptr<Expression> fDefined_Expression;
388 
389 private:
390     class Defined : public Expression {
391     public:
Defined(const Type & type)392         Defined(const Type& type)
393         : INHERITED(-1, kDefined_Kind, type) {}
394 
hasSideEffects()395         bool hasSideEffects() const override {
396             return false;
397         }
398 
description()399         String description() const override {
400             return "<defined>";
401         }
402 
clone()403         std::unique_ptr<Expression> clone() const override {
404             return std::unique_ptr<Expression>(new Defined(fType));
405         }
406 
407         typedef Expression INHERITED;
408     };
409 
fp_type(const Type * intType,const Type * boolType)410     static std::unique_ptr<Type> fp_type(const Type* intType, const Type* boolType) {
411         // Build fields for FragmentProcessors, which should parallel the
412         // C++ API for GrFragmentProcessor.
413         Modifiers mods(Layout(), Modifiers::kConst_Flag);
414         std::vector<Type::Field> fields = {
415             Type::Field(mods, "numTextureSamplers", intType),
416             Type::Field(mods, "numCoordTransforms", intType),
417             Type::Field(mods, "numChildProcessors", intType),
418             Type::Field(mods, "usesLocalCoords", boolType),
419             Type::Field(mods, "compatibleWithCoverageAsAlpha", boolType),
420             Type::Field(mods, "preservesOpaqueInput", boolType),
421             Type::Field(mods, "hasConstantOutputForConstantInput", boolType)
422         };
423         return std::unique_ptr<Type>(new Type("fragmentProcessor", fields));
424     }
425 };
426 
427 } // namespace
428 
429 #endif
430