| /* |
| * Copyright (C) 2010 Google Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.google.clearsilver.jsilver.syntax; |
| |
| import com.google.clearsilver.jsilver.syntax.analysis.DepthFirstAdapter; |
| import com.google.clearsilver.jsilver.syntax.node.AAddExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ADecimalExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ADivideExpression; |
| import com.google.clearsilver.jsilver.syntax.node.AEqExpression; |
| import com.google.clearsilver.jsilver.syntax.node.AFunctionExpression; |
| import com.google.clearsilver.jsilver.syntax.node.AHexExpression; |
| import com.google.clearsilver.jsilver.syntax.node.AModuloExpression; |
| import com.google.clearsilver.jsilver.syntax.node.AMultiplyExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ANameVariable; |
| import com.google.clearsilver.jsilver.syntax.node.ANeExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ANegativeExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ANumericAddExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ANumericEqExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ANumericExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ANumericNeExpression; |
| import com.google.clearsilver.jsilver.syntax.node.ASubtractExpression; |
| import com.google.clearsilver.jsilver.syntax.node.PExpression; |
| import com.google.clearsilver.jsilver.syntax.node.PVariable; |
| |
| /** |
| * AST visitor to add numeric expressions to the syntax tree. |
| * |
| * <p> |
| * There are three types of expression we need to process; addition, equality and inequality. By |
| * default these are treated as string expressions unless one of the operands is numeric, in which |
| * case the original expression is replaced with its numeric equivalent. This behavior seems to |
| * exactly match Clearsilver's type inference system. |
| * |
| * <p> |
| * Note how we preprocess our node before testing to see is it should be replaced. This is very |
| * important because it means that type inference is propagated correctly along compound |
| * expressions. Consider the expression: |
| * |
| * <pre>#a + b + c</pre> |
| * |
| * which is parsed (left-to-right) as: |
| * |
| * <pre>(#a + b) + c</pre> |
| * |
| * When we process the left-hand-side sub-expression {@code #a + b} it is turned into a numeric |
| * addition (due to the forced numeric value on the left). Then when we process the main expression |
| * we propagate the numeric type into it. |
| * |
| * <p> |
| * This matches Clearsilver behavior but means that the expressions: |
| * |
| * <pre>#a + b + c</pre> |
| * |
| * and |
| * |
| * <pre>c + b + #a</pre> |
| * |
| * produce different results (the {@code c + b} subexpression in the latter is evaluated as string |
| * concatenation and not numeric addition). |
| */ |
| public class TypeResolver extends DepthFirstAdapter { |
| |
| @Override |
| public void caseAAddExpression(AAddExpression node) { |
| super.caseAAddExpression(node); |
| PExpression lhs = node.getLeft(); |
| PExpression rhs = node.getRight(); |
| if (isNumeric(lhs) || isNumeric(rhs)) { |
| node.replaceBy(new ANumericAddExpression(lhs, rhs)); |
| } |
| } |
| |
| @Override |
| public void caseAEqExpression(AEqExpression node) { |
| super.caseAEqExpression(node); |
| PExpression lhs = node.getLeft(); |
| PExpression rhs = node.getRight(); |
| if (isNumeric(lhs) || isNumeric(rhs)) { |
| node.replaceBy(new ANumericEqExpression(lhs, rhs)); |
| } |
| } |
| |
| @Override |
| public void caseANeExpression(ANeExpression node) { |
| super.caseANeExpression(node); |
| PExpression lhs = node.getLeft(); |
| PExpression rhs = node.getRight(); |
| if (isNumeric(lhs) || isNumeric(rhs)) { |
| node.replaceBy(new ANumericNeExpression(lhs, rhs)); |
| } |
| } |
| |
| /** |
| * Determines whether the given (sub)expression is numeric, which in turn means that its parent |
| * expression should be treated as numeric if possible. |
| */ |
| static boolean isNumeric(PExpression node) { |
| return node instanceof ANumericExpression // forced numeric (#a) |
| || node instanceof ANumericAddExpression // numeric addition (a + b) |
| || node instanceof ASubtractExpression // subtraction (a - b) |
| || node instanceof AMultiplyExpression // multiplication (a * b) |
| || node instanceof ADivideExpression // division (a / b) |
| || node instanceof AModuloExpression // modulu (x % b) |
| || node instanceof ADecimalExpression // literal decimal (213) |
| || node instanceof AHexExpression // literal hex (0xabc or 0XABC) |
| || node instanceof ANegativeExpression // negative expression (-a) |
| || isNumericFunction(node); // numeric function (subcount) |
| } |
| |
| /** |
| * Determine if the given expression represents a numeric function. |
| */ |
| static boolean isNumericFunction(PExpression node) { |
| if (!(node instanceof AFunctionExpression)) { |
| return false; |
| } |
| PVariable functionName = ((AFunctionExpression) node).getName(); |
| if (functionName instanceof ANameVariable) { |
| String name = ((ANameVariable) functionName).getWord().getText(); |
| if ("max".equals(name) || "min".equals(name) || "abs".equals(name) || "subcount".equals(name)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| } |