Java tutorial
/* * Copyright 2009 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.common.css.compiler.passes; import com.google.common.base.Preconditions; import com.google.common.base.Throwables; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Lists; import com.google.common.css.compiler.ast.CssCompilerPass; import com.google.common.css.compiler.ast.CssCustomFunctionNode; import com.google.common.css.compiler.ast.CssFunctionNode; import com.google.common.css.compiler.ast.CssLiteralNode; import com.google.common.css.compiler.ast.CssValueNode; import com.google.common.css.compiler.ast.DefaultTreeVisitor; import com.google.common.css.compiler.ast.ErrorManager; import com.google.common.css.compiler.ast.GssError; import com.google.common.css.compiler.ast.GssFunction; import com.google.common.css.compiler.ast.GssFunctionException; import com.google.common.css.compiler.ast.MutatingVisitController; import com.google.common.css.compiler.ast.Proxiable; import java.util.List; import java.util.Map; import java.util.Set; /** * This compiler pass replaces {@link CssCustomFunctionNode} instances with the * list of nodes returned by the GssFunction. * */ public class ResolveCustomFunctionNodes extends DefaultTreeVisitor implements CssCompilerPass { private final MutatingVisitController visitController; protected Map<String, GssFunction> functionMap; private final ErrorManager errorManager; private final boolean allowUnknownFunctions; private final Set<String> allowedNonStandardFunctions; /** * Constructs the pass. * * @param visitController The visit controller * @param errorManager The error manager * @param functionMap The map from function names to resolve to GSS functions */ public ResolveCustomFunctionNodes(MutatingVisitController visitController, ErrorManager errorManager, Map<String, GssFunction> functionMap) { this(visitController, errorManager, functionMap, false /* allowUnknownFunctions */); } /** * Constructs the pass. * * @param visitController The visit controller * @param errorManager The error manager * @param functionMap The map from function names to resolve to GSS functions * @param allowUnknownFunctions Whether to allow unknown function calls, * leaving them as is, instead of reporting an error */ public ResolveCustomFunctionNodes(MutatingVisitController visitController, ErrorManager errorManager, Map<String, GssFunction> functionMap, boolean allowUnknownFunctions) { this(visitController, errorManager, functionMap, allowUnknownFunctions, ImmutableSet.<String>of() /* allowedNonStandardFunctions */); } /** * Constructs the pass. * * @param visitController The visit controller * @param errorManager The error manager * @param functionMap The map from function names to resolve to GSS functions * @param allowUnknownFunctions Whether to allow unknown function calls, * leaving them as is, instead of reporting an error * @param allowedNonStandardFunctions functions that should not yield a * warning if they appear in a stylesheet */ public ResolveCustomFunctionNodes(MutatingVisitController visitController, ErrorManager errorManager, Map<String, GssFunction> functionMap, boolean allowUnknownFunctions, Set<String> allowedNonStandardFunctions) { Preconditions.checkNotNull(functionMap); this.visitController = visitController; this.errorManager = errorManager; this.functionMap = functionMap; this.allowUnknownFunctions = allowUnknownFunctions; this.allowedNonStandardFunctions = ImmutableSet.copyOf(allowedNonStandardFunctions); } @Override public void leaveFunctionNode(CssFunctionNode functionNode) { if (!(functionNode instanceof Proxiable)) { return; } CssCustomFunctionNode node = (CssCustomFunctionNode) functionNode; List<CssValueNode> functionResult = node.getResult(); if (functionResult == null) { // Look up the function's name in the map. String functionName = node.getFunctionName(); GssFunction function = functionMap.get(functionName); if (function == null) { if (!allowUnknownFunctions && !allowedNonStandardFunctions.contains(functionName)) { errorManager.report(new GssError(String.format("Unknown function \"%s\"", functionName), node.getSourceCodeLocation())); visitController.removeCurrentNode(); } return; } // Removes the commas from the arguments and groups arguments separated // by commas, e.g.: // verticalGradient(#fff, #f2f2f2, url(foo) left top) // has 7 initial arguments (2 commas, 5 words). // After the cleanup we end up with the 3 arguments separated by commas. // TODO(user): Clean this up once we get rid of the comma-as-argument hack. List<CssValueNode> arguments = Lists.newArrayList(); CssValueNode lastArg = null; for (CssValueNode value : node.getArguments().childIterable()) { if (value.getValue() != null && value.getValue().equals(",")) { lastArg = null; } else { if (lastArg == null) { arguments.add(value); lastArg = value; } else { if (value instanceof CssLiteralNode && " ".equals(value.getValue())) { // Here we are building a parse subtree that, when // printed by most output passes, looks like the subtree // we got as input, but actually consists of just a // CssLiteralNode. This requires us to add some // whitespace to the printed representations of the // nodes we are merging, corresponding to the whitespace // eaten by the parser between lexemes and generated by // printing passes when flattening a tree back to a // string. But functions are special: the parse tree // includes CssLiteralNode(" ") to explicitly represent // function argument delimiters. We need to avoid adding // extra space here, just as printing passes do. } else if (lastArg.getValue() == null) { arguments.remove(lastArg); lastArg = new CssLiteralNode(lastArg.toString() + " " + value.toString()); arguments.add(lastArg); } else { lastArg.setValue(lastArg.getValue() + " " + value.toString()); } } } } Integer expArgNumber = function.getNumExpectedArguments(); int argNumber = arguments.size(); if (expArgNumber != null && expArgNumber.intValue() != argNumber) { errorManager .report(new GssError("Function expects " + expArgNumber + " arguments but has " + argNumber, node.getSourceCodeLocation())); visitController.removeCurrentNode(); return; } try { functionResult = evaluateFunction(node, function, arguments, errorManager); } catch (GssFunctionException e) { visitController.removeCurrentNode(); return; } catch (RuntimeException e) { errorManager .report(new GssError(Throwables.getStackTraceAsString(e), node.getSourceCodeLocation())); visitController.removeCurrentNode(); return; } } visitController.replaceCurrentBlockChildWith(functionResult, false); } /** * Evaluates the given function node. * * <p>Subclasses may sublcass this method to change the evaluation * process in some circumstances. * * @param node the function node to evaluate * @param function the GSS function matching this node * @param arguments the arguments of this node * @param errorManager the error manager passed into the GSS function call * @return the result of the evaluation as a list of value nodes * @throws GssFunctionException if the function call is invalid * @throws RuntimeException if the function call fails to complete */ protected List<CssValueNode> evaluateFunction(CssCustomFunctionNode node, GssFunction function, List<CssValueNode> arguments, ErrorManager errorManager) throws GssFunctionException { List<CssValueNode> functionResult = function.getCallResultNodes(arguments, errorManager); node.setResult(functionResult); return functionResult; } @Override public void runPass() { visitController.startVisit(this); } }