]> gerrit.simantics Code Review - simantics/platform.git/blob
930dfe14b547208cb2dba5e228379aa700491b6e
[simantics/platform.git] /
1 package org.simantics.scl.compiler.internal.elaboration.profiling;
2
3 import java.util.ArrayList;
4
5 import org.simantics.scl.compiler.elaboration.expressions.Case;
6 import org.simantics.scl.compiler.elaboration.expressions.EApply;
7 import org.simantics.scl.compiler.elaboration.expressions.EApplyType;
8 import org.simantics.scl.compiler.elaboration.expressions.EAsPattern;
9 import org.simantics.scl.compiler.elaboration.expressions.EBinary;
10 import org.simantics.scl.compiler.elaboration.expressions.EBind;
11 import org.simantics.scl.compiler.elaboration.expressions.EBlock;
12 import org.simantics.scl.compiler.elaboration.expressions.EConstant;
13 import org.simantics.scl.compiler.elaboration.expressions.ECoveringBranchPoint;
14 import org.simantics.scl.compiler.elaboration.expressions.EEnforce;
15 import org.simantics.scl.compiler.elaboration.expressions.EEntityTypeAnnotation;
16 import org.simantics.scl.compiler.elaboration.expressions.EError;
17 import org.simantics.scl.compiler.elaboration.expressions.EExternalConstant;
18 import org.simantics.scl.compiler.elaboration.expressions.EFieldAccess;
19 import org.simantics.scl.compiler.elaboration.expressions.EGetConstraint;
20 import org.simantics.scl.compiler.elaboration.expressions.EIf;
21 import org.simantics.scl.compiler.elaboration.expressions.EIntegerLiteral;
22 import org.simantics.scl.compiler.elaboration.expressions.ELambda;
23 import org.simantics.scl.compiler.elaboration.expressions.ELambdaType;
24 import org.simantics.scl.compiler.elaboration.expressions.ELet;
25 import org.simantics.scl.compiler.elaboration.expressions.EListComprehension;
26 import org.simantics.scl.compiler.elaboration.expressions.EListLiteral;
27 import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
28 import org.simantics.scl.compiler.elaboration.expressions.EMatch;
29 import org.simantics.scl.compiler.elaboration.expressions.EPlaceholder;
30 import org.simantics.scl.compiler.elaboration.expressions.EPreLet;
31 import org.simantics.scl.compiler.elaboration.expressions.EPreRuleset;
32 import org.simantics.scl.compiler.elaboration.expressions.ERange;
33 import org.simantics.scl.compiler.elaboration.expressions.ERealLiteral;
34 import org.simantics.scl.compiler.elaboration.expressions.ERecord;
35 import org.simantics.scl.compiler.elaboration.expressions.ERuleset;
36 import org.simantics.scl.compiler.elaboration.expressions.ESelect;
37 import org.simantics.scl.compiler.elaboration.expressions.ESimpleLambda;
38 import org.simantics.scl.compiler.elaboration.expressions.ESimpleLet;
39 import org.simantics.scl.compiler.elaboration.expressions.EStringLiteral;
40 import org.simantics.scl.compiler.elaboration.expressions.ETransformation;
41 import org.simantics.scl.compiler.elaboration.expressions.ETypeAnnotation;
42 import org.simantics.scl.compiler.elaboration.expressions.EVar;
43 import org.simantics.scl.compiler.elaboration.expressions.EVariable;
44 import org.simantics.scl.compiler.elaboration.expressions.EWhen;
45 import org.simantics.scl.compiler.elaboration.expressions.Expression;
46 import org.simantics.scl.compiler.elaboration.expressions.GuardedExpression;
47 import org.simantics.scl.compiler.elaboration.expressions.GuardedExpressionGroup;
48 import org.simantics.scl.compiler.elaboration.expressions.StandardExpressionTransformer;
49 import org.simantics.scl.compiler.elaboration.expressions.block.BindStatement;
50 import org.simantics.scl.compiler.elaboration.expressions.block.GuardStatement;
51 import org.simantics.scl.compiler.elaboration.expressions.block.LetStatement;
52 import org.simantics.scl.compiler.elaboration.expressions.block.RuleStatement;
53 import org.simantics.scl.compiler.elaboration.expressions.list.ListAssignment;
54 import org.simantics.scl.compiler.elaboration.expressions.list.ListGenerator;
55 import org.simantics.scl.compiler.elaboration.expressions.list.ListGuard;
56 import org.simantics.scl.compiler.elaboration.expressions.list.ListQualifier;
57 import org.simantics.scl.compiler.elaboration.expressions.list.ListSeq;
58 import org.simantics.scl.compiler.elaboration.expressions.list.ListThen;
59 import org.simantics.scl.compiler.elaboration.query.QAlternative;
60 import org.simantics.scl.compiler.elaboration.query.QAtom;
61 import org.simantics.scl.compiler.elaboration.query.QConjunction;
62 import org.simantics.scl.compiler.elaboration.query.QDisjunction;
63 import org.simantics.scl.compiler.elaboration.query.QExists;
64 import org.simantics.scl.compiler.elaboration.query.QIf;
65 import org.simantics.scl.compiler.elaboration.query.QMapping;
66 import org.simantics.scl.compiler.elaboration.query.QNegation;
67 import org.simantics.scl.compiler.elaboration.query.Query;
68 import org.simantics.scl.compiler.elaboration.query.pre.QPreBinds;
69 import org.simantics.scl.compiler.elaboration.query.pre.QPreEquals;
70 import org.simantics.scl.compiler.elaboration.query.pre.QPreExists;
71 import org.simantics.scl.compiler.elaboration.query.pre.QPreGuard;
72 import org.simantics.scl.runtime.profiling.BranchPoint;
73
74 public class BranchPointInjector extends StandardExpressionTransformer {
75     public ArrayList<BranchPoint> currentBranchPoints = new ArrayList<BranchPoint>();
76     int codeCounter = 0;
77     
78     public Expression injectBranchPoint(Expression expression) {
79         ArrayList<BranchPoint> oldBranchPoints = currentBranchPoints;
80         currentBranchPoints = new ArrayList<BranchPoint>();
81         int beginCodeCounter = codeCounter;
82         expression = expression.accept(this);
83         BranchPoint branchPoint = new BranchPoint(expression.location,
84                 codeCounter - beginCodeCounter,
85                 currentBranchPoints.isEmpty() ? BranchPoint.EMPTY_ARRAY
86                         : currentBranchPoints.toArray(new BranchPoint[currentBranchPoints.size()]));
87         oldBranchPoints.add(branchPoint);
88         currentBranchPoints = oldBranchPoints;
89         return new ECoveringBranchPoint(expression, branchPoint);
90     }
91     
92     @Override
93     public Expression transform(ESimpleLambda expression) {
94         ++codeCounter;
95         expression.value = injectBranchPoint(expression.value);
96         return expression;
97     }
98     
99     @Override
100     public Expression transform(ELambda expression) {
101         ++codeCounter;
102         for(Case case_ : expression.cases)
103             case_.value = injectBranchPoint(case_.value);
104         return expression;
105     }
106     
107     @Override
108     public Expression transform(EMatch expression) {
109         ++codeCounter;
110         for(int i=0;i<expression.scrutinee.length;++i)
111             expression.scrutinee[i] = expression.scrutinee[i].accept(this);
112         for(Case case_ : expression.cases)
113             case_.value = injectBranchPoint(case_.value);
114         return expression;
115     }
116     
117     @Override
118     public Expression transform(EIf expression) {
119         ++codeCounter;
120         expression.condition = expression.condition.accept(this);
121         expression.then_ = injectBranchPoint(expression.then_);
122         expression.else_ = injectBranchPoint(expression.else_);
123         return expression;
124     }
125     
126     @Override
127     public Expression transform(EBind expression) {
128         ++codeCounter;
129         expression.pattern = expression.pattern.accept(this);
130         expression.value = expression.value.accept(this);
131         expression.in = injectBranchPoint(expression.in);
132         return expression;
133     }
134     
135     @Override
136     public Expression transform(EListComprehension expression) {
137         ++codeCounter;
138         expression.head = injectBranchPoint(expression.head);
139         expression.qualifier =  expression.qualifier.accept(this);
140         return expression;
141     }
142     
143     @Override
144     public Expression transform(EWhen expression) {
145         ++codeCounter;
146         expression.query = expression.query.accept(this);
147         expression.action = injectBranchPoint(expression.action);
148         return expression;
149     }
150
151     @Override
152     public Expression transform(GuardedExpressionGroup expression) {
153         ++codeCounter;
154         for(GuardedExpression ge : expression.expressions) {
155             for(int i=0;i<ge.guards.length;++i)
156                 ge.guards[i] = ge.guards[i].accept(this);
157             ge.value = injectBranchPoint(ge.value);
158         }
159         return expression;
160     }
161     
162     @Override
163     public Expression transform(EApply expression) {
164         ++codeCounter;
165         return super.transform(expression);
166     }
167     
168     @Override
169     public Expression transform(EApplyType expression) {
170         ++codeCounter;
171         return super.transform(expression);
172     }
173     
174     @Override
175     public Expression transform(EAsPattern expression) {
176         ++codeCounter;
177         return super.transform(expression);
178     }
179     
180     @Override
181     public Expression transform(EBinary expression) {
182         ++codeCounter;
183         return super.transform(expression);
184     }
185     
186     @Override
187     public Expression transform(EBlock expression) {
188         ++codeCounter;
189         return super.transform(expression);
190     }
191     
192     @Override
193     public Expression transform(EConstant expression) {
194         ++codeCounter;
195         return super.transform(expression);
196     }
197     
198     @Override
199     public Expression transform(ECoveringBranchPoint expression) {
200         ++codeCounter;
201         return super.transform(expression);
202     }
203     
204     @Override
205     public Expression transform(EEnforce expression) {
206         ++codeCounter;
207         return super.transform(expression);
208     }
209     
210     @Override
211     public Expression transform(EEntityTypeAnnotation expression) {
212         ++codeCounter;
213         return super.transform(expression);
214     }
215     
216     @Override
217     public Expression transform(EError expression) {
218         ++codeCounter;
219         return super.transform(expression);
220     }
221     
222     @Override
223     public Expression transform(EExternalConstant expression) {
224         ++codeCounter;
225         return super.transform(expression);
226     }
227     
228     @Override
229     public Expression transform(EFieldAccess expression) {
230         ++codeCounter;
231         return super.transform(expression);
232     }
233     
234     @Override
235     public Expression transform(EGetConstraint expression) {
236         ++codeCounter;
237         return super.transform(expression);
238     }
239     
240     @Override
241     public Expression transform(EIntegerLiteral expression) {
242         ++codeCounter;
243         return super.transform(expression);
244     }
245     
246     @Override
247     public Expression transform(ELambdaType expression) {
248         ++codeCounter;
249         return super.transform(expression);
250     }
251     
252     @Override
253     public Expression transform(ELet expression) {
254         ++codeCounter;
255         return super.transform(expression);
256     }
257     
258     @Override
259     public Expression transform(EListLiteral expression) {
260         ++codeCounter;
261         return super.transform(expression);
262     }
263     
264     @Override
265     public Expression transform(ELiteral expression) {
266         ++codeCounter;
267         return super.transform(expression);
268     }
269     
270     @Override
271     public Expression transform(EPlaceholder expression) {
272         ++codeCounter;
273         return super.transform(expression);
274     }
275     
276     @Override
277     public Expression transform(EPreLet expression) {
278         ++codeCounter;
279         return super.transform(expression);
280     }
281     
282     @Override
283     public Expression transform(EPreRuleset expression) {
284         ++codeCounter;
285         return super.transform(expression);
286     }
287     
288     @Override
289     public Expression transform(ERange expression) {
290         ++codeCounter;
291         return super.transform(expression);
292     }
293     
294     @Override
295     public Expression transform(ERealLiteral expression) {
296         ++codeCounter;
297         return super.transform(expression);
298     }
299     
300     @Override
301     public Expression transform(ERecord expression) {
302         ++codeCounter;
303         return super.transform(expression);
304     }
305     
306     @Override
307     public Expression transform(ERuleset expression) {
308         ++codeCounter;
309         return super.transform(expression);
310     }
311     
312     @Override
313     public Expression transform(ESelect expression) {
314         ++codeCounter;
315         return super.transform(expression);
316     }
317     
318     @Override
319     public Expression transform(ESimpleLet expression) {
320         ++codeCounter;
321         return super.transform(expression);
322     }
323     
324     @Override
325     public Expression transform(EStringLiteral expression) {
326         ++codeCounter;
327         return super.transform(expression);
328     }
329     
330     @Override
331     public Expression transform(ETransformation expression) {
332         ++codeCounter;
333         return super.transform(expression);
334     }
335     
336     @Override
337     public Expression transform(ETypeAnnotation expression) {
338         ++codeCounter;
339         return super.transform(expression);
340     }
341     
342     @Override
343     public Expression transform(EVar expression) {
344         ++codeCounter;
345         return super.transform(expression);
346     }
347     
348     @Override
349     public Expression transform(EVariable expression) {
350         ++codeCounter;
351         return super.transform(expression);
352     }
353     
354     @Override
355     public ListQualifier transform(ListAssignment qualifier) {
356         ++codeCounter;
357         return super.transform(qualifier);
358     }
359     
360     @Override
361     public ListQualifier transform(ListGenerator qualifier) {
362         ++codeCounter;
363         return super.transform(qualifier);
364     }
365     
366     @Override
367     public ListQualifier transform(ListGuard qualifier) {
368         ++codeCounter;
369         return super.transform(qualifier);
370     }
371     
372     @Override
373     public ListQualifier transform(ListSeq qualifier) {
374         ++codeCounter;
375         return super.transform(qualifier);
376     }
377     
378     @Override
379     public ListQualifier transform(ListThen qualifier) {
380         ++codeCounter;
381         return super.transform(qualifier);
382     }
383     
384     @Override
385     public Query transform(QAlternative query) {
386         ++codeCounter;
387         return super.transform(query);
388     }
389     
390     @Override
391     public Query transform(QAtom query) {
392         ++codeCounter;
393         return super.transform(query);
394     }
395     
396     @Override
397     public Query transform(QConjunction query) {
398         ++codeCounter;
399         return super.transform(query);
400     }
401     
402     @Override
403     public Query transform(QDisjunction query) {
404         ++codeCounter;
405         return super.transform(query);
406     }
407     
408     @Override
409     public Query transform(QExists query) {
410         ++codeCounter;
411         return super.transform(query);
412     }
413     
414     @Override
415     public Query transform(QIf query) {
416         ++codeCounter;
417         return super.transform(query);
418     }
419     
420     @Override
421     public Query transform(QMapping query) {
422         ++codeCounter;
423         return super.transform(query);
424     }
425     
426     @Override
427     public Query transform(QNegation query) {
428         ++codeCounter;
429         return super.transform(query);
430     }
431     
432     @Override
433     public Query transform(QPreBinds query) {
434         ++codeCounter;
435         return super.transform(query);
436     }
437     
438     @Override
439     public Query transform(QPreEquals query) {
440         ++codeCounter;
441         return super.transform(query);
442     }
443     
444     @Override
445     public Query transform(QPreExists query) {
446         ++codeCounter;
447         return super.transform(query);
448     }
449     
450     @Override
451     public Query transform(QPreGuard query) {
452         ++codeCounter;
453         return super.transform(query);
454     }
455     
456     public BranchPoint[] getAndClearBranchPoints() {
457         BranchPoint[] result = currentBranchPoints.toArray(new BranchPoint[currentBranchPoints.size()]);
458         currentBranchPoints.clear();
459         return result;
460     }
461     
462     @Override
463     public void visit(BindStatement statement) {
464         ++codeCounter;
465         super.visit(statement);
466     }
467     
468     @Override
469     public void visit(GuardStatement statement) {
470         ++codeCounter;
471         super.visit(statement);
472     }
473     
474     @Override
475     public void visit(LetStatement statement) {
476         ++codeCounter;
477         if(statement.pattern.isFunctionDefinitionLhs())
478             statement.value = injectBranchPoint(statement.value);
479         else
480             super.visit(statement);
481     }
482     
483     @Override
484     public void visit(RuleStatement statement) {
485         ++codeCounter;
486         super.visit(statement);
487     }
488     
489 }