KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jicengine > expression > InvocationParser


1 package org.jicengine.expression;
2
3 import org.jicengine.operation.MethodInvocationOperation;
4 import org.jicengine.operation.ObjectInstantiationOperation;
5 import org.jicengine.operation.ArrayConstructionOperation;
6 import org.jicengine.operation.Operation;
7 import java.util.*;
8
9 /**
10  * <p>
11  * Parses both method and constructor invocations.
12  * </p>
13  * <p>
14  * Copyright (C) 2004 Timo Laitinen
15  * </p>
16  * @author Timo Laitinen
17  * @created 2004-09-20
18  * @since JICE-0.10
19  */
20
21 public class InvocationParser implements Parser {
22
23     private static final String JavaDoc NEW_OPERATOR = "new ";
24     private static final String JavaDoc ARGUMENTS_PART_START = "(";
25     private static final String JavaDoc ARGUMENTS_PART_END = ")";
26     private static final String JavaDoc ARRAY_BRACKET_START = "[";
27     private static final String JavaDoc ARRAY_BRACKET_END = "]";
28     private static final String JavaDoc DOT = ".";
29
30     private Parser elementParser;
31
32     public InvocationParser(Parser elementParser)
33     {
34         this.elementParser = elementParser;
35     }
36
37     public Operation parse(String JavaDoc expression) throws SyntaxException
38     {
39         int argumentsPartStart;
40
41         if( expression.startsWith(NEW_OPERATOR) ){
42             // a 'new' operation, either:
43 // a) 'new full.class.name(parameters)'
44 // b) 'new full.class.name[arraySize]'
45
46             argumentsPartStart = expression.indexOf(ARGUMENTS_PART_START);
47
48             if ( argumentsPartStart != -1 ){
49                 // not an array
50 // extract class-name, like 'java.util.Date' from expression 'new java.util.Date()'.
51 String JavaDoc className = expression.substring(4,argumentsPartStart);
52                 String JavaDoc argumentsList = extractArguments(expression,argumentsPartStart);
53                 return new ObjectInstantiationOperation(expression, elementParser.parse(className), parseArguments(this.elementParser, argumentsList));
54             }
55             else {
56                 int arrayLengthStart = expression.indexOf(ARRAY_BRACKET_START);
57
58                 if( arrayLengthStart != -1 ){
59                     // looks like an array creation..
60 String JavaDoc componentType = expression.substring(4,arrayLengthStart);
61                     String JavaDoc length = expression.substring(arrayLengthStart+1, expression.lastIndexOf(ARRAY_BRACKET_END));
62                     return new ArrayConstructionOperation(expression, elementParser.parse(componentType), elementParser.parse(length));
63                 }
64                 else {
65                     throw new SyntaxException("expected 'new full.class.name(parameters)' or 'new full.class.name[arraySize]', got '" + expression + "'");
66                 }
67             }
68         }
69         else if( (argumentsPartStart = expression.indexOf(ARGUMENTS_PART_START) ) != -1 ){
70             // if the 'new' operator is not used, then some method is called, either a static
71 // or a method of some instance.
72
73             // extract the part before "()" marks.
74 String JavaDoc beforeMethodArguments = expression.substring(0, argumentsPartStart);
75
76             // extract the actor-part, a name of a variable or a class
77 int lastDotIndex = beforeMethodArguments.lastIndexOf(DOT);
78             String JavaDoc actorName = beforeMethodArguments.substring(0,lastDotIndex);
79             String JavaDoc method = beforeMethodArguments.substring(lastDotIndex+1);
80
81             Operation actor = elementParser.parse(actorName);
82
83             Operation[] arguments = parseArguments(this.elementParser, extractArguments(expression, argumentsPartStart));
84
85             return new MethodInvocationOperation(expression, actor, method, arguments);
86         }
87         else {
88             return null;
89         }
90     }
91
92     public static Operation[] parseArguments(Parser parser, String JavaDoc argumentsExpression) throws SyntaxException {
93
94         String JavaDoc[] params = Utils.parseArgumentlist(argumentsExpression);
95         Operation[] paramsAsOperations = new Operation[params.length];
96         for (int i = 0; i < params.length; i++) {
97             paramsAsOperations[i] = parser.parse(params[i]);
98         }
99         return paramsAsOperations;
100     }
101
102         /**
103          * extracts arguments-list from an expression.
104          * Like 'param1,param2' from expression new full.package.name.ClassName(param1,param2)'
105          */
106         private static String JavaDoc extractArguments(String JavaDoc expression, int argumentsPartStart) throws SyntaxException
107         {
108             try {
109                 return expression.substring(argumentsPartStart+1, expression.lastIndexOf(ARGUMENTS_PART_END));
110             } catch (StringIndexOutOfBoundsException JavaDoc e){
111                 throw new SyntaxException("Expression '" + expression + "' doesn't have valid arguments-part enclosed inside ()");
112             }
113         }
114
115 }
116
Popular Tags