/*
* Copyright 2008 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.gwt.resources.css;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.resources.css.ast.CssDef;
import com.google.gwt.resources.css.ast.CssEval;
import com.google.gwt.resources.css.ast.CssExternalSelectors;
import com.google.gwt.resources.css.ast.CssIf;
import com.google.gwt.resources.css.ast.CssMediaRule;
import com.google.gwt.resources.css.ast.CssNoFlip;
import com.google.gwt.resources.css.ast.CssNode;
import com.google.gwt.resources.css.ast.CssPageRule;
import com.google.gwt.resources.css.ast.CssProperty;
import com.google.gwt.resources.css.ast.CssRule;
import com.google.gwt.resources.css.ast.CssSelector;
import com.google.gwt.resources.css.ast.CssSprite;
import com.google.gwt.resources.css.ast.CssStylesheet;
import com.google.gwt.resources.css.ast.CssUnknownAtRule;
import com.google.gwt.resources.css.ast.CssUrl;
import com.google.gwt.resources.css.ast.HasNodes;
import com.google.gwt.resources.css.ast.HasProperties;
import com.google.gwt.resources.css.ast.CssProperty.DotPathValue;
import com.google.gwt.resources.css.ast.CssProperty.IdentValue;
import com.google.gwt.resources.css.ast.CssProperty.ListValue;
import com.google.gwt.resources.css.ast.CssProperty.NumberValue;
import com.google.gwt.resources.css.ast.CssProperty.StringValue;
import com.google.gwt.resources.css.ast.CssProperty.TokenValue;
import com.google.gwt.resources.css.ast.CssProperty.Value;
import org.w3c.css.sac.AttributeCondition;
import org.w3c.css.sac.CSSException;
import org.w3c.css.sac.CSSParseException;
import org.w3c.css.sac.CharacterDataSelector;
import org.w3c.css.sac.CombinatorCondition;
import org.w3c.css.sac.Condition;
import org.w3c.css.sac.ConditionalSelector;
import org.w3c.css.sac.ContentCondition;
import org.w3c.css.sac.DescendantSelector;
import org.w3c.css.sac.DocumentHandler;
import org.w3c.css.sac.ElementSelector;
import org.w3c.css.sac.ErrorHandler;
import org.w3c.css.sac.InputSource;
import org.w3c.css.sac.LangCondition;
import org.w3c.css.sac.LexicalUnit;
import org.w3c.css.sac.NegativeCondition;
import org.w3c.css.sac.NegativeSelector;
import org.w3c.css.sac.PositionalCondition;
import org.w3c.css.sac.ProcessingInstructionSelector;
import org.w3c.css.sac.SACMediaList;
import org.w3c.css.sac.Selector;
import org.w3c.css.sac.SelectorList;
import org.w3c.css.sac.SiblingSelector;
import org.w3c.flute.parser.Parser;
import java.io.IOException;
import java.io.StringReader;
import java.lang.ref.SoftReference;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Generates a CssStylesheet from the contents of a URL.
*/
@SuppressWarnings("unused")
public class GenerateCssAst {
/**
* Maps SAC CSSParseExceptions into a TreeLogger. All parsing errors will be
* recorded in a single TreeLogger branch, which will be created only if a
* loggable error message is emitted.
*/
private static class Errors implements ErrorHandler {
/**
* A flag that controls whether or not the exec method will fail.
*/
private boolean fatalErrorEncountered;
private TreeLogger logger;
private final TreeLogger parentLogger;
/**
* Constructor.
*
* @param parentLogger the TreeLogger that should be branched to produce the
* CSS parsing messages.
*/
public Errors(TreeLogger parentLogger) {
this.parentLogger = parentLogger;
}
public TreeLogger branch(TreeLogger.Type type, String message) {
return branch(type, message, null);
}
public TreeLogger branch(TreeLogger.Type type, String message, Throwable t) {
return logOrBranch(type, message, t, true);
}
public void error(CSSParseException exception) throws CSSException {
// TODO Since this indicates a loss of data, should this be a fatal error?
log(TreeLogger.WARN, exception);
}
public void fatalError(CSSParseException exception) throws CSSException {
log(TreeLogger.ERROR, exception);
}
public void log(TreeLogger.Type type, String message) {
log(type, message, null);
}
public void log(TreeLogger.Type type, String message, Throwable t) {
logOrBranch(type, message, t, false);
}
public void warning(CSSParseException exception) throws CSSException {
log(TreeLogger.DEBUG, exception);
}
private void log(TreeLogger.Type type, CSSParseException e) {
log(type, "Line " + e.getLineNumber() + " column " + e.getColumnNumber()
+ ": " + e.getMessage());
}
private TreeLogger logOrBranch(TreeLogger.Type type, String message,
Throwable t, boolean branch) {
fatalErrorEncountered |= type == TreeLogger.ERROR;
if (parentLogger.isLoggable(type)) {
maybeBranch();
if (branch) {
return logger.branch(type, message, t);
} else {
logger.log(type, message, t);
return null;
}
} else {
return TreeLogger.NULL;
}
}
private void maybeBranch() {
if (logger == null) {
logger = parentLogger.branch(TreeLogger.INFO,
"The following problems were detected");
}
}
}
/**
* Maps the SAC model into our own CSS AST nodes.
*/
private static class GenerationHandler implements DocumentHandler {
/**
* The stylesheet that is being composed.
*/
private final CssStylesheet css = new CssStylesheet();
/**
* Accumulates CSS nodes as they are created.
*/
private final Stack<HasNodes> currentParent = new Stack<HasNodes>();
/**
* Accumulates CSS properties as they are seen.
*/
private HasProperties currentRule;
/**
* Records references to {@code @def} rules.
*/
private final Map<String, CssDef> defs = new HashMap<String, CssDef>();
/**
* Used when parsing the contents of meta-styles.
*/
private final Errors errors;
/**
* Used by {@link #startSelector(SelectorList)} to suppress the creation of
* new CssRules in favor of retaining {@link #currentRule}.
*/
private boolean nextSelectorCreatesRule = true;
public GenerationHandler(Errors errors) {
this.errors = errors;
currentParent.push(css);
}
public void comment(String text) throws CSSException {
// Ignore comments
// TODO Should comments be retained but not generally printed?
}
public void endDocument(InputSource source) throws CSSException {
}
public void endFontFace() throws CSSException {
}
public void endMedia(SACMediaList media) throws CSSException {
currentParent.pop();
}
public void endPage(String name, String pseudoPage) throws CSSException {
}
public void endSelector(SelectorList selectors) throws CSSException {
}
/**
* Reflectively invoke a method named parseRule on this instance.
*/
public void ignorableAtRule(String atRule) throws CSSException {
int idx = atRule.indexOf(" ");
if (idx == -1) {
// Empty rule like @foo;
addNode(new CssUnknownAtRule(atRule));
return;
}
String ruleName = atRule.substring(1, idx);
String methodName = "parse" + (Character.toUpperCase(ruleName.charAt(0)))
+ ruleName.substring(1).toLowerCase();
try {
Method parseMethod = getClass().getDeclaredMethod(methodName,
String.class);
parseMethod.invoke(this, atRule);
} catch (NoSuchMethodException e) {
// A rule like @-webkit-keyframe {...} that we can't process
addNode(new CssUnknownAtRule(atRule));
} catch (IllegalAccessException e) {
errors.log(TreeLogger.ERROR, "Unable to invoke parse method ", e);
} catch (InvocationTargetException e) {
Throwable cause = e.getCause();
if (cause instanceof CSSException) {
// Unwind a CSSException normally
throw (CSSException) cause;
} else if (cause != null) {
// Otherwise, report the message nicely
TreeLogger details = errors.branch(TreeLogger.ERROR,
cause.getMessage());
details.log(TreeLogger.DEBUG, "Full stack trace", cause);
} else {
TreeLogger details = errors.branch(TreeLogger.ERROR,
"Unknown failure parsing " + ruleName);
details.log(TreeLogger.DEBUG, "Full stack trace", e);
}
}
}
public void importStyle(String uri, SACMediaList media,
String defaultNamespaceURI) throws CSSException {
}
public void namespaceDeclaration(String prefix, String uri)
throws CSSException {
}
public void property(String name, LexicalUnit value, boolean important)
throws CSSException {
List<Value> values = new ArrayList<Value>();
if (value != null) {
extractValueOf(values, value);
}
currentRule.getProperties().add(
new CssProperty(escapeIdent(name), new ListValue(values), important));
}
public void startDocument(InputSource source) throws CSSException {
}
public void startFontFace() throws CSSException {
}
public void startMedia(SACMediaList media) throws CSSException {
CssMediaRule r = new CssMediaRule();
for (int i = 0; i < media.getLength(); i++) {
r.getMedias().add(media.item(i));
}
pushParent(r);
}
public void startPage(String name, String pseudoPage) throws CSSException {
CssPageRule r = new CssPageRule();
// name appears to be unused in CSS2
r.setPseudoPage(pseudoPage);
addNode(r);
currentRule = r;
}
public void startSelector(SelectorList selectors) throws CSSException {
CssRule r;
if (nextSelectorCreatesRule) {
r = new CssRule();
addNode(r);
currentRule = r;
} else {
r = (CssRule) currentRule;
nextSelectorCreatesRule = true;
}
for (int i = 0; i < selectors.getLength(); i++) {
r.getSelectors().add(new CssSelector(valueOf(selectors.item(i))));
}
}
void parseDef(String atRule) {
String value = atRule.substring(4, atRule.length()).trim();
InputSource s = new InputSource();
s.setCharacterStream(new StringReader(value));
Parser parser = new Parser();
parser.setErrorHandler(errors);
final List<Value> values = new ArrayList<Value>();
parser.setDocumentHandler(new PropertyExtractor(values));
try {
String dummy = "* { prop : " + value + "}";
parser.parseStyleSheet(new InputSource(new StringReader(dummy)));
} catch (IOException e) {
assert false : "Should never happen";
}
if (values.size() < 2) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"@def rules must specify an identifier and one or more values",
null);
}
IdentValue defName = values.get(0).isIdentValue();
if (defName == null) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"First lexical unit must be an identifier", null);
}
/*
* Replace any references to previously-seen @def constructs. We do
* expansion up-front to prevent the need for cycle-detection later.
*/
for (ListIterator<Value> it = values.listIterator(1); it.hasNext();) {
IdentValue maybeDefReference = it.next().isIdentValue();
if (maybeDefReference != null) {
CssDef previousDef = defs.get(maybeDefReference.getIdent());
if (previousDef != null) {
it.remove();
for (Value previousValue : previousDef.getValues()) {
it.add(previousValue);
}
}
}
}
CssDef def = new CssDef(defName.getIdent());
def.getValues().addAll(values.subList(1, values.size()));
addNode(def);
defs.put(defName.getIdent(), def);
}
/**
* The elif nodes are processed as though they were {@code @if} nodes. The
* newly-generated CssIf node will be attached to the last CssIf in the
* if/else chain.
*/
void parseElif(String atRule) throws CSSException {
List<CssNode> nodes = currentParent.peek().getNodes();
CssIf lastIf = findLastIfInChain(nodes);
if (lastIf == null) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"@elif must immediately follow an @if or @elif", null);
}
assert lastIf.getElseNodes().isEmpty();
// @elif -> lif (because parseIf strips the first three chars)
parseIf(atRule.substring(2));
// Fix up the structure by remove the newly-created node from the parent
// context and moving it to the end of the @if chain
lastIf.getElseNodes().add(nodes.remove(nodes.size() - 1));
}
/**
* The else nodes are processed as though they were written as {@code @elif
* true} rules.
*/
void parseElse(String atRule) throws CSSException {
// The last CssIf in the if/else chain
CssIf lastIf = findLastIfInChain(currentParent.peek().getNodes());
if (lastIf == null) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"@else must immediately follow an @if or @elif", null);
}
// Create the CssIf to hold the @else rules
String fakeElif = "@elif (true) " + atRule.substring(atRule.indexOf("{"));
parseElif(fakeElif);
CssIf elseIf = findLastIfInChain(currentParent.peek().getNodes());
assert lastIf.getElseNodes().size() == 1
&& lastIf.getElseNodes().get(0) == elseIf;
assert elseIf.getElseNodes().isEmpty();
// Merge the rules into the last CssIf to break the chain and prevent
// @else followed by @else
lastIf.getElseNodes().clear();
lastIf.getElseNodes().addAll(elseIf.getNodes());
}
void parseEval(String atRule) throws CSSException {
// @eval key com.google.Type.staticFunction
String[] parts = atRule.substring(0, atRule.length() - 1).split("\\s");
if (parts.length != 3) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"Incorrect number of parts for @eval", null);
}
CssEval eval = new CssEval(parts[1], parts[2]);
addNode(eval);
}
void parseExternal(String atRule) throws CSSException {
// @external .foo, bar; Drop the dots and commas
String[] parts = atRule.substring(10, atRule.length() - 1).replaceAll(
"(, *)|( +)", " ").replaceAll("\\.", "").split(" ");
CssExternalSelectors externals = new CssExternalSelectors();
Collections.addAll(externals.getClasses(), parts);
addNode(externals);
}
void parseIf(String atRule) throws CSSException {
String predicate = atRule.substring(3, atRule.indexOf('{') - 1).trim();
String blockContents = atRule.substring(atRule.indexOf('{') + 1,
atRule.length() - 1);
CssIf cssIf = new CssIf();
if (predicate.startsWith("(") && predicate.endsWith(")")) {
cssIf.setExpression(predicate);
} else {
String[] predicateParts = predicate.split("\\s");
switch (predicateParts.length) {
case 0:
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"Incorrect format for @if predicate", null);
case 1:
if (predicateParts[0].length() == 0) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"Incorrect format for @if predicate", null);
}
errors.log(
TreeLogger.WARN,
"Deprecated syntax for Java expression detected. Enclose the expression in parentheses");
cssIf.setExpression(predicateParts[0]);
break;
default:
if (predicateParts[0].startsWith("!")) {
cssIf.setNegated(true);
cssIf.setProperty(predicateParts[0].substring(1));
} else {
cssIf.setProperty(predicateParts[0]);
}
String[] values = new String[predicateParts.length - 1];
System.arraycopy(predicateParts, 1, values, 0, values.length);
cssIf.setPropertyValues(values);
}
}
parseInnerStylesheet("@if", cssIf, blockContents);
}
void parseNoflip(String atRule) throws CSSException {
String blockContents = atRule.substring(atRule.indexOf('{') + 1,
atRule.length() - 1);
parseInnerStylesheet("@noflip", new CssNoFlip(), blockContents);
}
void parseSprite(String atRule) throws CSSException {
CssSprite sprite = new CssSprite();
currentRule = sprite;
addNode(sprite);
// Flag to tell startSelector() to use the CssSprite instead of creating
// its own CssRule.
nextSelectorCreatesRule = false;
// parse the inner text
InputSource s = new InputSource();
s.setCharacterStream(new StringReader(atRule.substring(7)));
Parser parser = new Parser();
parser.setDocumentHandler(this);
parser.setErrorHandler(errors);
try {
parser.parseRule(s);
} catch (IOException e) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"Unable to parse @sprite", e);
}
}
void parseUrl(String atRule) throws CSSException {
// @url key dataResourceFunction
String[] parts = atRule.substring(0, atRule.length() - 1).split("\\s");
if (parts.length != 3) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"Incorrect number of parts for @url", null);
}
CssUrl url = new CssUrl(parts[1], parts[2]);
addNode(url);
}
/**
* Add a node to the current parent.
*/
private void addNode(CssNode node) {
currentParent.peek().getNodes().add(node);
}
private <T extends CssNode & HasNodes> void parseInnerStylesheet(
String tagName, T parent, String blockContents) {
pushParent(parent);
// parse the inner text
InputSource s = new InputSource();
s.setCharacterStream(new StringReader(blockContents));
Parser parser = new Parser();
parser.setDocumentHandler(this);
parser.setErrorHandler(errors);
try {
parser.parseStyleSheet(s);
} catch (IOException e) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR, "Unable to parse "
+ tagName, e);
}
if (currentParent.pop() != parent) {
// This is a coding error
throw new RuntimeException("Incorrect element popped");
}
}
/**
* Adds a node to the current parent and then makes the node the current
* parent node.
*/
private <T extends CssNode & HasNodes> void pushParent(T newParent) {
addNode(newParent);
currentParent.push(newParent);
}
}
/**
* Extracts all properties in a document into a List.
*/
private static class PropertyExtractor implements DocumentHandler {
private final List<Value> values;
private PropertyExtractor(List<Value> values) {
this.values = values;
}
public void comment(String text) throws CSSException {
}
public void endDocument(InputSource source) throws CSSException {
}
public void endFontFace() throws CSSException {
}
public void endMedia(SACMediaList media) throws CSSException {
}
public void endPage(String name, String pseudoPage) throws CSSException {
}
public void endSelector(SelectorList selectors) throws CSSException {
}
public void ignorableAtRule(String atRule) throws CSSException {
}
public void importStyle(String uri, SACMediaList media,
String defaultNamespaceURI) throws CSSException {
}
public void namespaceDeclaration(String prefix, String uri)
throws CSSException {
}
public void property(String name, LexicalUnit value, boolean important)
throws CSSException {
extractValueOf(values, value);
}
public void startDocument(InputSource source) throws CSSException {
}
public void startFontFace() throws CSSException {
}
public void startMedia(SACMediaList media) throws CSSException {
}
public void startPage(String name, String pseudoPage) throws CSSException {
}
public void startSelector(SelectorList selectors) throws CSSException {
}
}
/**
* Associates a template CssStylesheet with a timestamp.
*/
private static class CachedStylesheet {
private final CssStylesheet sheet;
private final long timestamp;
public CachedStylesheet(CssStylesheet sheet, long timestamp) {
this.sheet = sheet;
this.timestamp = timestamp;
}
public CssStylesheet getCopyOfStylesheet() {
return new CssStylesheet(sheet);
}
public long getTimestamp() {
return timestamp;
}
}
private static final String LITERAL_FUNCTION_NAME = "literal";
/**
* We cache the stylesheets to prevent repeated parsing of the same source
* material. This is a common case if the user is using UiBinder's implicit
* stylesheets. It is necessary to use the list of URLs passed to exec because
* of the eager variable expansion performed by
* {@link GenerationHandler#parseDef(String)}.
*/
private static final Map<List<URL>, SoftReference<CachedStylesheet>> SHEETS = Collections.synchronizedMap(new HashMap<List<URL>, SoftReference<CachedStylesheet>>());
private static final String VALUE_FUNCTION_NAME = "value";
/**
* Create a CssStylesheet from the contents of one or more URLs. If multiple
* URLs are provided, the generated stylesheet will be created as though the
* contents of the URLs had been concatenated.
*/
public static CssStylesheet exec(TreeLogger logger, URL... stylesheets)
throws UnableToCompleteException {
long mtime = 0;
for (URL url : stylesheets) {
long lastModified;
try {
lastModified = url.openConnection().getLastModified();
} catch (IOException e) {
// Non-fatal, assuming we can re-open the stream later
logger.log(TreeLogger.DEBUG, "Could not determine cached time", e);
lastModified = 0;
}
if (lastModified == 0) {
/*
* We have to refresh, since the modification date can't be determined,
* either due to IOException or getLastModified() not providing useful
* data.
*/
mtime = Long.MAX_VALUE;
break;
} else {
mtime = Math.max(mtime, lastModified);
}
}
List<URL> sheets = Arrays.asList(stylesheets);
SoftReference<CachedStylesheet> ref = SHEETS.get(sheets);
CachedStylesheet toReturn = ref == null ? null : ref.get();
if (toReturn != null) {
if (mtime <= toReturn.getTimestamp()) {
logger.log(TreeLogger.DEBUG, "Using cached result");
return toReturn.getCopyOfStylesheet();
} else {
logger.log(TreeLogger.DEBUG, "Invalidating cached stylesheet");
}
}
Parser p = new Parser();
Errors errors = new Errors(logger);
GenerationHandler g = new GenerationHandler(errors);
p.setDocumentHandler(g);
p.setErrorHandler(errors);
for (URL stylesheet : sheets) {
TreeLogger branchLogger = logger.branch(TreeLogger.DEBUG,
"Parsing CSS stylesheet " + stylesheet.toExternalForm());
try {
p.parseStyleSheet(stylesheet.toURI().toString());
continue;
} catch (CSSException e) {
branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
} catch (IOException e) {
branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
} catch (URISyntaxException e) {
branchLogger.log(TreeLogger.ERROR, "Unable to parse CSS", e);
}
throw new UnableToCompleteException();
}
if (errors.fatalErrorEncountered) {
// Logging will have been performed by the Errors instance, just exit
throw new UnableToCompleteException();
}
toReturn = new CachedStylesheet(g.css, mtime == Long.MAX_VALUE ? 0 : mtime);
SHEETS.put(new ArrayList<URL>(sheets), new SoftReference<CachedStylesheet>(
toReturn));
return toReturn.getCopyOfStylesheet();
}
/**
* Expresses an rgb function as a hex expression.
*
* @param colors a sequence of LexicalUnits, assumed to be
* <code>(VAL COMMA VAL COMMA VAL)</code> where VAL can be an INT or
* a PERCENT (which is then converted to INT)
* @return the minimal hex expression for the RGB color values
*/
private static Value colorValue(LexicalUnit colors) {
LexicalUnit red = colors;
int r = getRgbComponentValue(red);
LexicalUnit green = red.getNextLexicalUnit().getNextLexicalUnit();
int g = getRgbComponentValue(green);
LexicalUnit blue = green.getNextLexicalUnit().getNextLexicalUnit();
int b = getRgbComponentValue(blue);
String sr = Integer.toHexString(r);
if (sr.length() == 1) {
sr = "0" + sr;
}
String sg = Integer.toHexString(g);
if (sg.length() == 1) {
sg = "0" + sg;
}
String sb = Integer.toHexString(b);
if (sb.length() == 1) {
sb = "0" + sb;
}
// #AABBCC --> #ABC
if (sr.charAt(0) == sr.charAt(1) && sg.charAt(0) == sg.charAt(1)
&& sb.charAt(0) == sb.charAt(1)) {
sr = sr.substring(1);
sg = sg.substring(1);
sb = sb.substring(1);
}
return new IdentValue("#" + sr + sg + sb);
}
private static String escapeIdent(String selector) {
assert selector.length() > 0;
StringBuilder toReturn = new StringBuilder();
if (selector.charAt(0) == '-') {
// Allow leading hyphen
selector = selector.substring(1);
toReturn.append('-');
}
if (!isIdentStart(selector.charAt(0))) {
toReturn.append('\\');
}
toReturn.append(selector.charAt(0));
if (selector.length() > 1) {
for (char c : selector.substring(1).toCharArray()) {
if (!isIdentPart(c)) {
toReturn.append('\\');
}
toReturn.append(c);
}
}
return toReturn.toString();
}
/**
* Convert a LexicalUnit list into a List of Values.
*/
private static void extractValueOf(List<Value> accumulator, LexicalUnit value) {
do {
accumulator.add(valueOf(value));
value = value.getNextLexicalUnit();
} while (value != null);
}
/**
* The elif and else constructs are modeled as nested if statements in the
* CssIf's elseNodes field. This method will search a list of CssNodes and
* remove the last chained CssIf from the last element in the list of nodes.
*/
private static CssIf findLastIfInChain(List<CssNode> nodes) {
if (nodes.isEmpty()) {
return null;
}
CssNode lastNode = nodes.get(nodes.size() - 1);
if (lastNode instanceof CssIf) {
CssIf asIf = (CssIf) lastNode;
if (asIf.getElseNodes().isEmpty()) {
return asIf;
} else {
return findLastIfInChain(asIf.getElseNodes());
}
}
return null;
}
/**
* Return an integer value from 0-255 for a component of an RGB color.
*
* @param color typed value from the CSS parser, which may be an INTEGER or a
* PERCENTAGE
* @return integer value from 0-255
* @throws IllegalArgumentException if the color is not an INTEGER or
* PERCENTAGE value
*/
private static int getRgbComponentValue(LexicalUnit color) {
switch (color.getLexicalUnitType()) {
case LexicalUnit.SAC_INTEGER:
return Math.min(color.getIntegerValue(), 255);
case LexicalUnit.SAC_PERCENTAGE:
return (int) Math.min(color.getFloatValue() * 255, 255);
default:
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"RGB component value must be integer or percentage, was " + color,
null);
}
}
private static boolean isIdentPart(char c) {
return Character.isLetterOrDigit(c) || (c == '\\') || (c == '-')
|| (c == '_');
}
private static boolean isIdentStart(char c) {
return Character.isLetter(c) || (c == '\\') || (c == '_');
}
/**
* Utility method to concatenate strings.
*/
private static String join(Iterable<Value> elements, String separator) {
StringBuilder b = new StringBuilder();
for (Iterator<Value> i = elements.iterator(); i.hasNext();) {
b.append(i.next().toCss());
if (i.hasNext()) {
b.append(separator);
}
}
return b.toString();
}
private static String maybeUnquote(String s) {
if (s.startsWith("\"") && s.endsWith("\"")) {
return s.substring(1, s.length() - 1);
}
return s;
}
/**
* Used when evaluating literal() rules.
*/
private static String unescapeLiteral(String s) {
s = s.replaceAll(Pattern.quote("\\\""), "\"");
s = s.replaceAll(Pattern.quote("\\\\"), Matcher.quoteReplacement("\\"));
return s;
}
private static String valueOf(Condition condition) {
if (condition instanceof AttributeCondition) {
AttributeCondition c = (AttributeCondition) condition;
switch (c.getConditionType()) {
case Condition.SAC_ATTRIBUTE_CONDITION:
return "[" + c.getLocalName()
+ (c.getValue() != null ? "=\"" + c.getValue() + '"' : "") + "]";
case Condition.SAC_ONE_OF_ATTRIBUTE_CONDITION:
return "[" + c.getLocalName() + "~=\"" + c.getValue() + "\"]";
case Condition.SAC_BEGIN_HYPHEN_ATTRIBUTE_CONDITION:
return "[" + c.getLocalName() + "|=\"" + c.getValue() + "\"]";
case Condition.SAC_ID_CONDITION:
return "#" + c.getValue();
case Condition.SAC_CLASS_CONDITION:
return "." + c.getValue();
case Condition.SAC_PSEUDO_CLASS_CONDITION:
return ":" + c.getValue();
}
} else if (condition instanceof CombinatorCondition) {
CombinatorCondition c = (CombinatorCondition) condition;
switch (condition.getConditionType()) {
case Condition.SAC_AND_CONDITION:
return valueOf(c.getFirstCondition())
+ valueOf(c.getSecondCondition());
case Condition.SAC_OR_CONDITION:
// Unimplemented in CSS2?
}
} else if (condition instanceof ContentCondition) {
// Unimplemented in CSS2?
} else if (condition instanceof LangCondition) {
LangCondition c = (LangCondition) condition;
return ":lang(" + c.getLang() + ")";
} else if (condition instanceof NegativeCondition) {
// Unimplemented in CSS2?
} else if (condition instanceof PositionalCondition) {
// Unimplemented in CSS2?
}
throw new RuntimeException("Unhandled condition of type "
+ condition.getConditionType() + " " + condition.getClass().getName());
}
private static Value valueOf(LexicalUnit value) {
switch (value.getLexicalUnitType()) {
case LexicalUnit.SAC_ATTR:
return new IdentValue("attr(" + value.getStringValue() + ")");
case LexicalUnit.SAC_IDENT:
return new IdentValue(escapeIdent(value.getStringValue()));
case LexicalUnit.SAC_STRING_VALUE:
return new StringValue(value.getStringValue());
case LexicalUnit.SAC_RGBCOLOR:
// flute models the commas as operators so no separator needed
return colorValue(value.getParameters());
case LexicalUnit.SAC_INTEGER:
return new NumberValue(value.getIntegerValue());
case LexicalUnit.SAC_REAL:
return new NumberValue(value.getFloatValue());
case LexicalUnit.SAC_CENTIMETER:
case LexicalUnit.SAC_DEGREE:
case LexicalUnit.SAC_DIMENSION:
case LexicalUnit.SAC_EM:
case LexicalUnit.SAC_EX:
case LexicalUnit.SAC_GRADIAN:
case LexicalUnit.SAC_HERTZ:
case LexicalUnit.SAC_KILOHERTZ:
case LexicalUnit.SAC_MILLIMETER:
case LexicalUnit.SAC_MILLISECOND:
case LexicalUnit.SAC_PERCENTAGE:
case LexicalUnit.SAC_PICA:
case LexicalUnit.SAC_PIXEL:
case LexicalUnit.SAC_POINT:
case LexicalUnit.SAC_RADIAN:
case LexicalUnit.SAC_SECOND:
return new NumberValue(value.getFloatValue(),
value.getDimensionUnitText());
case LexicalUnit.SAC_URI:
return new IdentValue("url(" + value.getStringValue() + ")");
case LexicalUnit.SAC_OPERATOR_COMMA:
return new TokenValue(",");
case LexicalUnit.SAC_COUNTER_FUNCTION:
case LexicalUnit.SAC_COUNTERS_FUNCTION:
case LexicalUnit.SAC_FUNCTION: {
if (value.getFunctionName().equals(VALUE_FUNCTION_NAME)) {
// This is a call to value()
List<Value> params = new ArrayList<Value>();
extractValueOf(params, value.getParameters());
if (params.size() != 1 && params.size() != 3) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"Incorrect number of parameters to " + VALUE_FUNCTION_NAME,
null);
}
Value dotPathValue = params.get(0);
String dotPath = maybeUnquote(((StringValue) dotPathValue).getValue());
String suffix = params.size() == 3
? maybeUnquote(((StringValue) params.get(2)).getValue()) : "";
return new DotPathValue(dotPath, suffix);
} else if (value.getFunctionName().equals(LITERAL_FUNCTION_NAME)) {
// This is a call to value()
List<Value> params = new ArrayList<Value>();
extractValueOf(params, value.getParameters());
if (params.size() != 1) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"Incorrect number of parameters to " + LITERAL_FUNCTION_NAME,
null);
}
Value expression = params.get(0);
if (!(expression instanceof StringValue)) {
throw new CSSException(CSSException.SAC_SYNTAX_ERR,
"The single argument to " + LITERAL_FUNCTION_NAME
+ " must be a string value", null);
}
String s = maybeUnquote(((StringValue) expression).getValue());
s = unescapeLiteral(s);
return new IdentValue(s);
} else {
// Just return a String representation of the original value
List<Value> parameters = new ArrayList<Value>();
extractValueOf(parameters, value.getParameters());
return new IdentValue(value.getFunctionName() + "("
+ join(parameters, "") + ")");
}
}
case LexicalUnit.SAC_INHERIT:
return new IdentValue("inherit");
case LexicalUnit.SAC_OPERATOR_EXP:
return new TokenValue("^");
case LexicalUnit.SAC_OPERATOR_GE:
return new TokenValue(">=");
case LexicalUnit.SAC_OPERATOR_GT:
return new TokenValue(">");
case LexicalUnit.SAC_OPERATOR_LE:
return new TokenValue("<=");
case LexicalUnit.SAC_OPERATOR_LT:
return new TokenValue("<");
case LexicalUnit.SAC_OPERATOR_MINUS:
return new TokenValue("-");
case LexicalUnit.SAC_OPERATOR_MOD:
return new TokenValue("%");
case LexicalUnit.SAC_OPERATOR_MULTIPLY:
return new TokenValue("*");
case LexicalUnit.SAC_OPERATOR_PLUS:
return new TokenValue("+");
case LexicalUnit.SAC_OPERATOR_SLASH:
return new TokenValue("/");
case LexicalUnit.SAC_OPERATOR_TILDE:
return new IdentValue("~");
case LexicalUnit.SAC_RECT_FUNCTION: {
// Just return this as a String
List<Value> parameters = new ArrayList<Value>();
extractValueOf(parameters, value.getParameters());
return new IdentValue("rect(" + join(parameters, "") + ")");
}
case LexicalUnit.SAC_SUB_EXPRESSION:
// Should have been taken care of by our own traversal
case LexicalUnit.SAC_UNICODERANGE:
// Cannot be expressed in CSS2
}
throw new RuntimeException("Unhandled LexicalUnit type "
+ value.getLexicalUnitType());
}
private static String valueOf(Selector selector) {
if (selector instanceof CharacterDataSelector) {
// Unimplemented in CSS2?
} else if (selector instanceof ConditionalSelector) {
ConditionalSelector s = (ConditionalSelector) selector;
String simpleSelector = valueOf(s.getSimpleSelector());
if ("*".equals(simpleSelector)) {
// Don't need the extra * for compound selectors
return valueOf(s.getCondition());
} else {
return simpleSelector + valueOf(s.getCondition());
}
} else if (selector instanceof DescendantSelector) {
DescendantSelector s = (DescendantSelector) selector;
switch (s.getSelectorType()) {
case Selector.SAC_CHILD_SELECTOR:
if (s.getSimpleSelector().getSelectorType() == Selector.SAC_PSEUDO_ELEMENT_SELECTOR) {
return valueOf(s.getAncestorSelector()) + ":"
+ valueOf(s.getSimpleSelector());
} else {
return valueOf(s.getAncestorSelector()) + ">"
+ valueOf(s.getSimpleSelector());
}
case Selector.SAC_DESCENDANT_SELECTOR:
return valueOf(s.getAncestorSelector()) + " "
+ valueOf(s.getSimpleSelector());
}
} else if (selector instanceof ElementSelector) {
ElementSelector s = (ElementSelector) selector;
if (s.getLocalName() == null) {
return "*";
} else {
return escapeIdent(s.getLocalName());
}
} else if (selector instanceof NegativeSelector) {
// Unimplemented in CSS2?
} else if (selector instanceof ProcessingInstructionSelector) {
// Unimplemented in CSS2?
} else if (selector instanceof SiblingSelector) {
SiblingSelector s = (SiblingSelector) selector;
return valueOf(s.getSelector()) + "+" + valueOf(s.getSiblingSelector());
}
throw new RuntimeException("Unhandled selector of type "
+ selector.getClass().getName());
}
/**
* Utility class.
*/
private GenerateCssAst() {
}
}