[WHSL] Need grammar to specify kernel group size
[WebKit-https.git] / Tools / WebGPUShadingLanguageRI / Visitor.js
1 /*
2  * Copyright (C) 2018 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25 "use strict";
26
27 class Visitor {
28     visitProgram(node)
29     {
30         for (let statement of node.topLevelStatements)
31             statement.visit(this);
32     }
33     
34     visitFunc(node)
35     {
36         node.returnType.visit(this);
37         for (let parameter of node.parameters)
38             parameter.visit(this);
39         if (node.attributeBlock) {
40             for (let attribute of node.attributeBlock)
41                 attribute.visit(this);
42         }
43     }
44     
45     visitFuncParameter(node)
46     {
47         node.type.visit(this);
48     }
49     
50     visitFuncDef(node)
51     {
52         this.visitFunc(node);
53         node.body.visit(this);
54     }
55     
56     visitNativeFunc(node)
57     {
58         this.visitFunc(node);
59     }
60     
61     visitBlock(node)
62     {
63         for (let statement of node.statements)
64             statement.visit(this);
65     }
66     
67     visitCommaExpression(node)
68     {
69         for (let expression of node.list)
70             expression.visit(this);
71     }
72     
73     visitTypeRef(node)
74     {
75         for (let typeArgument of node.typeArguments)
76             typeArgument.visit(this);
77     }
78     
79     visitNativeType(node)
80     {
81         for (let typeArgument of node.typeArguments)
82             typeArgument.visit(this);
83     }
84     
85     visitTypeDef(node)
86     {
87         node.type.visit(this);
88     }
89     
90     visitStructType(node)
91     {
92         for (let field of node.fields)
93             field.visit(this);
94     }
95     
96     visitField(node)
97     {
98         node.type.visit(this);
99     }
100     
101     visitEnumType(node)
102     {
103         node.baseType.visit(this);
104         for (let member of node.members)
105             member.visit(this);
106     }
107     
108     visitEnumMember(node)
109     {
110         Node.visit(node.value, this);
111     }
112     
113     visitEnumLiteral(node)
114     {
115     }
116     
117     visitElementalType(node)
118     {
119         node.elementType.visit(this);
120     }
121     
122     visitReferenceType(node)
123     {
124         this.visitElementalType(node);
125     }
126     
127     visitPtrType(node)
128     {
129         this.visitReferenceType(node);
130     }
131     
132     visitArrayRefType(node)
133     {
134         this.visitReferenceType(node);
135     }
136     
137     visitArrayType(node)
138     {
139         this.visitElementalType(node);
140         node.numElements.visit(this);
141     }
142     
143     visitVariableDecl(node)
144     {
145         node.type.visit(this);
146         Node.visit(node.initializer, this);
147     }
148     
149     visitAssignment(node)
150     {
151         node.lhs.visit(this);
152         node.rhs.visit(this);
153         Node.visit(node.type, this);
154     }
155     
156     visitReadModifyWriteExpression(node)
157     {
158         node.lValue.visit(this);
159         node.oldValueVar.visit(this);
160         node.newValueVar.visit(this);
161         node.newValueExp.visit(this);
162         node.resultExp.visit(this);
163     }
164     
165     visitDereferenceExpression(node)
166     {
167         node.ptr.visit(this);
168     }
169
170     visitTernaryExpression(node)
171     {
172         node.predicate.visit(this);
173         node.bodyExpression.visit(this);
174         node.elseExpression.visit(this);
175     }
176     
177     _handlePropertyAccessExpression(node)
178     {
179         Node.visit(node.baseType, this);
180         Node.visit(node.callForGet, this);
181         Node.visit(node.resultTypeForGet, this);
182         Node.visit(node.callForAnd, this);
183         Node.visit(node.resultTypeForAnd, this);
184         Node.visit(node.callForSet, this);
185     }
186     
187     visitDotExpression(node)
188     {
189         node.struct.visit(this);
190         this._handlePropertyAccessExpression(node);
191     }
192     
193     visitIndexExpression(node)
194     {
195         node.array.visit(this);
196         node.index.visit(this);
197         this._handlePropertyAccessExpression(node);
198     }
199     
200     visitMakePtrExpression(node)
201     {
202         node.lValue.visit(this);
203     }
204     
205     visitMakeArrayRefExpression(node)
206     {
207         node.lValue.visit(this);
208         Node.visit(node.numElements, this);
209     }
210     
211     visitConvertPtrToArrayRefExpression(node)
212     {
213         node.lValue.visit(this);
214     }
215     
216     visitVariableRef(node)
217     {
218     }
219     
220     visitIfStatement(node)
221     {
222         node.conditional.visit(this);
223         node.body.visit(this);
224         Node.visit(node.elseBody, this);
225     }
226     
227     visitWhileLoop(node)
228     {
229         node.conditional.visit(this);
230         node.body.visit(this);
231     }
232     
233     visitDoWhileLoop(node)
234     {
235         node.body.visit(this);
236         node.conditional.visit(this);
237     }
238     
239     visitForLoop(node)
240     {
241         Node.visit(node.initialization, this);
242         Node.visit(node.condition, this);
243         Node.visit(node.increment, this);
244         node.body.visit(this);
245     }
246     
247     visitSwitchStatement(node)
248     {
249         node.value.visit(this);
250         for (let switchCase of node.switchCases)
251             switchCase.visit(this);
252     }
253     
254     visitSwitchCase(node)
255     {
256         Node.visit(node.value, this);
257         node.body.visit(this);
258     }
259
260     visitReturn(node)
261     {
262         Node.visit(node.value, this);
263     }
264
265     visitContinue(node)
266     {
267     }
268
269     visitBreak(node)
270     {
271     }
272
273     visitTrapStatement(node)
274     {
275     }
276     
277     visitGenericLiteral(node)
278     {
279         node.type.visit(this);
280     }
281     
282     visitGenericLiteralType(node)
283     {
284         Node.visit(node.type, this);
285         node.preferredType.visit(this);
286     }
287     
288     visitNullLiteral(node)
289     {
290         node.type.visit(this);
291     }
292     
293     visitBoolLiteral(node)
294     {
295     }
296     
297     visitNullType(node)
298     {
299         Node.visit(node.type, this);
300     }
301     
302     visitCallExpression(node)
303     {
304         for (let argument of node.argumentList)
305             Node.visit(argument, this);
306         Node.visit(node.returnType, this);
307         Node.visit(node.resultType, this);
308     }
309     
310     visitLogicalNot(node)
311     {
312         node.operand.visit(this);
313     }
314     
315     visitLogicalExpression(node)
316     {
317         node.left.visit(this);
318         node.right.visit(this);
319     }
320     
321     visitFunctionLikeBlock(node)
322     {
323         Node.visit(node.returnType, this);
324         for (let argument of node.argumentList)
325             argument.visit(this);
326         for (let parameter of node.parameters)
327             parameter.visit(this);
328         node.body.visit(this);
329         Node.visit(node.resultType, this);
330     }
331     
332     visitAnonymousVariable(node)
333     {
334         Node.visit(node.type, this);
335     }
336     
337     visitIdentityExpression(node)
338     {
339         node.target.visit(this);
340     }
341
342     visitVectorType(node)
343     {
344         node.elementType.visit(this);
345         node.numElements.visit(this);
346     }
347
348     visitMatrixType(node)
349     {
350         node.elementType.visit(this);
351         node.numRows.visit(this);
352         node.numColumns.visit(this);
353     }
354
355     visitFuncNumThreadsAttribute(node)
356     {
357     }
358 }
359