Statistics
| Revision:

svn-gvsig-desktop / trunk / org.gvsig.desktop / org.gvsig.desktop.library / org.gvsig.expressionevaluator / org.gvsig.expressionevaluator.lib / org.gvsig.expressionevaluator.lib.impl / src / main / java / org / gvsig / expressionevaluator / impl / DefaultOptimizer.java @ 44198

History | View | Annotate | Download (7.27 KB)

1 44009 jjdelcerro
package org.gvsig.expressionevaluator.impl;
2
3
import org.gvsig.expressionevaluator.Optimizer;
4
import java.util.Collection;
5
import java.util.Collections;
6
import java.util.Iterator;
7
import org.gvsig.expressionevaluator.Code;
8
import org.gvsig.expressionevaluator.Code.Caller;
9
import org.gvsig.expressionevaluator.CodeBuilder;
10
import org.gvsig.expressionevaluator.Function;
11
import org.gvsig.expressionevaluator.Interpreter;
12
import org.gvsig.expressionevaluator.SymbolTable;
13 44139 jjdelcerro
import org.gvsig.expressionevaluator.impl.DefaultCodeBuilder.BaseCodes;
14 44009 jjdelcerro
import org.gvsig.tools.script.Script;
15
16
/**
17
 *
18
 * @author jjdelcerro
19
 */
20
public class DefaultOptimizer implements Optimizer {
21
22
    private static class OptimizerSymbolTable implements SymbolTable {
23
24
        private SymbolTable symbolTable;
25
26
        public OptimizerSymbolTable() {
27
28
        }
29
30
        public SymbolTable getSymbolTable() {
31
            return this.symbolTable;
32
        }
33
34
        public void setSymbolTable(SymbolTable symbolTable) {
35
            this.symbolTable = symbolTable;
36
        }
37
38
        @Override
39
        public String getName() {
40
            return "Optimizer";
41
        }
42
43
        @Override
44
        public void addSymbolTable(SymbolTable symbolTable) {
45
            throw new UnsupportedOperationException("Not supported yet.");
46
        }
47
48
        @Override
49
        public Function function(String name) {
50
            return this.symbolTable.function(name);
51
        }
52
53
        @Override
54
        public boolean exists(String name) {
55
            return false;
56
        }
57
58
        @Override
59
        public Object value(String name) {
60
            return null;
61
        }
62
63
        @Override
64
        public Collection<String> variables() {
65
            return Collections.EMPTY_LIST;
66
        }
67
68
        @Override
69
        public Collection<Function> functions() {
70
            return this.symbolTable.functions();
71
        }
72
73
        @Override
74
        public Collection<Script> scripts() {
75
            return this.symbolTable.scripts();
76
        }
77
78
        @Override
79
        @SuppressWarnings("CloneDoesntCallSuperClone")
80
        public SymbolTable clone() throws CloneNotSupportedException {
81
            throw new UnsupportedOperationException("Not supported yet.");
82
        }
83
84
        @Override
85
        public Iterator<Function> iterator() {
86
            return this.symbolTable.iterator();
87
        }
88
89
    }
90
91
    private final OptimizerSymbolTable symbolTable;
92
    private Interpreter interpreter;
93
    private CodeBuilder codeBuilder;
94 44010 jjdelcerro
95 44009 jjdelcerro
    public DefaultOptimizer() {
96
        this.symbolTable = new OptimizerSymbolTable();
97
    }
98
99
    public DefaultOptimizer(SymbolTable symbolTable) {
100
        this();
101
        this.symbolTable.setSymbolTable(symbolTable);
102
    }
103
104
    @Override
105
    public void setSymbolTable(SymbolTable symbolTable) {
106
        this.symbolTable.setSymbolTable(symbolTable);
107
    }
108
109 44010 jjdelcerro
    @Override
110
    public SymbolTable getSymbolTable() {
111
        return this.symbolTable;
112
    }
113
114
    @Override
115
    public Interpreter getInterpreter() {
116
        if (this.interpreter == null) {
117 44009 jjdelcerro
            this.interpreter = new DefaultInterpreter();
118
            this.interpreter.setSymbolTable(this.symbolTable);
119
        }
120
        return this.interpreter;
121
    }
122 44010 jjdelcerro
123
    @Override
124
    public CodeBuilder getCodeBuilder() {
125
        if (this.codeBuilder == null) {
126 44009 jjdelcerro
            this.codeBuilder = new DefaultCodeBuilder();
127
        }
128
        return this.codeBuilder;
129
    }
130 44010 jjdelcerro
131 44009 jjdelcerro
    @Override
132 44019 jjdelcerro
    public Code optimize(SymbolTable symbolTable, Code code) {
133
        this.setSymbolTable(symbolTable);
134
        return this.optimize(code);
135
    }
136
137
    @Override
138 44009 jjdelcerro
    public Code optimize(Code code) {
139
        code = this.doOptimize(code);
140
        return code;
141
    }
142 44010 jjdelcerro
143 44009 jjdelcerro
    private Code doOptimize(Code code) {
144
        switch (code.code()) {
145
            case Code.CALLER:
146
                Caller caller = (Caller) code;
147 44010 jjdelcerro
                if (caller.function() == null) {
148
                    // resolve and link function
149
                    caller.function(this.getSymbolTable().function(caller.name()));
150
                }
151
                if (caller.function() instanceof FunctionOptimizer) {
152
                    return ((FunctionOptimizer) caller.function()).optimize(this, caller);
153
                } else {
154
                    switch (caller.type()) {
155
                        case Caller.BINARY_OPERATOR: {
156 44198 jjdelcerro
                            Code op1 = this.doOptimize(caller.parameters().get(0));
157
                            Code op2 = this.doOptimize(caller.parameters().get(1));
158 44010 jjdelcerro
                            if (caller.function().allowConstantFolding()) {
159
                                if (op1.code() == Code.CONSTANT && op2.code() == Code.CONSTANT) {
160
                                    Object value = this.getInterpreter().run(code);
161
                                    Code newCode = this.getCodeBuilder().constant(value);
162
                                    return newCode;
163
                                }
164
                                Code newCode = this.getCodeBuilder().operator(caller.name(), op1, op2);
165
                                return newCode;
166
                            }
167 44009 jjdelcerro
                        }
168 44010 jjdelcerro
169
                        case Code.Caller.UNARY_OPERATOR: {
170 44198 jjdelcerro
                            Code op1 = this.doOptimize(caller.parameters().get(0));
171 44010 jjdelcerro
                            if (caller.function().allowConstantFolding()
172
                                    && op1.code() == Code.CONSTANT) {
173
                                Object value = this.getInterpreter().run(code);
174
                                Code newCode = this.getCodeBuilder().constant(value);
175
                                return newCode;
176
                            }
177
                            return code;
178 44009 jjdelcerro
                        }
179
180 44010 jjdelcerro
                        case Code.Caller.FUNCTION:
181
                        default: {
182 44139 jjdelcerro
                            BaseCodes newArgs = null;
183 44010 jjdelcerro
                            boolean canOptimize = true;
184 44198 jjdelcerro
                            if (caller.parameters() != null) {
185 44139 jjdelcerro
                                newArgs = (BaseCodes) this.getCodeBuilder().args();
186 44198 jjdelcerro
                                for (Code arg : caller.parameters()) {
187 44010 jjdelcerro
                                    Code newArg = this.doOptimize(arg);
188
                                    newArgs.add(newArg);
189
                                    if (newArg.code() != Code.CONSTANT) {
190
                                        canOptimize = false;
191
                                    }
192 44009 jjdelcerro
                                }
193
                            }
194 44010 jjdelcerro
                            if (canOptimize && caller.function().allowConstantFolding()) {
195
                                Object value = this.getInterpreter().run(code);
196
                                Code newCode = this.getCodeBuilder().constant(value);
197
                                return newCode;
198
                            }
199
                            Code newCode = this.getCodeBuilder().function(
200
                                    caller.name(),
201
                                    caller.type(),
202
                                    newArgs
203
                            );
204 44009 jjdelcerro
                            return newCode;
205
                        }
206
                    }
207
                }
208 44139 jjdelcerro
//                break;//                break;
209 44010 jjdelcerro
210 44009 jjdelcerro
            case Code.CONSTANT:
211
            case Code.IDENTIFIER:
212
            case Code.METHOD:
213
            default:
214
                return code;
215
        }
216
    }
217
}