Revision 43939 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/DefaultCompiler.java

View differences:

DefaultCompiler.java
9 9

  
10 10
public class DefaultCompiler implements Compiler {
11 11

  
12
    private boolean objectAccessSupported;
12 13
    private LexicalAnalyzer lexer;
13 14
    private CodeBuilder codeBuilder;
14 15
    //
......
18 19
    public DefaultCompiler() {
19 20
        this.lexer = new SQLLexicalAnalyzer();
20 21
        this.codeBuilder = new DefaultCodeBuilder();
22
        this.objectAccessSupported = true;
21 23
    }
22 24

  
23 25
    @Override
......
45 47
    }
46 48
    
47 49
    @Override
50
    public boolean isObjectAccessSupported() {
51
        return this.objectAccessSupported;
52
    }
53

  
54
    @Override
55
    public void setObjectAccessSupported(boolean objectAccessSupported) {
56
        this.objectAccessSupported = objectAccessSupported;
57
    }
58
    
59
    @Override
48 60
    public Code compileExpression(String expression) {
49 61
        this.lexer.setSource(expression);
50 62
        return parseExpression();
......
185 197
    }
186 198

  
187 199
    private Code parse_factor() {
188
        Code op1 = parse_termino();
200
        Code op1 = parse_getattr();
189 201
        Code op2;
190 202
        while( true ) {
191 203
            Token token = lexer.look();
192 204
            switch( token.getType() ) {
193 205
            case Token.OP_MULT:
194 206
                lexer.next();
195
                op2 = parse_termino();
207
                op2 = parse_getattr();
196 208
                op1 = codeBuilder.mult(op1, op2);
197 209
                break;
198 210
            case Token.OP_DIV:
199 211
                lexer.next();
200
                op2 = parse_termino();
212
                op2 = parse_getattr();
201 213
                op1 = codeBuilder.div(op1, op2);
202 214
                break;
203 215
            case Token.OP_MOD:
204 216
                lexer.next();
205
                op2 = parse_termino();
217
                op2 = parse_getattr();
206 218
                op1 = codeBuilder.mod(op1, op2);
207 219
                break;
208 220
            default:
......
211 223
        }
212 224
    }
213 225

  
226
    private Code parse_getattr() {
227
        Code op1 = parse_termino();
228
        if( !isObjectAccessSupported() ) {
229
            return op1;
230
        }
231
        while( true ) {
232
            Token next = lexer.look();
233
            switch( next.getType() ) {
234
            case Token.OP_GETATTR:
235
                lexer.next();
236
                next = lexer.look();
237
                if( next.getType()!=Token.IDENTIFIER ) {
238
                    throw new RuntimeException("An attribute identifier was expected and '"+next.getLiteral()+"' was found");
239
                }
240
                String id = (String) next.getLiteral();
241
                lexer.next();
242
                next = lexer.look();
243
                if( next.getType() == Token.PARENTHESIS_OPEN ) {
244
                    lexer.next();
245
                    Arguments args = parseArgs();
246
                    next = lexer.next();
247
                    if( next.getType() != Token.PARENTHESIS_CLOSE ) {
248
                        throw new RuntimeException("Closing parenthesis was expected and '"+next.getLiteral()+"' was found");
249
                    }
250
                    return codeBuilder.method(op1, id, args);
251
                } else {
252
                    return codeBuilder.getattr(op1, id);
253
                }
254
            default:
255
                return op1;
256
            }
257
        }
258
    }    
259

  
214 260
    private Code parse_termino() {
215 261

  
216 262
        Token token = lexer.look();
......
220 266
                Code value = parseExpression();
221 267
                Token next = lexer.next();
222 268
                if( next.getType() != Token.PARENTHESIS_CLOSE ) {
223
                    throw new RuntimeException();
269
                    throw new RuntimeException("Closing parenthesis was expected and '"+next.getLiteral()+"' was found");
224 270
                }
225 271
                return value;
226 272
            }
......
233 279
                    Arguments args = parseArgs();
234 280
                    next = lexer.next();
235 281
                    if( next.getType() != Token.PARENTHESIS_CLOSE ) {
236
                        throw new RuntimeException("Expected ')'.");
282
                        throw new RuntimeException("Closing parenthesis was expected and '"+next.getLiteral()+"' was found");
237 283
                    }
238 284
                    return codeBuilder.function(id, args);
239 285
                } else {

Also available in: Unified diff