blob: 7f514790260138bc557f0aa6a123316b67a5ef31 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
/*******************************************************************************
* Copyright (c) 2003, 2005 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
/*
* This is for primitive expressions that are optimized out the compiler such as bit or, bit and, etc..
*/
package org.eclipse.jem.internal.proxy.initParser;
import java.text.MessageFormat;
/*
*/
public class PrimitiveOperation extends Expression {
protected int operation; // This can be BitOR or BitAND
protected Expression receiver; // The left hand side of the expression
protected boolean isComplete = false;
public PrimitiveOperation(Expression aReceiver, int anOperation){
receiver = aReceiver;
operation = anOperation;
}
public Object evaluate() throws Exception {
Object leftHandSide = receiver.evaluate();
Object rightHandSide = currentExpression.evaluate();
if (leftHandSide instanceof Integer && rightHandSide instanceof Integer) {
if(operation == BitOR) {
return new Integer(((Integer)leftHandSide).intValue() | ((Integer)rightHandSide).intValue());
} else if(operation == BitAND) {
return new Integer(((Integer)leftHandSide).intValue() & ((Integer)rightHandSide).intValue());
}
}
throw new RuntimeException(MessageFormat.format(ProxyInitParserMessages.getString("PrimitiveOperation.Evaluate.InvalidOperator_EXC_"), new Object[]{getOperDescription(), leftHandSide, rightHandSide})); //$NON-NLS-1$
}
protected String getOperDescription(){
if(operation == BitOR) return "|"; //$NON-NLS-1$
if (operation == BitAND) return "&"; //$NON-NLS-1$
return "???"; //$NON-NLS-1$
}
public boolean isComplete() {
return isComplete;
}
public Class getTypeClass() throws Exception {
return Integer.TYPE;
}
protected String getTypeClassName() {
return Integer.TYPE.getName();
}
public Expression push(char[] token, char tokenDelimiter) {
// Create a new statement if the argument is null ( we are always created with a receiver )
if(currentExpression == null && token.length > 0){
currentExpression = new Statement(fClassLoader).push(token,tokenDelimiter);
pushExpressionStack(currentExpression);
return this;
}
// Ignore whitespace
if(token.length == 0 && tokenDelimiter == ' ') return this;
// If we have an argument we just keep pushing the expression onto this
if(currentExpression != null){
Expression result = currentExpression.push(token,tokenDelimiter);
if(result != currentExpression){
pushExpressionStack(result);
}
}
if(currentExpression != null && currentExpression.isComplete()){
if(tokenDelimiter == DelimiterComma){
isComplete = true;
return this;
} else if (tokenDelimiter == DelimiterCloseParen){
if(receiver.parenthesisLevel > 0){
receiver.parenthesisLevel--;
} else {
isComplete = true;
return this;
}
}
}
return this;
}
public boolean isPrimitive() throws Exception {
return true;
}
public String toString(){
StringBuffer buffer = new StringBuffer();
if (receiver != null) buffer.append(receiver.toString());
buffer.append(getOperDescription());
if (currentExpression != null) buffer.append(currentExpression.toString());
return buffer.toString();
}
}
|
