Note: These are the exact methods exposed in the original C++ Parser. The * names are simply modified to conform to Java. */ public interface HtmlParser extends Parser { /** * The Parser Mode requested for parsing a given template. * Currently we support: *
class="someClass" target="_blank"
Which could be included from a parent template that contains * an anchor tag, say:
*<a href="/bla" ["INCLUDED_TEMPLATE"]>
All these states map exactly to those exposed in the C++ (original) * version of the HtmlParser. */ public final static ExternalState STATE_TEXT = new ExternalState("STATE_TEXT"); public final static ExternalState STATE_TAG = new ExternalState("STATE_TAG"); public final static ExternalState STATE_COMMENT = new ExternalState("STATE_COMMENT"); public final static ExternalState STATE_ATTR = new ExternalState("STATE_ATTR"); public final static ExternalState STATE_VALUE = new ExternalState("STATE_VALUE"); public final static ExternalState STATE_JS_FILE = new ExternalState("STATE_JS_FILE"); public final static ExternalState STATE_CSS_FILE = new ExternalState("STATE_CSS_FILE"); /** * Returns {@code true} if the parser is currently processing Javascript. * Such is the case if and only if, the parser is processing an attribute * that takes Javascript, a Javascript script block or the parser * is (re)set with {@link Mode#JS}. * * @return {@code true} if the parser is processing Javascript, * {@code false} otherwise */ public boolean inJavascript(); /** * Returns {@code true} if the parser is currently processing * a Javascript litteral that is quoted. The caller will typically * invoke this method after determining that the parser is processing * Javascript. Knowing whether the element is quoted or not helps * determine which escaping to apply to it when needed. * * @return {@code true} if and only if the parser is inside a quoted * Javascript literal */ public boolean isJavascriptQuoted(); /** * Returns {@code true} if and only if the parser is currently within * an attribute, be it within the attribute name or the attribute value. * * @return {@code true} if and only if inside an attribute */ public boolean inAttribute(); /** * Returns {@code true} if and only if the parser is currently within * a CSS context. A CSS context is one of the below: *
This is useful to determine which escaping to apply based * on the type of value this attribute expects. * * @return type of the attribute * @see HtmlParser.ATTR_TYPE */ public ATTR_TYPE getAttributeType(); /** * Returns {@code true} if and only if the parser is currently within * an attribute value and that attribute value is quoted. * * @return {@code true} if and only if the attribute value is quoted */ public boolean isAttributeQuoted(); /** * Returns the name of the HTML tag if the parser is currently within one. * Note that the name may be incomplete if the parser is currently still * parsing the name. Returns an empty {@code String} if the parser is not * in a tag as determined by {@code getCurrentExternalState}. * * @return the name of the HTML tag or an empty {@code String} if we are * not within an HTML tag */ public String getTag(); /** * Returns the name of the HTML attribute the parser is currently processing. * If the parser is still parsing the name, then the returned name * may be incomplete. Returns an empty {@code String} if the parser is not * in an attribute as determined by {@code getCurrentExternalState}. * * @return the name of the HTML attribute or an empty {@code String} * if we are not within an HTML attribute */ public String getAttribute(); /** * Returns the value of an HTML attribute if the parser is currently * within one. If the parser is currently parsing the value, the returned * value may be incomplete. The caller will typically first determine * that the parser is processing a value by calling * {@code getCurrentExternalState}. * * @return the value, could be an empty {@code String} if the parser is not * in an HTML attribute value */ public String getValue(); /** * Returns the current position of the parser within the HTML attribute * value, zero being the position of the first character in the value. * The caller will typically first determine that the parser is * processing a value by calling {@link #getState()}. * * @return the index or zero if the parser is not processing a value */ public int getValueIndex(); /** * Returns {@code true} if and only if the current position of the parser is * at the start of a URL HTML attribute value. This is the case when the * following three conditions are all met: *
*
This method may be used by an Html Sanitizer or an Auto-Escape system * to determine whether to validate the URL for well-formedness and validate * the scheme of the URL (e.g. {@code HTTP}, {@code HTTPS}) is safe. * In particular, it is recommended to use this method instead of * checking that {@link #getValueIndex()} is {@code 0} to support attribute * types where the URL does not start at index zero, such as the * {@code content} attribute of the {@code meta} HTML tag. * * @return {@code true} if and only if the parser is at the start of the URL */ public boolean isUrlStart(); /** * Resets the state of the parser, allowing for reuse of the * {@code HtmlParser} object. * *
See the {@link HtmlParser.Mode} enum for information on all * the valid modes. * * @param mode is an enum representing the high-level state of the parser */ public void resetMode(HtmlParser.Mode mode); /** * A specialized directive to tell the parser there is some content * that will be inserted here but that it will not get to parse. Used * by the template system that may not be able to give some content * to the parser but wants it to know there typically will be content * inserted at that point. This is a hint used in corner cases within * parsing of HTML attribute names and values where content we do not * get to see could affect our parsing and alter our current state. * *
Returns {@code false} if and only if the parser encountered * a fatal error which prevents it from continuing further parsing. * *
Note: The return value is different from the C++ Parser which * always returns {@code true} but in my opinion makes more sense. * * @throws ParseException if an unrecoverable error occurred during parsing */ public void insertText() throws ParseException; /** * Returns the state the Javascript parser is in. * *
See {@link JavascriptParser} for more information on the valid
* external states. The caller will typically first determine that the
* parser is processing Javascript and then invoke this method to
* obtain more fine-grained state information.
*
* @return external state of the javascript parser
*/
public ExternalState getJavascriptState();
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/ExternalState.java 0000644 0001750 0001750 00000005021 11427052602 025712 0 ustar chris chris /*
* 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.streamhtmlparser;
import com.google.common.base.Preconditions;
/**
* A representation of the parser state suitable for use by the caller
* of the Parser. The meaning of each state and therefore which action
* the caller should perform on that state is not self-evident. In particular,
* it depends on which parser is used (currently {@link HtmlParser} and
* {@link JavascriptParser}). For examples, you will have to look
* at the Google Template System and ClearSilver
* both of which support Auto-Escaping by interfacing with our parser
* (using the parser written in C++).
*
*
The caller of the Parser will query for the current parser state at * points of interest during parsing of templates. Based on the parser's * current state as represented by this class, the caller can determine * the appropriate escaping to apply. * *
Note: Given this class is external-facing, I considered creating * an interface but it is not likely we'll ever need to add more flexibility * and the class is so simple, I figured it was not warranted. * * * @see HtmlParser * @see JavascriptParser */ public class ExternalState { private final String name; /** * Creates an {@code ExternalState} object. * * @param name the name to assign to that state * @see HtmlParser * @see JavascriptParser */ public ExternalState(String name) { Preconditions.checkNotNull(name); // Developer error if it happens. this.name = name; } /** * Returns the name of the object. The name is only needed * to provide human-readable information when debugging. * * @return the name of that object */ public String getName() { return name; } /** * Returns the string representation of this external state. * The details of this representation are subject to change. */ @Override public String toString() { return String.format("ExternalState: %s", name); } } jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/JavascriptParser.java 0000644 0001750 0001750 00000002730 11427052602 026416 0 ustar chris chris /* * 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.streamhtmlparser; /** * Methods exposed for Javascript parsing of text to facilitate implementation * of Automatic context-aware escaping. This interface does not add * additional methods on top of {@code Parser} for the time being, * it simply exposes the states in which the Javascript parser may be in. * *
Note: These are the exact states exposed in the original C++ Parser. */ public interface JavascriptParser extends Parser { public static final ExternalState STATE_TEXT = new ExternalState("STATE_TEXT"); public static final ExternalState STATE_Q = new ExternalState("STATE_Q"); public static final ExternalState STATE_DQ = new ExternalState("STATE_DQ"); public static final ExternalState STATE_REGEXP = new ExternalState("STATE_REGEXP"); public static ExternalState STATE_COMMENT = new ExternalState("STATE_COMMENT"); } jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/impl/ 0000755 0001750 0001750 00000000000 11767454572 023252 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/impl/GenericParser.java 0000644 0001750 0001750 00000022232 11427052602 026624 0 ustar chris chris /* * 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.streamhtmlparser.impl; import com.google.common.base.Preconditions; import com.google.streamhtmlparser.ExternalState; import com.google.streamhtmlparser.Parser; import com.google.streamhtmlparser.ParseException; import com.google.streamhtmlparser.util.HtmlUtils; import java.util.Map; /** * An implementation of the {@code Parser} interface that is common to both * {@code HtmlParser} and {@code JavascriptParser}. * *
Provides methods for parsing input and ensuring that all in-state, * entering-a-state and exiting-a-state callbacks are invoked as appropriate. * *
This class started as abstract but it was found better for testing to
* make it instantiatable so that the parsing logic can be tested with dummy
* state transitions.
*/
public class GenericParser implements Parser {
protected final ParserStateTable parserStateTable;
protected final Map Absent any callbacks defined, this function simply determines the
* next state to switch to based on the However some states have specific callbacks defined which when
* receiving specific characters may decide to overwrite the next state to
* go to. Hence the next state is a function both of the main state table
* in {@code ParserStateTable} as well as specific run-time information
* from the callback functions.
*
* Also note that the callbacks are called in a proper sequence,
* first the exit-state one then the enter-state one and finally the
* in-state one. Changing the order may result in a functional change.
*
* @param input the input character to parse (process)
* @throws ParseException if an unrecoverable error occurred during parsing
*/
@Override
public void parse(char input) throws ParseException {
InternalState nextState =
parserStateTable.getNextState(currentState, input);
if (nextState == InternalState.INTERNAL_ERROR_STATE) {
String errorMsg =
String.format("Unexpected character '%s' in int_state '%s' " +
"(ext_state '%s')",
HtmlUtils.encodeCharForAscii(input),
currentState.getName(), getState().getName());
currentState = InternalState.INTERNAL_ERROR_STATE;
throw new ParseException(this, errorMsg);
}
if (currentState != nextState) {
nextState = handleExitState(currentState, nextState, input);
}
if (currentState != nextState) {
nextState = handleEnterState(nextState, nextState, input);
}
nextState = handleInState(nextState, input);
currentState = nextState;
record(input);
columnNumber++;
if (input == '\n') {
lineNumber++;
columnNumber = 1;
}
}
/**
* Return the current state of the parser.
*/
@Override
public ExternalState getState() {
if (!intToExtStateTable.containsKey(currentState)) {
throw new NullPointerException("Did not find external state mapping " +
"For internal state: " + currentState);
}
return intToExtStateTable.get(currentState);
}
/**
* Reset the parser back to its initial default state.
*/
@Override
public void reset() {
currentState = initialState;
lineNumber = 1;
columnNumber = 1;
}
/**
* Sets the current line number which is returned during error messages.
*/
@Override
public void setLineNumber(int lineNumber) {
this.lineNumber = lineNumber;
}
/**
* Returns the current line number.
*/
@Override
public int getLineNumber() {
return lineNumber;
}
/**
* Sets the current column number which is returned during error messages.
*/
@Override
public void setColumnNumber(int columnNumber) {
this.columnNumber = columnNumber;
}
/**
* Returns the current column number.
*/
@Override
public int getColumnNumber() {
return columnNumber;
}
InternalState getCurrentInternalState() {
return currentState;
}
protected void setNextState(InternalState nextState) throws ParseException {
Preconditions.checkNotNull(nextState); // Developer error if it triggers.
/* We are not actually parsing hence providing
* a null char to the event handlers.
*/
// TODO: Complicated logic to follow in C++ but clean it up.
final char nullChar = '\0';
if (currentState != nextState) {
nextState = handleExitState(currentState, nextState, nullChar);
}
if (currentState != nextState) {
handleEnterState(nextState, nextState, nullChar);
}
currentState = nextState;
}
/**
* Invoked when the parser enters a new state.
*
* @param currentState the current state of the parser
* @param expectedNextState the next state according to the
* state table definition
* @param input the last character parsed
* @return the state to change to, could be the same as the
* {@code expectedNextState} provided
* @throws ParseException if an unrecoverable error occurred during parsing
*/
protected InternalState handleEnterState(InternalState currentState,
InternalState expectedNextState,
char input) throws ParseException {
return expectedNextState;
}
/**
* Invoked when the parser exits a state.
*
* @param currentState the current state of the parser
* @param expectedNextState the next state according to the
* state table definition
* @param input the last character parsed
* @return the state to change to, could be the same as the
* {@code expectedNextState} provided
* @throws ParseException if an unrecoverable error occurred during parsing
*/
protected InternalState handleExitState(InternalState currentState,
InternalState expectedNextState,
char input) throws ParseException {
return expectedNextState;
}
/**
* Invoked for each character read when no state change occured.
*
* @param currentState the current state of the parser
* @param input the last character parsed
* @return the state to change to, could be the same as the
* {@code expectedNextState} provided
* @throws ParseException if an unrecoverable error occurred during parsing
*/
protected InternalState handleInState(InternalState currentState,
char input) throws ParseException {
return currentState;
}
/**
* Perform some processing on the given character. Derived classes
* may override this method in order to perform additional logic
* on every processed character beyond the logic defined in
* state transitions.
*
* @param input the input character to operate on
*/
protected void record(char input) { }
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/impl/InternalState.java 0000644 0001750 0001750 00000007303 11427052602 026652 0 ustar chris chris /*
* 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.streamhtmlparser.impl;
import com.google.common.base.Preconditions;
import java.util.concurrent.atomic.AtomicInteger;
/**
* A very simple representation of the parser internal state. The state
* contains a small integer identifier (from 1 to 255) to allow for
* the implementation of a simple finite state machine. The name is
* purely informational.
*
* In order to eliminate the possibility that different states have
* the same identifier, this class manages the idenitifiers themselves.
* The HTML and Javascript parser states are managed elsewhere in different
* "namespaces" hence will not clash and there is no current need for this
* class to disambiguate them further.
*
* The methods to create new This is the main class in the package. It implements the
* {@code HtmlParser} interface.
*
* This class is not thread-safe, in particular you cannot invoke any
* state changing operations (such as {@code parse} from multiple threads
* on the same object.
*
* If you are looking at this class, chances are very high you are
* implementing Auto-Escaping for a new template system. Please see the
* landing page including a design document at
* Auto-Escape Landing Page.
*/
public class HtmlParserImpl extends GenericParser implements HtmlParser {
/*
* Internal representation of the parser state, which is at a
* finer-granularity than the external state as given to callers.
* The relationship between Both for performance reasons and to leverage code a state-flow machine
* that is automatically generated from Python for multiple target
* languages, this object uses a static {@code ParserStateTable} that
* is read-only and obtained from the generated code in {@code HtmlParserFsm}.
* That code also maintains the mapping from internal states
* ({@code InternalState}) to external states ({@code ExternalState}).
*/
public HtmlParserImpl() {
super(STATE_TABLE, STATE_MAPPING, TEXT);
tag = new CharacterRecorder();
attr = new CharacterRecorder();
value = new CharacterRecorder();
cdataCloseTag = new CharacterRecorder();
entityResolver = new EntityResolver();
jsParser = new JavascriptParserImpl();
insideJavascript = false;
valueIndex = 0;
textInsideUrlValue = false;
}
/**
* Creates an {@code HtmlParserImpl} that is a copy of the one provided.
*
* @param aHtmlParserImpl the {@code HtmlParserImpl} object to copy
*/
public HtmlParserImpl(HtmlParserImpl aHtmlParserImpl) {
super(aHtmlParserImpl);
tag = new CharacterRecorder(aHtmlParserImpl.tag);
attr = new CharacterRecorder(aHtmlParserImpl.attr);
value = new CharacterRecorder(aHtmlParserImpl.value);
cdataCloseTag = new CharacterRecorder(aHtmlParserImpl.cdataCloseTag);
entityResolver = new EntityResolver(aHtmlParserImpl.entityResolver);
jsParser = new JavascriptParserImpl(aHtmlParserImpl.jsParser);
insideJavascript = aHtmlParserImpl.insideJavascript;
valueIndex = aHtmlParserImpl.valueIndex;
textInsideUrlValue = aHtmlParserImpl.textInsideUrlValue;
}
@Override
public boolean inJavascript() {
return (insideJavascript
&& ( (getState() == STATE_VALUE)
|| (currentState == CDATA_TEXT)
|| (currentState == CDATA_COM_START)
|| (currentState == CDATA_COM_START_DASH)
|| (currentState == CDATA_COM_BODY)
|| (currentState == CDATA_COM_DASH)
|| (currentState == CDATA_COM_DASH_DASH)
|| (currentState == CDATA_LT)
|| (currentState == CDATA_MAY_CLOSE)
|| (currentState == JS_FILE) ));
}
@Override
public boolean isJavascriptQuoted() {
if (inJavascript()) {
ExternalState jsParserState = jsParser.getState();
return (jsParserState == JavascriptParserImpl.STATE_Q
|| jsParserState == JavascriptParserImpl.STATE_DQ);
}
return false;
}
@Override
public boolean inAttribute() {
ExternalState extState = getState();
return (extState != null && (extState == STATE_ATTR
|| extState == STATE_VALUE));
}
/**
* Returns {@code true} if and only if the parser is currently within
* a CSS context. A CSS context is one of the below:
* See the {@link HtmlParser.Mode} enum for information on all
* the valid modes.
*
* @param mode is an enum representing the high-level state of the parser
*/
@Override
public void resetMode(Mode mode) {
insideJavascript = false;
tag.reset();
attr.reset();
value.reset();
cdataCloseTag.reset();
valueIndex = 0;
textInsideUrlValue = false;
jsParser.reset();
switch (mode) {
case HTML:
currentState = TEXT;
break;
case JS:
currentState = JS_FILE;
insideJavascript = true;
break;
case CSS:
currentState = CSS_FILE;
break;
case HTML_IN_TAG:
currentState = TAG_SPACE;
break;
default:
throw new IllegalArgumentException("Did not recognize Mode: " +
mode.toString());
}
}
/**
* Resets the state of the parser to the initial state of parsing HTML.
*/
public void reset() {
super.reset();
resetMode(Mode.HTML);
}
/**
* A specialized directive to tell the parser there is some content
* that will be inserted here but that it will not get to parse. Used
* by the template system that may not be able to give some content
* to the parser but wants it to know there typically will be content
* inserted at that point. This is a hint used in corner cases within
* parsing of HTML attribute names and values where content we do not
* get to see could affect our parsing and alter our current state.
*
* The two cases where {@code #insertText()} affects our parsing are:
* Called for every character inside an attribute value.
*
* @param input character read
* @throws ParseException if an unrecoverable error occurred during parsing
*/
private void inStateValue(char input) throws ParseException {
valueIndex++;
if (insideJavascript) {
EntityResolver.Status status = entityResolver.processChar(input);
if (status == EntityResolver.Status.COMPLETED) {
jsParser.parse(entityResolver.getEntity());
entityResolver.reset();
} else if (status == EntityResolver.Status.NOT_STARTED) {
jsParser.parse(input);
}
}
}
/**
* Handles the tag it finished reading.
*
* For a script tag, it initializes the javascript parser. For all
* tags that are recognized to have CDATA values
* (including the script tag), it switches the CDATA state to handle them
* properly. For code simplification, CDATA and RCDATA sections are
* treated the same.
*
* Called when the parser leaves a tag definition.
*
* @param state current state
* @return state next state, could be the same as current state
*/
private InternalState tagClose(InternalState state) {
InternalState nextState = state;
String tagName = getTag();
if ("script".equals(tagName)) {
nextState = CDATA_TEXT;
jsParser.reset();
insideJavascript = true;
} else if ("style".equals(tagName)
|| "title".equals(tagName)
|| "textarea".equals(tagName)) {
nextState = CDATA_TEXT;
insideJavascript = false;
}
return nextState;
}
/**
* Feeds the character to the javascript parser for processing.
*
* Called inside CDATA blocks to parse javascript.
*
* @param input character read
* @throws ParseException if an unrecoverable error occurred during parsing
*/
private void inStateCdata(char input) throws ParseException {
if (insideJavascript) {
jsParser.parse(input);
}
}
/**
* Starts recording. This is so we find the closing tag name in order to
* know if the tag is going to be closed or not.
*
* Called when encountering a '<' character in a CDATA section.
*/
private void enterStateCdataMayClose() {
cdataCloseTag.startRecording();
}
/**
* Determines whether to close the tag element, It closes it if it finds
* the corresponding end tag. Called when reading what could be a
* closing CDATA tag.
*
* @param input the character read
* @param expectedNextState the expected state to go to next
* unless we want to change it here
* @return the next state to go to
*/
private InternalState exitStateCdataMayClose(
InternalState expectedNextState,
char input) {
InternalState nextState = expectedNextState;
cdataCloseTag.stopRecording();
String cdataCloseTagString = cdataCloseTag.getContent();
Preconditions.checkState(!cdataCloseTagString.isEmpty()
&& cdataCloseTagString.charAt(0) == '/'); // Developer error.
if (cdataCloseTagString.substring(1).equalsIgnoreCase(getTag())
&& (input == '>' || HtmlUtils.isHtmlSpace(input))) {
tag.clear();
insideJavascript = false;
} else {
nextState = CDATA_TEXT;
}
return nextState;
}
// ======================================================= //
// SECTION BELOW WILL ALL BE AUTO-GENERATED IN FUTURE. //
// ======================================================= //
private static void registerMapping(InternalState internalState,
ExternalState externalState) {
STATE_MAPPING.put(internalState, externalState);
}
private static void initializeStateMapping() {
// Each parser implementation must map the error state appropriately.
registerMapping(InternalState.INTERNAL_ERROR_STATE, HtmlParser.STATE_ERROR);
registerMapping(TEXT, HtmlParser.STATE_TEXT);
registerMapping(TAG_START, HtmlParser.STATE_TAG);
registerMapping(TAG_NAME, HtmlParser.STATE_TAG);
registerMapping(DECL_START, HtmlParser.STATE_TEXT);
registerMapping(DECL_BODY, HtmlParser.STATE_TEXT);
registerMapping(COM_OPEN, HtmlParser.STATE_TEXT);
registerMapping(COM_BODY, HtmlParser.STATE_COMMENT);
registerMapping(COM_DASH, HtmlParser.STATE_COMMENT);
registerMapping(COM_DASH_DASH, HtmlParser.STATE_COMMENT);
registerMapping(PI, HtmlParser.STATE_TEXT);
registerMapping(PI_MAY_END, HtmlParser.STATE_TEXT);
registerMapping(TAG_SPACE, HtmlParser.STATE_TAG);
registerMapping(TAG_CLOSE, HtmlParser.STATE_TEXT);
registerMapping(ATTR, HtmlParser.STATE_ATTR);
registerMapping(ATTR_SPACE, HtmlParser.STATE_ATTR);
registerMapping(VALUE, HtmlParser.STATE_VALUE);
registerMapping(VALUE_TEXT, HtmlParser.STATE_VALUE);
registerMapping(VALUE_Q_START, HtmlParser.STATE_VALUE);
registerMapping(VALUE_Q, HtmlParser.STATE_VALUE);
registerMapping(VALUE_DQ_START, HtmlParser.STATE_VALUE);
registerMapping(VALUE_DQ, HtmlParser.STATE_VALUE);
registerMapping(CDATA_COM_START, HtmlParser.STATE_TEXT);
registerMapping(CDATA_COM_START_DASH, HtmlParser.STATE_TEXT);
registerMapping(CDATA_COM_BODY, HtmlParser.STATE_TEXT);
registerMapping(CDATA_COM_DASH, HtmlParser.STATE_TEXT);
registerMapping(CDATA_COM_DASH_DASH, HtmlParser.STATE_TEXT);
registerMapping(CDATA_TEXT, HtmlParser.STATE_TEXT);
registerMapping(CDATA_LT, HtmlParser.STATE_TEXT);
registerMapping(CDATA_MAY_CLOSE, HtmlParser.STATE_TEXT);
registerMapping(JS_FILE, HtmlParser.STATE_JS_FILE);
registerMapping(CSS_FILE, HtmlParser.STATE_CSS_FILE);
}
private static void registerTransition(String expression,
InternalState source,
InternalState to) {
// It seems to silly to go through a StateTableTransition here
// but it adds extra data checking.
StateTableTransition stt = new StateTableTransition(expression,
source, to);
STATE_TABLE.setExpression(stt.getExpression(), stt.getFrom(),
stt.getTo());
}
// NOTE: The "[:default:]" transition should be registered before any
// other transitions for a given state or it will over-write them.
private static void initializeParserStateTable() {
registerTransition("[:default:]", CSS_FILE, CSS_FILE);
registerTransition("[:default:]", JS_FILE, JS_FILE);
registerTransition("[:default:]", CDATA_MAY_CLOSE, CDATA_TEXT);
registerTransition(" \t\n\r", CDATA_MAY_CLOSE, TAG_SPACE);
registerTransition(">", CDATA_MAY_CLOSE, TEXT);
registerTransition("A-Za-z0-9/_:-", CDATA_MAY_CLOSE, CDATA_MAY_CLOSE);
registerTransition("[:default:]", CDATA_LT, CDATA_TEXT);
registerTransition("!", CDATA_LT, CDATA_COM_START);
registerTransition("/", CDATA_LT, CDATA_MAY_CLOSE);
registerTransition("[:default:]", CDATA_TEXT, CDATA_TEXT);
registerTransition("<", CDATA_TEXT, CDATA_LT);
registerTransition("[:default:]", CDATA_COM_DASH_DASH, CDATA_COM_BODY);
registerTransition(">", CDATA_COM_DASH_DASH, CDATA_TEXT);
registerTransition("-", CDATA_COM_DASH_DASH, CDATA_COM_DASH_DASH);
registerTransition("[:default:]", CDATA_COM_DASH, CDATA_COM_BODY);
registerTransition("-", CDATA_COM_DASH, CDATA_COM_DASH_DASH);
registerTransition("[:default:]", CDATA_COM_BODY, CDATA_COM_BODY);
registerTransition("-", CDATA_COM_BODY, CDATA_COM_DASH);
registerTransition("[:default:]", CDATA_COM_START_DASH, CDATA_TEXT);
registerTransition("-", CDATA_COM_START_DASH, CDATA_COM_BODY);
registerTransition("[:default:]", CDATA_COM_START, CDATA_TEXT);
registerTransition("-", CDATA_COM_START, CDATA_COM_START_DASH);
registerTransition("[:default:]", VALUE_DQ, VALUE_DQ);
registerTransition("\"", VALUE_DQ, TAG_SPACE);
registerTransition("[:default:]", VALUE_DQ_START, VALUE_DQ);
registerTransition("\"", VALUE_DQ_START, TAG_SPACE);
registerTransition("[:default:]", VALUE_Q, VALUE_Q);
registerTransition("\'", VALUE_Q, TAG_SPACE);
registerTransition("[:default:]", VALUE_Q_START, VALUE_Q);
registerTransition("\'", VALUE_Q_START, TAG_SPACE);
registerTransition("[:default:]", VALUE_TEXT, VALUE_TEXT);
registerTransition(" \t\n\r", VALUE_TEXT, TAG_SPACE);
registerTransition(">", VALUE_TEXT, TAG_CLOSE);
registerTransition("[:default:]", VALUE, VALUE_TEXT);
registerTransition(">", VALUE, TAG_CLOSE);
registerTransition(" \t\n\r", VALUE, VALUE);
registerTransition("\"", VALUE, VALUE_DQ_START);
registerTransition("\'", VALUE, VALUE_Q_START);
registerTransition("=", ATTR_SPACE, VALUE);
registerTransition("/", ATTR_SPACE, TAG_SPACE);
registerTransition("A-Za-z0-9_:-", ATTR_SPACE, ATTR);
registerTransition(" \t\n\r", ATTR_SPACE, ATTR_SPACE);
registerTransition(">", ATTR_SPACE, TAG_CLOSE);
registerTransition(" \t\n\r", ATTR, ATTR_SPACE);
registerTransition("=", ATTR, VALUE);
registerTransition("/", ATTR, TAG_SPACE);
registerTransition(">", ATTR, TAG_CLOSE);
registerTransition("A-Za-z0-9_:.-", ATTR, ATTR);
registerTransition("[:default:]", TAG_CLOSE, TEXT);
registerTransition("<", TAG_CLOSE, TAG_START);
registerTransition("/", TAG_SPACE, TAG_SPACE);
registerTransition("A-Za-z0-9_:-", TAG_SPACE, ATTR);
registerTransition(" \t\n\r", TAG_SPACE, TAG_SPACE);
registerTransition(">", TAG_SPACE, TAG_CLOSE);
registerTransition("[:default:]", PI_MAY_END, PI);
registerTransition(">", PI_MAY_END, TEXT);
registerTransition("[:default:]", PI, PI);
registerTransition("?", PI, PI_MAY_END);
registerTransition("[:default:]", COM_DASH_DASH, COM_BODY);
registerTransition(">", COM_DASH_DASH, TEXT);
registerTransition("-", COM_DASH_DASH, COM_DASH_DASH);
registerTransition("[:default:]", COM_DASH, COM_BODY);
registerTransition("-", COM_DASH, COM_DASH_DASH);
registerTransition("[:default:]", COM_BODY, COM_BODY);
registerTransition("-", COM_BODY, COM_DASH);
registerTransition("[:default:]", COM_OPEN, TEXT);
registerTransition("-", COM_OPEN, COM_BODY);
registerTransition("[:default:]", DECL_BODY, DECL_BODY);
registerTransition(">", DECL_BODY, TEXT);
registerTransition("[:default:]", DECL_START, DECL_BODY);
registerTransition(">", DECL_START, TEXT);
registerTransition("-", DECL_START, COM_OPEN);
registerTransition(">", TAG_NAME, TAG_CLOSE);
registerTransition(" \t\n\r", TAG_NAME, TAG_SPACE);
registerTransition("A-Za-z0-9/_:-", TAG_NAME, TAG_NAME);
// Manual change to remain in-sync with CL 10597850 in C HtmlParser.
registerTransition("[:default:]", TAG_START, TEXT);
registerTransition("<", TAG_START, TAG_START);
// End of manual change.
registerTransition("!", TAG_START, DECL_START);
registerTransition("?", TAG_START, PI);
registerTransition("A-Za-z0-9/_:-", TAG_START, TAG_NAME);
registerTransition("[:default:]", TEXT, TEXT);
registerTransition("<", TEXT, TAG_START);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/impl/ParserStateTable.java 0000644 0001750 0001750 00000015456 11427052602 027312 0 ustar chris chris /*
* 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.streamhtmlparser.impl;
import com.google.common.base.Preconditions;
/**
* Holds a state table which is defined as the set of all
* recognized state transitions and the set of characters that
* trigger them.
*
* The logic of what character causes what state transition is derived from
* a base definition written as a Python configuration file in the original
* C++ parser.
*
* This class provides methods to initially build the state table and then
* methods at parsing time to determine the transitions to subsequent states.
*
* Note on characters outside the extended ASCII range: Currently, all state
* transitions in the Python configuration file trigger only on extended
* ASCII characters, that is characters in the Unicode space of [U+0000 to
* U+00FF]. We use that property to design a more efficient state transition
* representation. When receiving characters outside that ASCII range, we
* simply apply the DEFAULT transition for the given state - as we do for any
* character that is not a hot character for that state. If no default
* transition exists, we switch to the Internal Error state.
*
* Technical note: In Java, a {@code char} is a code unit and in some cases
* may not represent a complete Unicode code point. However, when that happens,
* the code units that follow for that code point are all in the surrogate area
* [U+D800 - U+DFFF] and hence outside of the ASCII range and will not trigger
* any incorrect state transitions.
*
* This class is storage-inefficient but it is static at least
* and not generated for each Parser instance.
*/
class ParserStateTable {
/**
* A limit on how many different states we can have in one state table.
* Can be increased should it no longer be sufficient.
*/
private static final int MAX_STATES = 256;
/**
* We only check transitions for (extended) ASCII characters, hence
* characters in the range 0 to MAX_CHARS -1.
*/
private static final int MAX_CHARS = 256;
/**
* Records all state transitions except those identified as DEFAULT
* transitions. It is two dimensional: Stores a target {@code InternalState}
* given a source state (referenced by its numeric ID) and the current
* character.
*/
private final InternalState[][] stateTable;
/**
* Records all DEFAULT state transitions. These are transitions provided
* using the {@code "[:default:]"} syntax in the Python configuration file.
* There can be only one such transition for any given source state, hence
* the array is one dimensional.
*/
private final InternalState[] defaultStateTable;
public ParserStateTable() {
stateTable = new InternalState[MAX_STATES][MAX_CHARS];
defaultStateTable = new InternalState[MAX_STATES];
}
/**
* Returns the state to go to when receiving the current {@code char}
* in the {@code from} state.
* Returns {@code InternalState.INTERNAL_ERROR_STATE} if there is no
* state transition for that character and no default state transition
* for that state.
*
* For ASCII characters, first look-up an explicit state transition for
* the current character. If none is found, look-up a default transition. For
* non-ASCII characters, look-up a default transition only.
*
* @param from the source state
* @param currentChar the character received
* @return the state to move to or {@code InternalState.INTERNAL_ERROR_STATE}
*/
InternalState getNextState(InternalState from, int currentChar) {
// TODO: Consider throwing run-time error here.
if (from == null || currentChar < 0)
return InternalState.INTERNAL_ERROR_STATE;
int id = from.getId();
if (id < 0 || id >= MAX_STATES) {
return InternalState.INTERNAL_ERROR_STATE;
}
InternalState result = null;
if (currentChar < MAX_CHARS) {
result = stateTable[id][currentChar];
}
if (result == null) {
result = defaultStateTable[from.getId()];
}
return result != null ? result : InternalState.INTERNAL_ERROR_STATE;
}
void setExpression(String expr, InternalState from, InternalState to) {
if ((expr == null) || (from == null) || (to == null)) {
return;
}
// This special string indicates a default state transition.
if ("[:default:]".equals(expr)) {
setDefaultDestination(from, to);
return;
}
int i = 0;
while (i < expr.length()) {
// If next char is a '-' which is not the last character of the expr
if (i < (expr.length() - 2) && expr.charAt(i + 1) == '-') {
setRange(from, expr.charAt(i), expr.charAt(i + 2), to);
i += 2;
} else {
setDestination(from, expr.charAt(i), to);
i++;
}
}
}
private void fill(InternalState from, InternalState to) {
char c;
for (c = 0; c < MAX_CHARS; c++) {
setDestination(from, c, to);
}
}
private void setDefaultDestination(InternalState from, InternalState to) {
Preconditions.checkNotNull(from); // Developer error if it triggers
Preconditions.checkNotNull(to); // Developer error if it triggers
int id = from.getId();
if ((id < 0) || (id >= MAX_STATES)) {
return;
}
// TODO: Consider asserting if there was a state transition defined.
defaultStateTable[from.getId()] = to;
}
private void setDestination(InternalState from, char chr, InternalState to) {
Preconditions.checkNotNull(from); // Developer error if it triggers
Preconditions.checkNotNull(to); // Developer error if it triggers
Preconditions.checkArgument(chr >= 0 && chr < MAX_CHARS,
"char must be in ASCII set: %c", chr);
int id = from.getId();
if ((id < 0) || (id >= MAX_STATES)) {
return;
}
stateTable[from.getId()][chr] = to;
}
private void setRange(InternalState from, char start, char end,
InternalState to) {
// Developer error if either trigger.
Preconditions.checkArgument(start >= 0 && start < MAX_CHARS,
"char must be in ASCII set: %c", start);
Preconditions.checkArgument(end >= 0 && end < MAX_CHARS,
"char must be in ASCII set: %c", end);
char c;
for (c = start; c <= end; c++) {
setDestination(from, c, to);
}
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/impl/StateTableTransition.java 0000644 0001750 0001750 00000004251 11427052602 030177 0 ustar chris chris /*
* 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.streamhtmlparser.impl;
import com.google.common.base.Preconditions;
/**
* Holds one state transition as derived from a Python configuration
* file. A state transition is a triplet as follows:
* For example, the triplet ("a-z123", A, B) will cause the
* state to go from A to B for any character that is either 1,2,3 or in
* the range a-z inclusive.
*/
class StateTableTransition {
private final String expression;
private final InternalState from;
private final InternalState to;
/**
* Returns the full state of the {@code StateTableTransition} in a
* human readable form. The format of the returned {@code String} is not
* specified and is subject to change.
*
* @return full state of the {@code StateTableTransition}
*/
@Override
public String toString() {
return String.format("Expression: %s; From: %s; To: %s",
expression, from, to);
}
StateTableTransition(String expression, InternalState from,
InternalState to) {
// Developer error if any triggers.
Preconditions.checkNotNull(expression);
Preconditions.checkNotNull(from);
Preconditions.checkNotNull(to);
this.expression = expression;
this.from = from;
this.to = to;
}
String getExpression() {
return expression;
}
InternalState getFrom() {
return from;
}
InternalState getTo() {
return to;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/impl/JavascriptParserImpl.java 0000644 0001750 0001750 00000032334 11427052602 030204 0 ustar chris chris /*
* 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.streamhtmlparser.impl;
import com.google.common.collect.Maps;
import com.google.streamhtmlparser.ExternalState;
import com.google.streamhtmlparser.JavascriptParser;
import com.google.streamhtmlparser.util.HtmlUtils;
import com.google.streamhtmlparser.util.JavascriptTokenBuffer;
import java.util.Map;
/**
* Many comments copied almost verbatim from the original C version.
*/
public class JavascriptParserImpl extends GenericParser
implements JavascriptParser {
final static InternalState JS_TEXT;
final static InternalState JS_Q;
final static InternalState JS_Q_E;
final static InternalState JS_DQ;
final static InternalState JS_DQ_E;
final static InternalState JS_SLASH;
final static InternalState JS_REGEXP_SLASH;
final static InternalState JS_REGEXP;
final static InternalState JS_REGEXP_BRK;
final static InternalState JS_REGEXP_BRK_E;
final static InternalState JS_REGEXP_E;
final static InternalState JS_COM_LN;
final static InternalState JS_COM_ML;
final static InternalState JS_COM_ML_CLOSE;
final static InternalState JS_COM_AFTER;
static {
JS_TEXT = InternalState.getInstanceJavascript("JS_TEXT");
JS_Q = InternalState.getInstanceJavascript("JS_Q");
JS_Q_E = InternalState.getInstanceJavascript("JS_Q_E");
JS_DQ = InternalState.getInstanceJavascript("JS_DQ");
JS_DQ_E = InternalState.getInstanceJavascript("JS_DQ_E");
JS_SLASH = InternalState.getInstanceJavascript("JS_SLASH");
JS_REGEXP = InternalState.getInstanceJavascript("JS_REGEXP");
JS_REGEXP_SLASH = InternalState.getInstanceJavascript("JS_REGEXP_SLASH");
JS_REGEXP_E = InternalState.getInstanceJavascript("JS_REGEXP_E");
JS_REGEXP_BRK = InternalState.getInstanceJavascript("JS_REGEXP_BRK");
JS_REGEXP_BRK_E = InternalState.getInstanceJavascript("JS_REGEXP_BRK_E");
JS_COM_LN = InternalState.getInstanceJavascript("COMMENT_LN");
JS_COM_ML = InternalState.getInstanceJavascript("COMMENT_ML");
JS_COM_ML_CLOSE = InternalState.getInstanceJavascript("COMMENT_ML_CLOSE");
JS_COM_AFTER = InternalState.getInstanceJavascript("COMMENT_AFTER");
}
private static final Map Comment copied verbatim from the corresponding C-version.
*
* Implements the logic to figure out if this slash character is a
* division operator or if it opens a regular expression literal.
* This is heavily inspired by the syntactic resynchronization
* for javascript 2.0:
*
* When we receive a '/', we look at the previous non space character
* to figure out if it's the ending of a punctuator that can precede a
* regexp literal, in which case we assume the current '/' is part of a
* regular expression literal (or the opening of a javascript comment,
* but that part is dealt with in the state machine). The exceptions to
* this are unary operators, so we look back a second character to rule
* out '++' and '--'.
*
* Although it is not straightforward to figure out if the binary
* operator is a postfix of the previous expression or a prefix of the
* regular expression, we rule out the later as it is an uncommon practice.
*
* If we ruled out the previous token to be a valid regexp preceding
* punctuator, we extract the last identifier in the buffer and match
* against a list of keywords that are known to precede expressions in
* the grammar. If we get a match on any of these keywords, then we are
* opening a regular expression, if not, then we have a division operator.
*
* Known cases that are accepted by the grammar but we handle
* differently, although I (falmeida) don't believe there is a
* legitimate usage for those:
* Division of a regular expression: var result = /test/ / 5;
* Prefix unary increment of a regular expression: var result = ++/test/;
* Division of an object literal: { a: 1 } /x/.exec('x');
*
* @param state being entered to
* @param input character being processed
* @return state next state to go to, may be the same as the one we
* were called with
*
* http://www.mozilla.org/js/language/js20-2000-07/rationale/syntax.html>
* Syntactic Resynchronization
*/
private InternalState enterStateJsSlash(InternalState state, char input) {
InternalState nextState = state;
int position = -1;
// Consume the last whitespace
if (HtmlUtils.isJavascriptWhitespace(ccBuffer.getChar(position))) {
--position;
}
switch (ccBuffer.getChar(position)) {
// Ignore unary increment
case '+':
if (ccBuffer.getChar(position - 1) != '+') {
nextState = JS_REGEXP_SLASH;
}
break;
case '-':
// Ignore unary decrement
if (ccBuffer.getChar(position - 1) != '-') {
nextState = JS_REGEXP_SLASH;
}
break;
// List of punctuator endings except ), ], }, + and - *
case '=':
case '<':
case '>':
case '&':
case '|':
case '!':
case '%':
case '*':
case '/':
case ',':
case ';':
case '?':
case ':':
case '^':
case '~':
case '{':
case '(':
case '[':
case '}':
case '\0':
nextState = JS_REGEXP_SLASH;
break;
default:
String lastIdentifier = ccBuffer.getLastIdentifier();
if (lastIdentifier != null && HtmlUtils
.isJavascriptRegexpPrefix(lastIdentifier)) {
nextState = JS_REGEXP_SLASH;
}
}
ccBuffer.appendChar(input);
return nextState;
}
/**
* Called at the end of a javascript comment.
*
* When we open a comment, the initial '/' was inserted into the ring
* buffer, but it is not a token and should be considered whitespace
* for parsing purposes.
*
* When we first saw the '/' character, we didn't yet know if it was
* the beginning of a comment, a division operator, or a regexp.
*
* In this function we just replace the inital '/' with a whitespace
* character, unless we had a preceding whitespace character, in which
* case we just remove the '/'. This is needed to ensure all spaces in
* the buffer are correctly folded.
*/
private void enterStateJsCommentAfter() {
if (HtmlUtils.isJavascriptWhitespace(ccBuffer.getChar(-2))) {
ccBuffer.popChar();
} else {
ccBuffer.setChar(-1, ' ');
}
}
private void inStateJsText(char input) {
ccBuffer.appendChar(input);
}
// ======================================================= //
// SECTION BELOW WILL ALL BE AUTO-GENERATED IN FUTURE. //
// ======================================================= //
private static void registerMapping(InternalState internalState,
ExternalState externalState) {
STATE_MAPPING.put(internalState, externalState);
}
private static void initializeStateMapping() {
// Each parser implementation must map the error state appropriately.
registerMapping(InternalState.INTERNAL_ERROR_STATE,
JavascriptParser.STATE_ERROR);
registerMapping(JS_TEXT, JavascriptParser.STATE_TEXT);
registerMapping(JS_Q, JavascriptParser.STATE_Q);
registerMapping(JS_Q_E, JavascriptParser.STATE_Q);
registerMapping(JS_DQ, JavascriptParser.STATE_DQ);
registerMapping(JS_DQ_E, JavascriptParser.STATE_DQ);
registerMapping(JS_SLASH, JavascriptParser.STATE_TEXT);
registerMapping(JS_REGEXP_SLASH, JavascriptParser.STATE_TEXT);
registerMapping(JS_REGEXP, JavascriptParser.STATE_REGEXP);
registerMapping(JS_REGEXP_BRK,JavascriptParser.STATE_REGEXP);
registerMapping(JS_REGEXP_BRK_E, JavascriptParser.STATE_REGEXP);
registerMapping(JS_REGEXP_E,JavascriptParser.STATE_REGEXP);
registerMapping(JS_COM_LN, JavascriptParser.STATE_COMMENT);
registerMapping(JS_COM_ML, JavascriptParser.STATE_COMMENT);
registerMapping(JS_COM_ML_CLOSE, JavascriptParser.STATE_COMMENT);
registerMapping(JS_COM_AFTER, JavascriptParser.STATE_TEXT);
}
private static void registerTransition(String expression,
InternalState source,
InternalState to) {
// It seems to silly to go through a StateTableTransition here
// but it adds extra data checking.
StateTableTransition stt = new StateTableTransition(expression,
source, to);
STATE_TABLE.setExpression(stt.getExpression(), stt.getFrom(),
stt.getTo());
}
private static void initializeParserStateTable() {
registerTransition("[:default:]", JS_COM_AFTER, JS_TEXT);
registerTransition("/", JS_COM_AFTER, JS_SLASH);
registerTransition("\"", JS_COM_AFTER, JS_DQ);
registerTransition("\'", JS_COM_AFTER, JS_Q);
registerTransition("[:default:]", JS_COM_ML_CLOSE, JS_COM_ML);
registerTransition("/", JS_COM_ML_CLOSE,JS_COM_AFTER);
registerTransition("[:default:]", JS_COM_ML, JS_COM_ML);
registerTransition("*", JS_COM_ML, JS_COM_ML_CLOSE);
registerTransition("[:default:]", JS_COM_LN,JS_COM_LN);
registerTransition("\n", JS_COM_LN,JS_COM_AFTER);
registerTransition("[:default:]", JS_REGEXP_E, JS_REGEXP);
registerTransition("[:default:]", JS_REGEXP_BRK_E, JS_REGEXP_BRK);
registerTransition("[:default:]", JS_REGEXP_BRK, JS_REGEXP_BRK);
registerTransition("]", JS_REGEXP_BRK, JS_REGEXP);
registerTransition("\\", JS_REGEXP_BRK, JS_REGEXP_BRK_E);
registerTransition("[:default:]", JS_REGEXP, JS_REGEXP);
registerTransition("/", JS_REGEXP, JS_TEXT);
registerTransition("[", JS_REGEXP, JS_REGEXP_BRK);
registerTransition("\\", JS_REGEXP, JS_REGEXP_E);
registerTransition("[:default:]", JS_REGEXP_SLASH, JS_REGEXP);
registerTransition("[", JS_REGEXP_SLASH, JS_REGEXP_BRK);
registerTransition("\\", JS_REGEXP_SLASH, JS_REGEXP_E);
registerTransition("*", JS_REGEXP_SLASH, JS_COM_ML);
registerTransition("/", JS_REGEXP_SLASH, JS_COM_LN);
registerTransition("[:default:]", JS_SLASH, JS_TEXT);
registerTransition("*", JS_SLASH, JS_COM_ML);
registerTransition("/", JS_SLASH, JS_COM_LN);
registerTransition("[:default:]", JS_DQ_E,JS_DQ);
registerTransition("[:default:]", JS_DQ,JS_DQ);
registerTransition("\"", JS_DQ, JS_TEXT);
registerTransition("\\", JS_DQ, JS_DQ_E);
registerTransition("[:default:]", JS_Q_E,JS_Q);
registerTransition("[:default:]", JS_Q,JS_Q);
registerTransition("\'", JS_Q, JS_TEXT);
registerTransition("\\", JS_Q, JS_Q_E);
registerTransition("[:default:]", JS_TEXT, JS_TEXT);
registerTransition("/", JS_TEXT, JS_SLASH);
registerTransition("\"", JS_TEXT, JS_DQ);
registerTransition("\'", JS_TEXT, JS_Q);
}
} jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/ParseException.java 0000644 0001750 0001750 00000002572 11427052602 026070 0 ustar chris chris /*
* 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.streamhtmlparser;
/**
* Checked exception thrown on an unrecoverable error during parsing.
*
* @see Parser#parse(String)
*/
public class ParseException extends Exception {
/**
* Constructs an {@code ParseException} with no detail message.
*/
public ParseException() {}
/**
* Constructs an {@code ParseException} with a detail message obtained
* from the supplied message and the parser's line and column numbers.
* @param parser the {@code Parser} that triggered the exception
* @param msg the error message
*/
public ParseException(Parser parser, String msg) {
super(String.format("At line: %d (col: %d); %s",
parser.getLineNumber(),
parser.getColumnNumber(),
msg));
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/JavascriptParserFactory.java 0000644 0001750 0001750 00000002560 11427052602 027747 0 ustar chris chris /*
* 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.streamhtmlparser;
import com.google.streamhtmlparser.impl.JavascriptParserImpl;
/**
* A factory class to obtain instances of an Note that we do not typically expect a caller of this package to require
* an instance of a Position must be negative where -1 is the index of the last
* character in the buffer.
*
* @param position The index into the buffer
*
* @return character at the requested index
*/
public char getChar(int position) {
assert(position < 0); // Developer error if it triggers.
int absolutePosition = getAbsolutePosition(position);
if (absolutePosition < 0) {
return '\0';
}
return buffer[absolutePosition];
}
/**
* Sets the given {@code input} at the given {@code position} of the buffer.
* Returns {@code true} if we succeeded or {@code false} if we
* failed (i.e. the write was beyond the buffer boundary).
*
* Index positions are negative where -1 is the index of the
* last character in the buffer.
*
* @param position The index at which to set the character
* @param input The character to set in the buffer
* @return {@code true} if we succeeded, {@code false} otherwise
*/
public boolean setChar(int position, char input) {
assert(position < 0); // Developer error if it triggers.
int absolutePosition = getAbsolutePosition(position);
if (absolutePosition < 0) {
return false;
}
buffer[absolutePosition] = input;
return true;
}
/**
* Returns the last javascript identifier/keyword in the buffer.
*
* @return the last identifier or {@code null} if none was found
*/
public String getLastIdentifier() {
int end = -1;
if (HtmlUtils.isJavascriptWhitespace(getChar(-1))) {
end--;
}
int position;
for (position = end; HtmlUtils.isJavascriptIdentifier(getChar(position));
position--) {
}
if ((position + 1) >= end) {
return null;
}
return slice(position + 1, end);
}
/**
* Returns a slice of the buffer delimited by the given indices.
*
* The start and end indexes represent the start and end of the
* slice to copy. If the start argument extends beyond the beginning
* of the buffer, the slice will only contain characters
* starting from the beginning of the buffer.
*
* @param start The index of the first character the copy
* @param end the index of the last character to copy
*
* @return {@code String} between the given indices
*/
public String slice(int start, int end) {
// Developer error if any of the asserts below fail.
Preconditions.checkArgument(start <= end);
Preconditions.checkArgument(start < 0);
Preconditions.checkArgument(end < 0);
StringBuffer output = new StringBuffer();
for (int position = start; position <= end; position++) {
char c = getChar(position);
if (c != '\0') {
output.append(c);
}
}
return new String(output);
}
/**
* Returns the position relative to the start of the buffer or -1
* if the position is past the size of the buffer.
*
* @param position the index to be translated
* @return the position relative to the start of the buffer
*/
private int getAbsolutePosition(int position) {
assert (position < 0); // Developer error if it triggers.
if (position <= -buffer.length) {
return -1;
}
int len = endIndex - startIndex;
if (len < 0) {
len += buffer.length;
}
if (position < -len) {
return -1;
}
int absolutePosition = (position + endIndex) % buffer.length;
if (absolutePosition < 0) {
absolutePosition += buffer.length;
}
return absolutePosition;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/util/CharacterRecorder.java 0000644 0001750 0001750 00000012114 11427052602 027467 0 ustar chris chris /*
* 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.streamhtmlparser.util;
/**
* Records (stores) characters supplied one at a time conditional on
* whether recording is currently enabled.
*
* When {@link #maybeRecord(char)} is called, it will add the
* supplied character to the recording buffer but only if
* recording is in progress. This is useful in our
* {@link com.google.security.streamhtmlparser.HtmlParser}
* as the caller logic to enable/disable recording is decoupled from the logic
* of recording.
*
* This is a specialized class - of no use to external code -
* which aims to be 100% compatible with the corresponding logic
* in the C-version of the HtmlParser, specifically in
* The The functionality exposed is designed to be 100% compatible with
* the corresponding logic in the C-version of the HtmlParser as such
* we are particularly concerned with cross-language compatibility.
*
* Note: The words {@code Javascript} and {@code ECMAScript} are used
* interchangeably unless otherwise noted.
*/
public final class HtmlUtils {
/**
* static utility class
*/
private HtmlUtils() {
} // COV_NF_LINE
/**
* Indicates the type of content contained in the {@code content} HTML
* attribute of the {@code meta} HTML tag. Used by
* {@link HtmlUtils#parseContentAttributeForUrl(String)}.
* The values are:
* The token {@code void} was added to the list. Several keywords are
* defined in Ecmascript 4 not Ecmascript 3. However, to keep the logic
* simple we do not differentiate on the version and bundle them all together.
*/
private static final Set Currently returns {@code true} for any attribute name that starts
* with "on" which is not exactly correct but we trust a developer to
* not use non-spec compliant attribute names (e.g. onbogus).
*
* @param attribute the name of an HTML attribute
* @return {@code false} if the input is null or is not an attribute
* that expects javascript code; {@code true}
*/
public static boolean isAttributeJavascript(String attribute) {
return ((attribute != null) && attribute.startsWith("on"));
}
/**
* Determines if the HTML attribute specified expects a {@code style}
* for its value. Currently this is only true for the {@code style}
* HTML attribute.
*
* @param attribute the name of an HTML attribute
* @return {@code true} iff the attribute name is one that expects a
* style for a value; otherwise {@code false}
*/
public static boolean isAttributeStyle(String attribute) {
return "style".equals(attribute);
}
/**
* Determines if the HTML attribute specified expects a {@code URI}
* for its value. For example, both {@code href} and {@code src}
* expect a {@code URI} but {@code style} does not. Returns
* {@code false} if the attribute given was {@code null}.
*
* @param attribute the name of an HTML attribute
* @return {@code true} if the attribute name is one that expects
* a URI for a value; otherwise {@code null}
*
* @see #ATTRIBUTE_EXPECTS_URI
*/
public static boolean isAttributeUri(String attribute) {
return ATTRIBUTE_EXPECTS_URI.contains(attribute);
}
/**
* Determines if the specified character is an HTML whitespace character.
* A character is an HTML whitespace character if and only if it is one
* of the characters below.
* Encompasses the characters in sections 7.2 and 7.3 of ECMAScript 3, in
* particular, this list is quite different from that in
* This function expects to receive the value of the {@code content} HTML
* attribute. This attribute takes on different meanings depending on the
* value of the {@code http-equiv} HTML attribute of the same {@code meta}
* tag. Since we may not have access to the {@code http-equiv} attribute,
* we instead rely on parsing the given value to determine if it contains
* a URL.
*
* The specification of the {@code meta} HTML tag can be found in:
* http://dev.w3.org/html5/spec/Overview.html#attr-meta-http-equiv-refresh
*
* We return {@link HtmlUtils.META_REDIRECT_TYPE} indicating whether the
* value contains a URL and whether we are at the start of the URL or past
* the start. We are at the start of the URL if and only if one of the two
* conditions below is true:
* Examples:
* Decodes (unescapes) HTML entities with the complication that these
* are received one character at a time hence must be stored temporarily.
* Also, we may receive some "junk" characters before the actual
* entity which we will discard.
*
* This class is designed to be 100% compatible with the corresponding
* logic in the C-version of the
* {@link com.google.security.streamhtmlparser.HtmlParser}, found
* in Valid HTML entities have one of the following three forms:
* A
* In the unlikely case that this class fails to initialize properly
* (a developer error), an error is emitted to the error console and the logs
* and the specialized parser creation methods will throw
* an {@link AssertionError} on all invokations.
*/
public class HtmlParserFactory {
private static final Logger logger =
Logger.getLogger(HtmlParserFactory.class.getName());
/**
* To provide additional options when creating an {@code HtmlParser} using
* {@link HtmlParserFactory#createParserInAttribute(HtmlParser.ATTR_TYPE,
* boolean, Set)}
*/
public enum AttributeOptions {
/**
* Indicates that the attribute value is Javascript-quoted. Only takes
* effect for Javascript-accepting attributes - as identified by
* {@link HtmlParser.ATTR_TYPE#JS} - and only when the attribute is also
* HTML quoted.
*/
JS_QUOTED,
/**
* Indicates the attribute value is only a part of a URL as opposed to a
* full URL. In particular, the value is not at the start of a URL and
* hence does not necessitate validation of the URL scheme.
* Only valid for URI-accepting attributes - as identified by
* {@link HtmlParser.ATTR_TYPE#URI}.
*/
URL_PARTIAL,
}
/**
* To provide additional options when creating an {@code HtmlParser} using
* {@link HtmlParserFactory#createParserInMode(HtmlParser.Mode, Set)}
*/
public enum ModeOptions {
/**
* Indicates that the parser is inside a quoted {@code String}. Only
* valid in the {@link HtmlParser.Mode#JS} mode.
*/
JS_QUOTED
}
private static final HtmlParser parserInDefaultAttr = createParser();
private static final HtmlParser parserInDefaultAttrQ = createParser();
private static final HtmlParser parserInUriAttrComplete = createParser();
private static final HtmlParser parserInUriAttrQComplete = createParser();
private static final HtmlParser parserInUriAttrPartial = createParser();
private static final HtmlParser parserInUriAttrQPartial = createParser();
private static final HtmlParser parserInJsAttr = createParser();
private static final HtmlParser parserInJsAttrQ = createParser();
private static final HtmlParser parserInQJsAttr = createParser();
private static final HtmlParser parserInStyleAttr = createParser();
private static final HtmlParser parserInStyleAttrQ = createParser();
private static final HtmlParser parserInJsQ = createParser();
/**
* Protects all the createParserXXX methods by throwing a run-time exception
* if this class failed to initialize properly.
*/
private static boolean initSuccess = false;
static {
try {
initializeParsers();
initSuccess = true;
} catch (ParseException e) {
// Log a severe error and print it to stderr along with a stack trace.
String error = HtmlParserFactory.class.getName() +
" Failed initialization: " + e.getMessage();
logger.severe(error);
System.err.println(error);
e.printStackTrace();
}
}
// Static class.
private HtmlParserFactory() {
} // COV_NF_LINE
/**
* Returns an {@code HtmlParser} object ready to parse HTML input.
*
* @return an {@code HtmlParser} in the provided mode
*/
public static HtmlParser createParser() {
return new HtmlParserImpl();
}
/**
* Returns an {@code HtmlParser} object initialized with the
* requested Mode. Provide non {@code null} options to provide
* a more precise initialization with the desired Mode.
*
* @param mode the mode to reset the parser with
* @param options additional options or {@code null} for none
* @return an {@code HtmlParser} in the provided mode
* @throws AssertionError when this class failed to initialize
*/
public static HtmlParser createParserInMode(HtmlParser.Mode mode,
Set For example, to create a parser in a state akin to that
* after the parser has parsed "<a href=\"", invoke:
* You must provide the proper value of quoting or the parser
* will go into an unexpected state.
* As a special-case, when called with the {@code HtmlParser.ATTR_TYPE}
* of {@code HtmlParser.ATTR_TYPE.NONE}, the parser is created in a state
* inside an HTML tag where it expects an attribute name not an attribute
* value. It becomes equivalent to a parser initialized in the
* {@code HTML_IN_TAG} mode.
*
* @param attrtype the attribute type which the parser should be in
* @param quoted whether the attribute value is enclosed in double quotes
* @param options additional options or {@code null} for none
* @return an {@code HtmlParser} initialized in the given attribute type
* and quoting
* @throws AssertionError when this class failed to initialize
*/
public static HtmlParser createParserInAttribute(
HtmlParser.ATTR_TYPE attrtype,
boolean quoted, Set In the very unexpected case of the parsing failing (developer error),
* this class will fail to initialize properly.
*
* In addition:
*
* Provided {@code stringInternStrategy} instance will be used by shared all {@link Parser}
* objects created by the factory and used to optimize the HDF parsing process by reusing the
* String for keys and values.
*
* @param stringInternStrategy - {@link StringInternStrategy} instance used to optimize the HDF
* parsing.
* @return an instance of {@link ParserFactory} implementation.
*/
public static ParserFactory newFactory(StringInternStrategy stringInternStrategy) {
return new NewHdfParserFactory(stringInternStrategy);
}
public void parse(Reader reader, Data output, Parser.ErrorHandler errorHandler,
ResourceLoader resourceLoader, String dataFileName, boolean ignoreAttributes)
throws IOException {
parse(ParseState.createNewParseState(output, reader, errorHandler, resourceLoader, this,
dataFileName, ignoreAttributes));
}
private void parse(ParseState state) throws IOException {
while ((state.line = state.lineReader.readLine()) != null) {
String seq = stripWhitespace(state.line);
try {
parseCommand(seq, state);
} catch (OutOfCharsException e) {
reportError(state, "End of line was prematurely reached. Parse error.");
}
}
}
private static final String INCLUDE_WS = "#include ";
private void parseCommand(String seq, ParseState state) throws IOException, OutOfCharsException {
if (seq.length() == 0) {
// Empty line.
return;
}
if (charAt(seq, 0) == '#') {
// If there isn't a match on include then this is a comment and we do nothing.
if (matches(seq, 0, INCLUDE_WS)) {
// This is an include command
int start = skipLeadingWhitespace(seq, INCLUDE_WS.length());
parseInclude(seq, start, state);
}
return;
} else if (charAt(seq, 0) == '}') {
if (skipLeadingWhitespace(seq, 1) != seq.length()) {
reportError(state, "Extra chars after '}'");
return;
}
handleAscend(state);
} else {
parseHdfElement(seq, state);
}
}
private void parseInclude(String seq, int start, ParseState state) throws IOException,
OutOfCharsException {
int end = seq.length();
if (charAt(seq, start) == '"') {
if (charAt(seq, end - 1) == '"') {
start++;
end--;
} else {
reportError(state, "Missing '\"' at end of include");
return;
}
}
handleInclude(seq.substring(start, end), state);
}
private static final int NO_MATCH = -1;
private void parseHdfElement(String seq, ParseState state) throws IOException,
OutOfCharsException {
// Re-use a single element to avoid repeated allocations/trashing (serious
// performance impact, 5% of real service performance)
HdfNameAttrs element = state.hdfNameAttrs;
if (!parseHdfNameAttrs(element, seq, 0, state)) {
return;
}
int index = skipLeadingWhitespace(seq, element.endOfSequence);
switch (charAt(seq, index)) {
case '{':
// Descend
if (index + 1 != seq.length()) {
reportError(state, "No characters expected after '{'");
return;
}
handleDescend(state, element);
return;
case '=':
// Assignment
index = skipLeadingWhitespace(seq, index + 1);
String value = internStrategy.intern(seq.substring(index, seq.length()));
handleAssign(state, element, value);
return;
case ':':
if (charAt(seq, index + 1) == '=') {
// Copy
index = skipLeadingWhitespace(seq, index + 2);
String src = parseHdfName(seq, index);
if (src == null) {
reportError(state, "Invalid HDF name");
return;
}
if (index + src.length() != seq.length()) {
reportError(state, "No characters expected after '{'");
return;
}
handleCopy(state, element, src);
} else {
// Link
index = skipLeadingWhitespace(seq, index + 1);
String src = parseHdfName(seq, index);
if (src == null) {
reportError(state, "Invalid HDF name");
return;
}
if (index + src.length() != seq.length()) {
reportError(state, "No characters expected after '{'");
return;
}
handleLink(state, element, src);
}
return;
case '<':
if (charAt(seq, index + 1) != '<') {
reportError(state, "Expected '<<'");
}
index = skipLeadingWhitespace(seq, index + 2);
String eomMarker = seq.substring(index, seq.length());
// TODO: think about moving interning to handleAssign()
String multilineValue = internStrategy.intern(parseMultilineValue(state, eomMarker));
if (multilineValue == null) {
return;
}
handleAssign(state, element, multilineValue);
return;
default:
reportError(state, "No valid operator");
return;
}
}
/**
* This method parses out an HDF element name and any optional attributes into a caller-supplied
* HdfNameAttrs object. It returns a {@code boolean} with whether it succeeded to parse.
*/
private boolean parseHdfNameAttrs(HdfNameAttrs destination, String seq, int index,
ParseState state) throws OutOfCharsException {
String hdfName = parseHdfName(seq, index);
if (hdfName == null) {
reportError(state, "Invalid HDF name");
return false;
}
destination.reset(hdfName);
index = skipLeadingWhitespace(seq, index + hdfName.length());
int end = parseAttributes(seq, index, state, destination);
if (end == NO_MATCH) {
// Error already reported below.
return false;
} else {
destination.endOfSequence = end;
return true;
}
}
/**
* Parses a valid hdf path name.
*/
private String parseHdfName(String seq, int index) throws OutOfCharsException {
int end = index;
while (end < seq.length() && isHdfNameChar(charAt(seq, end))) {
end++;
}
if (end == index) {
return null;
}
return internStrategy.intern(seq.substring(index, end));
}
/**
* Looks for optional attributes and adds them to the HdfNameAttrs object passed into the method.
*/
private int parseAttributes(String seq, int index, ParseState state, HdfNameAttrs element)
throws OutOfCharsException {
if (charAt(seq, index) != '[') {
// No attributes to parse
return index;
}
index = skipLeadingWhitespace(seq, index + 1);
// If we don't care about attributes, just skip over them.
if (state.ignoreAttributes) {
while (charAt(seq, index) != ']') {
index++;
}
return index + 1;
}
boolean first = true;
do {
if (first) {
first = false;
} else if (charAt(seq, index) == ',') {
index = skipLeadingWhitespace(seq, index + 1);
} else {
reportError(state, "Error parsing attribute list");
}
index = parseAttribute(seq, index, state, element);
if (index == NO_MATCH) {
// reportError called by parseAttribute already.
return NO_MATCH;
}
index = skipLeadingWhitespace(seq, index);
} while (charAt(seq, index) != ']');
return index + 1;
}
private static final String DEFAULT_ATTR_VALUE = "1";
/**
* Parse out a single HDF attribute. If there is no explicit value, use default value of "1" like
* in C clearsilver. Returns NO_MATCH if it fails to parse an attribute.
*/
private int parseAttribute(String seq, int index, ParseState state, HdfNameAttrs element)
throws OutOfCharsException {
int end = parseAttributeKey(seq, index);
if (index == end) {
reportError(state, "No valid attribute key");
return NO_MATCH;
}
String attrKey = internStrategy.intern(seq.substring(index, end));
index = skipLeadingWhitespace(seq, end);
if (charAt(seq, index) != '=') {
// No value for this attribute key. Use default value of "1"
element.addAttribute(attrKey, DEFAULT_ATTR_VALUE);
return index;
}
// We need to parse out the attribute value.
index = skipLeadingWhitespace(seq, index + 1);
if (charAt(seq, index) == '"') {
index++;
StringBuilder sb = new StringBuilder();
end = parseQuotedAttributeValue(seq, index, sb);
if (end == NO_MATCH) {
reportError(state, "Unable to parse quoted attribute value");
return NO_MATCH;
}
String attrValue = internStrategy.intern(sb.toString());
element.addAttribute(attrKey, attrValue);
end++;
} else {
// Simple attribute that has no whitespace.
String attrValue = parseAttributeValue(seq, index, state);
if (attrValue == null || attrValue.length() == 0) {
reportError(state, "No attribute for key " + attrKey);
return NO_MATCH;
}
attrValue = internStrategy.intern(attrValue);
element.addAttribute(attrKey, attrValue);
end = index + attrValue.length();
}
return end;
}
/**
* Returns the range in the sequence starting at start that corresponds to a valid attribute key.
*/
private int parseAttributeKey(String seq, int index) throws OutOfCharsException {
while (isAlphaNumericChar(charAt(seq, index))) {
index++;
}
return index;
}
/**
* Parses a quoted attribute value. Unescapes octal characters and \n, \r, \t, \", etc.
*/
private int parseQuotedAttributeValue(String seq, int index, StringBuilder sb)
throws OutOfCharsException {
char c;
while ((c = charAt(seq, index)) != '"') {
if (c == '\\') {
// Escaped character. Look for 1 to 3 digits in a row as octal or n,t,r.
index++;
char next = charAt(seq, index);
if (isNumericChar(next)) {
// Parse the next 1 to 3 characters if they are digits. Treat it as an octal code.
int val = next - '0';
if (isNumericChar(charAt(seq, index + 1))) {
index++;
val = val * 8 + (charAt(seq, index) - '0');
if (isNumericChar(charAt(seq, index + 1))) {
index++;
val = val * 8 + (charAt(seq, index) - '0');
}
}
c = (char) val;
} else if (next == 'n') {
c = '\n';
} else if (next == 't') {
c = '\t';
} else if (next == 'r') {
c = '\r';
} else {
// Regular escaped char like " or /
c = next;
}
}
sb.append(c);
index++;
}
return index;
}
/**
* Parses a simple attribute value that cannot have any whitespace or specific punctuation
* reserved by the HDF grammar.
*/
private String parseAttributeValue(String seq, int index, ParseState state)
throws OutOfCharsException {
int end = index;
char c = charAt(seq, end);
while (c != ',' && c != ']' && c != '"' && !Character.isWhitespace(c)) {
end++;
c = charAt(seq, end);
}
return seq.substring(index, end);
}
private String parseMultilineValue(ParseState state, String eomMarker) throws IOException {
StringBuilder sb = new StringBuilder(256);
String line;
while ((line = state.lineReader.readLine()) != null) {
if (line.startsWith(eomMarker)
&& skipLeadingWhitespace(line, eomMarker.length()) == line.length()) {
return sb.toString();
} else {
sb.append(line).append('\n');
}
}
reportError(state, "EOM " + eomMarker + " never found");
return null;
}
// //////////////////////////////////////////////////////////////////////////
//
// Handlers
private void handleDescend(ParseState state, HdfNameAttrs element) {
Data child = handleNodeCreation(state.currentNode, element);
state.context.push(state.currentNode);
state.currentNode = child;
}
private Data handleNodeCreation(Data node, HdfNameAttrs element) {
return element.toData(node);
}
private void handleAssign(ParseState state, HdfNameAttrs element, String value) {
// TODO: think about moving interning here
Data child = handleNodeCreation(state.currentNode, element);
child.setValue(value);
}
private void handleCopy(ParseState state, HdfNameAttrs element, String srcName) {
Data child = handleNodeCreation(state.currentNode, element);
Data src = state.output.getChild(srcName);
if (src != null) {
child.setValue(src.getValue());
} else {
child.setValue("");
}
}
private void handleLink(ParseState state, HdfNameAttrs element, String srcName) {
Data child = handleNodeCreation(state.currentNode, element);
child.setSymlink(state.output.createChild(srcName));
}
private void handleAscend(ParseState state) {
if (state.context.isEmpty()) {
reportError(state, "Too many '}'");
return;
}
state.currentNode = state.context.pop();
}
private void handleInclude(String seq, ParseState state) throws IOException {
String includeFileName = internStrategy.intern(seq);
// Load the file
Reader reader = state.resourceLoader.open(includeFileName);
if (reader == null) {
reportError(state, "Unable to find file " + includeFileName);
return;
}
// Check whether we are in include loop
if (!state.includeStack.push(includeFileName)) {
reportError(state, createIncludeStackTraceMessage(state.includeStack, includeFileName));
return;
}
// Parse the file
state.hdfParser.parse(ParseState
.createParseStateForIncludedFile(state, includeFileName, reader));
if (!includeFileName.equals(state.includeStack.pop())) {
// Include stack trace is corrupted
throw new IllegalStateException("Unable to find on include stack: " + includeFileName);
}
}
private String createIncludeStackTraceMessage(UniqueStack
* An attempt to insert on a stack an object that is already there will fail and result with a
* method {@link #push(Object)} returning false.
*
*
* All provided operations ({@link #pop()} and {@link #push(Object)}) are done in average constant
* time.
*
*
* This class is iterable
*/
public class UniqueStack
* Fields are not private to avoid the performance overhead of hidden access methods used for
* outer classes to access private fields of inner classes.
*/
private static class LocalVariable extends AbstractData {
// Pointer to next LocalVariable in the list.
LocalVariable next;
// Pointer to the first LocalVariable in the next scope down.
LocalVariable nextScope;
String name;
String value;
// True if value represents the path to another Data variable.
boolean isPath;
// Once the path resolves to a valid Data node, store it here to avoid
// refetching.
Data node = null;
// Used only for loop local variables
boolean isFirst = true;
boolean isLast = true;
public String getName() {
return name;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
public String getFullPath() {
return name;
}
public void setAttribute(String key, String value) {
throw new UnsupportedOperationException("Not allowed on local variables.");
}
public String getAttribute(String key) {
return null;
}
public boolean hasAttribute(String key) {
return false;
}
public int getAttributeCount() {
return 0;
}
public Iterable
* Note: If you have elements foo.1, foo.2, foo.3 in first Data object and foo.4, foo.5, foo.6 in
* second Data object, then fetching children of foo will return only foo.1 foo.2 foo.3 from first
* Data object.
*/
public class ChainedData extends DelegatedData {
public static final Logger logger = Logger.getLogger(ChainedData.class.getName());
// This mode allows developers to locate occurrences where they set the same HDF
// variable in multiple Data objects in the chain, which usually indicates
// bad planning or misuse.
public static final boolean DEBUG_MULTIPLE_ASSIGNMENTS = false;
Data[] dataList;
/**
* Optmization for case of single item.
*
* @param data a single data object to wrap.
*/
public ChainedData(Data data) {
super(data);
this.dataList = new Data[] {data};
}
public ChainedData(Data... dataList) {
super(getFirstData(dataList));
this.dataList = dataList;
}
public ChainedData(List dataList) {
super(getFirstData(dataList));
this.dataList = dataList.toArray(new Data[dataList.size()]);
}
@Override
protected DelegatedData newInstance(Data newDelegate) {
return newDelegate == null ? null : new ChainedData(newDelegate);
}
private static Data getFirstData(Data[] dataList) {
if (dataList.length == 0) {
throw new IllegalArgumentException("Must pass in at least one Data object to ChainedData.");
}
Data first = dataList[0];
if (first == null) {
throw new IllegalArgumentException("ChainedData does not accept null Data objects.");
}
return first;
}
private static Data getFirstData(List dataList) {
if (dataList.size() == 0) {
throw new IllegalArgumentException("Must pass in at least one Data object to ChainedData.");
}
Data first = dataList.get(0);
if (first == null) {
throw new IllegalArgumentException("ChainedData does not accept null Data objects.");
}
return first;
}
@Override
public Data getChild(String path) {
ArrayList children = null;
Data first = null;
for (Data d : dataList) {
Data child = d.getChild(path);
if (child != null) {
if (!DEBUG_MULTIPLE_ASSIGNMENTS) {
// If not in debug mode just return the first match. This assumes we are using the new
// style of VariableLocator that does not iteratively ask for each HDF path element
// separately.
return child;
}
if (first == null) {
// First match found
first = child;
} else if (children == null) {
// Second match found
children = new ArrayList(dataList.length);
children.add(first);
children.add(child);
} else {
// Third or more match found
children.add(child);
}
}
}
if (children == null) {
// 0 or 1 matches. Return first which is null or Data.
return first;
} else {
// Multiple matches. Pass back the first item found. This is only hit when
// DEBUG_MULTIPLE_ASSIGNMENTS is true.
logger.info("Found " + children.size() + " matches for path " + path);
return first;
}
}
@Override
public Data createChild(String path) {
Data child = getChild(path);
if (child != null) {
return child;
} else {
// We don't call super because we don't want to wrap the result in DelegatedData.
return dataList[0].createChild(path);
}
}
@Override
public String getValue(String path, String defaultValue) {
Data child = getChild(path);
if (child != null && child.getValue() != null) {
return child.getValue();
} else {
return defaultValue;
}
}
@Override
public int getIntValue(String path, int defaultValue) {
Data child = getChild(path);
if (child != null) {
String value = child.getValue();
try {
return value == null ? defaultValue : TypeConverter.parseNumber(value);
} catch (NumberFormatException e) {
return defaultValue;
}
} else {
return defaultValue;
}
}
@Override
public String getValue(String path) {
Data child = getChild(path);
if (child != null) {
return child.getValue();
} else {
return null;
}
}
@Override
public int getIntValue(String path) {
Data child = getChild(path);
if (child != null) {
return child.getIntValue();
} else {
return 0;
}
}
@Override
public boolean getBooleanValue(String path) {
Data child = getChild(path);
if (child != null) {
return child.getBooleanValue();
} else {
return false;
}
}
@Override
public void toString(StringBuilder out, int indent) {
for (Data d : dataList) {
d.toString(out, indent);
}
}
@Override
public void write(Appendable out, int indent) throws IOException {
for (Data d : dataList) {
d.write(out, indent);
}
}
@Override
public void optimize() {
for (Data d : dataList) {
d.optimize();
}
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/data/DataFactory.java 0000644 0001750 0001750 00000002745 11427052602 026647 0 ustar chris chris /*
* 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.data;
import com.google.clearsilver.jsilver.exceptions.JSilverBadSyntaxException;
import com.google.clearsilver.jsilver.resourceloader.ResourceLoader;
import java.io.IOException;
/**
* Loads data from resources.
*/
public interface DataFactory {
/**
* Create new Data instance, ready to be populated.
*/
Data createData();
/**
* Loads data in Hierarchical Data Format (HDF) into an existing Data object.
*/
void loadData(final String dataFileName, ResourceLoader resourceLoader, Data output)
throws JSilverBadSyntaxException, IOException;
/**
* Loads data in Hierarchical Data Format (HDF) into a new Data object.
*/
Data loadData(String dataFileName, ResourceLoader resourceLoader) throws IOException;
/**
* Returns the Parser used by this factory to parse the HDF content.
*
* @return
*/
Parser getParser();
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/data/NestedMapData.java 0000644 0001750 0001750 00000044047 11427052602 027121 0 ustar chris chris /*
* 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.data;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
/**
* Represents a hierarchical data set of primitives.
*
* This is the JSilver equivalent to ClearSilver's HDF object.
*
* This class has no synchronization logic. Follow the same thread-safety semantics as you would for
* a java.util.ArrayList (i.e. concurrent reads allowed, but ensure you have exclusive access when
* modifying - should not read whilst another thread writes).
*/
public class NestedMapData extends AbstractData {
/**
* Number of children a node can have before we bother allocating a HashMap. We currently allocate
* the HashMap on the 5th child.
*/
private static final int CHILD_MAP_THRESHOLD = 4;
private String name;
private NestedMapData parent;
private final NestedMapData root;
// Lazily intitialized after CHILD_MAP_THRESHOLD is hit.
private Map
* Note: This returns an iterator that starts with the first child at the time of iterator() being
* called, not when this Iterable object was handed to the code. This might result in slightly
* unexpected behavior if the children list is modified between when getChildren() is called and
* iterator is called on the returned object but this should not be an issue in practice as
* iterator is usually called immediately after getChildren().
*
*/
private class IterableChildren implements Iterable
* This method is a helper method for supporting the first() and last() functions on loops without
* requiring loops create a full Data tree.
*
* @param name the name of the local variable to fetch or create.
* @param value The String value to store at the local variable.
* @param isFirst What the local variable should return for
* {@link com.google.clearsilver.jsilver.data.Data#isFirstSibling}
* @param isLast What the local variable should return for
* {@link com.google.clearsilver.jsilver.data.Data#isLastSibling}
*/
void createLocalVariableByValue(String name, String value, boolean isFirst, boolean isLast);
/**
* Creates a local variable that references a (possibly non-existent) Data node. When the Data
* object for this variable is requested, it will return the Data object at the path location or
* {@code null}, if it does not exist. If {@link #findVariable} is called with {@code create ==
* true}, then if no Data object exists at the path location, it will be created.
*
* @param name the name of the local variable to fetch or create.
* @param path The path to the Data object
*/
void createLocalVariableByPath(String name, String path);
/**
* Searches the variable map stack for the specified variable name. If not found, it then searches
* the root Data object. If not found then and create is {@code true}, then a new node is created
* with the given name in the root Data object and that node is returned.
*
* Note: This only creates nodes in the root Data object, not in any local variable map. To do
* that, use the Data node returned by {@link #pushVariableScope()}.
*
* @param name the name of the variable to find and/or create.
* @param create if {@link true} then a new node will be created if an existing Data node with the
* given name does not exist.
* @return The first Data node in the variable map stack that matches the given name, or a Data
* node in the root Data object matching the given name, or {@code null} if no such node
* exists and {@code create} is {@code false}.
*/
Data findVariable(String name, boolean create);
/**
* Searches the variable map stack for the specified variable name, and returns its
* {@link EscapeMode}.
*
* @return If the variable is found, returns its {@link EscapeMode}, otherwise returns {@code
* EscapeMode.ESCAPE_NONE}.
*/
EscapeMode findVariableEscapeMode(String name);
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/data/TypeConverter.java 0000644 0001750 0001750 00000012032 11427052602 027245 0 ustar chris chris /*
* 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.data;
/**
* Static methods for converting stuff in a ClearSilver compatible way.
*/
public class TypeConverter {
private TypeConverter() {}
private static final String ZERO = "0";
private static final String ONE = "1";
/**
* Determines if the given data node exists in a ClearSilver compatible way.
*/
public static boolean exists(Data data) {
return data != null && data.getValue() != null;
}
/**
* Helper method to safely convert an arbitrary data instance (including null) into a valid
* (non-null) string representation.
*/
public static String asString(Data data) {
// Non-existent variables become the empty string
// (the data instance will return null to us)
String value = data != null ? data.getValue() : null;
return value != null ? value : "";
}
/**
* Parses a non-null string in a ClearSilver compatible way.
*
* The is the underlying parsing function which can fail for badly formatted strings. It is really
* important that anyone doing parsing of strings calls this function (rather than doing it
* themselves).
*
* This is an area where JSilver and ClearSilver have some notable differences. ClearSilver relies
* on the template compiler to parse strings in the template and a different parser at runtime for
* HDF values. JSilver uses the same code for both cases.
*
* In ClearSilver HDF: Numbers are parsed sequentially and partial results are returned when an
* invalid character is reached. This means that {@code "123abc"} parses to {@code 123}.
*
* Additionally, ClearSilver doesn't do hex in HDF values, so {@code "a.b=0x123"} will just
* resolve to {@code 0}.
*
* In ClearSilver templates: Hex is supported, including negative values.
*
* In JSilver: A string must be a complete, valid numeric value for parsing. This means {@code
* "123abc"} is invalid and will default to {@code 0}.
*
* In JSilver: Positive hex values are supported for both HDF and templates but negative values
* aren't. This means a template containing something like "" will parse
* correctly but fail to render.
*
* @throws NumberFormatException is the string is badly formatted
*/
public static int parseNumber(String value) throws NumberFormatException {
// NOTE: This is likely to be one of the areas we will want to optimize
// for speed eventually.
if (value.startsWith("0x") || value.startsWith("0X")) {
return Integer.parseInt(value.substring(2), 16);
} else {
return Integer.parseInt(value);
}
}
/**
* Parses and returns the given string as an integer in a ClearSilver compatible way.
*/
public static int asNumber(String value) {
if (value == null || value.isEmpty()) {
return 0;
}
// fast detection for common constants to avoid parsing common values
// TODO: Maybe push this down into parseNumber ??
if (value.equals(ONE)) {
return 1;
}
if (value.equals(ZERO)) {
return 0;
}
try {
return parseNumber(value);
} catch (NumberFormatException e) {
return 0;
}
}
/**
* Helper method to safely convert an arbitrary data instance (including null) into a valid
* integer representation.
*/
public static int asNumber(Data data) {
// Non-existent variables become zero
return data != null ? data.getIntValue() : 0;
}
/**
* Parses and returns the given string as a boolean in a ClearSilver compatible way.
*/
public static boolean asBoolean(String value) {
if (value == null || value.isEmpty()) {
return false;
}
// fast detection for common constants to avoid parsing common values
if (value.equals(ONE)) {
return true;
}
if (value.equals(ZERO)) {
return false;
}
// fast detection of any string not starting with '0'
if (value.charAt(0) != '0') {
return true;
}
try {
return parseNumber(value) != 0;
} catch (NumberFormatException e) {
// Unlike number parsing, we return a positive value when the
// string is badly formatted (it's what clearsilver does).
return true;
}
}
/**
* Helper method to safely convert an arbitrary data instance (including null) into a valid
* boolean representation.
*/
public static boolean asBoolean(Data data) {
// Non-existent variables become false
return data != null ? data.getBooleanValue() : false;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/data/UnmodifiableData.java 0000644 0001750 0001750 00000007001 11427052602 027624 0 ustar chris chris /*
* 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.data;
import com.google.clearsilver.jsilver.autoescape.EscapeMode;
import java.util.Iterator;
/**
* Data wrapper that prevents modifying the delegated Data node or its tree.
*/
public class UnmodifiableData extends DelegatedData {
private static final String MODIFICATION_ERROR_MSG = "Cannot modify this Data object.";
public UnmodifiableData(Data delegate) {
super(delegate);
}
@Override
protected DelegatedData newInstance(Data newDelegate) {
return newDelegate == null ? null : new UnmodifiableData(newDelegate);
}
@Override
public void copy(Data from) {
throw new UnsupportedOperationException(MODIFICATION_ERROR_MSG);
}
@Override
public void copy(String toPath, Data from) {
throw new UnsupportedOperationException(MODIFICATION_ERROR_MSG);
}
/**
* {@link #createChild} calls {@link #getChild} and throws {@link UnsupportedOperationException}
* if no object was found.
*/
@Override
public Data createChild(String path) {
// Check if child already exists
Data child = getChild(path);
if (child == null) {
// If the child described by path does not exist we throw
// an exception as we cannot create a new one.
throw new UnsupportedOperationException(MODIFICATION_ERROR_MSG);
}
return child;
}
protected class UnmodifiableIterator extends DelegatedIterator {
UnmodifiableIterator(Iterator iterator) {
super(iterator);
}
public void remove() {
throw new UnsupportedOperationException(MODIFICATION_ERROR_MSG);
}
}
/**
* Override in order to not allow modifying children with remove().
*/
@Override
protected Iterator
* If there exists a String in the pool equal to the provided value then it will be returned.
* Otherwise provided String may be interned.
*
*
* There is no guarantees on when the pool will return the same object as provided. It is possible
* that value == intern(value) will never be true.
*
* @param value String to be interned
* @return a String that is equal to the one provided.
*/
String intern(String value);
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/interpreter/ 0000755 0001750 0001750 00000000000 11767454572 025250 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/interpreter/InterpretedTemplate.java 0000644 0001750 0001750 00000006256 11427052602 032062 0 ustar chris chris /*
* 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.interpreter;
import com.google.clearsilver.jsilver.autoescape.AutoEscapeOptions;
import com.google.clearsilver.jsilver.autoescape.EscapeMode;
import com.google.clearsilver.jsilver.data.Data;
import com.google.clearsilver.jsilver.data.DataContext;
import com.google.clearsilver.jsilver.data.DefaultDataContext;
import com.google.clearsilver.jsilver.functions.FunctionExecutor;
import com.google.clearsilver.jsilver.resourceloader.ResourceLoader;
import com.google.clearsilver.jsilver.syntax.TemplateSyntaxTree;
import com.google.clearsilver.jsilver.template.DefaultRenderingContext;
import com.google.clearsilver.jsilver.template.RenderingContext;
import com.google.clearsilver.jsilver.template.Template;
import com.google.clearsilver.jsilver.template.TemplateLoader;
import java.io.IOException;
/**
* Template implementation that uses the interpreter to render itself.
*/
public class InterpretedTemplate implements Template {
private final TemplateLoader loader;
private final TemplateSyntaxTree syntaxTree;
private final String name;
private final FunctionExecutor functionExecutor;
private final EscapeMode escapeMode;
private final AutoEscapeOptions autoEscapeOptions;
public InterpretedTemplate(TemplateLoader loader, TemplateSyntaxTree syntaxTree, String name,
FunctionExecutor functionExecutor, AutoEscapeOptions autoEscapeOptions, EscapeMode mode) {
this.loader = loader;
this.syntaxTree = syntaxTree;
this.name = name;
this.functionExecutor = functionExecutor;
this.escapeMode = mode;
this.autoEscapeOptions = autoEscapeOptions;
}
@Override
public void render(Data data, Appendable out, ResourceLoader resourceLoader) throws IOException {
render(createRenderingContext(data, out, resourceLoader));
}
@Override
public void render(RenderingContext context) throws IOException {
TemplateInterpreter interpreter =
new TemplateInterpreter(this, loader, context, functionExecutor);
context.pushExecutionContext(this);
syntaxTree.apply(interpreter);
context.popExecutionContext();
}
@Override
public RenderingContext createRenderingContext(Data data, Appendable out,
ResourceLoader resourceLoader) {
DataContext dataContext = new DefaultDataContext(data);
return new DefaultRenderingContext(dataContext, resourceLoader, out, functionExecutor,
autoEscapeOptions);
}
@Override
public String getTemplateName() {
return name;
}
@Override
public EscapeMode getEscapeMode() {
return escapeMode;
}
@Override
public String getDisplayName() {
return name;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/interpreter/TemplateInterpreter.java 0000644 0001750 0001750 00000057255 11427052602 032105 0 ustar chris chris /*
* 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.interpreter;
import com.google.clearsilver.jsilver.autoescape.EscapeMode;
import com.google.clearsilver.jsilver.data.Data;
import com.google.clearsilver.jsilver.data.DataContext;
import com.google.clearsilver.jsilver.exceptions.ExceptionUtil;
import com.google.clearsilver.jsilver.exceptions.JSilverIOException;
import com.google.clearsilver.jsilver.exceptions.JSilverInterpreterException;
import com.google.clearsilver.jsilver.functions.FunctionExecutor;
import com.google.clearsilver.jsilver.syntax.analysis.DepthFirstAdapter;
import com.google.clearsilver.jsilver.syntax.node.AAltCommand;
import com.google.clearsilver.jsilver.syntax.node.AAutoescapeCommand;
import com.google.clearsilver.jsilver.syntax.node.ACallCommand;
import com.google.clearsilver.jsilver.syntax.node.ADataCommand;
import com.google.clearsilver.jsilver.syntax.node.ADefCommand;
import com.google.clearsilver.jsilver.syntax.node.AEachCommand;
import com.google.clearsilver.jsilver.syntax.node.AEscapeCommand;
import com.google.clearsilver.jsilver.syntax.node.AEvarCommand;
import com.google.clearsilver.jsilver.syntax.node.AHardIncludeCommand;
import com.google.clearsilver.jsilver.syntax.node.AHardLincludeCommand;
import com.google.clearsilver.jsilver.syntax.node.AIfCommand;
import com.google.clearsilver.jsilver.syntax.node.AIncludeCommand;
import com.google.clearsilver.jsilver.syntax.node.ALincludeCommand;
import com.google.clearsilver.jsilver.syntax.node.ALoopCommand;
import com.google.clearsilver.jsilver.syntax.node.ALoopIncCommand;
import com.google.clearsilver.jsilver.syntax.node.ALoopToCommand;
import com.google.clearsilver.jsilver.syntax.node.ALvarCommand;
import com.google.clearsilver.jsilver.syntax.node.ANameCommand;
import com.google.clearsilver.jsilver.syntax.node.ANameVariable;
import com.google.clearsilver.jsilver.syntax.node.ASetCommand;
import com.google.clearsilver.jsilver.syntax.node.AUvarCommand;
import com.google.clearsilver.jsilver.syntax.node.AVarCommand;
import com.google.clearsilver.jsilver.syntax.node.AWithCommand;
import com.google.clearsilver.jsilver.syntax.node.PCommand;
import com.google.clearsilver.jsilver.syntax.node.PExpression;
import com.google.clearsilver.jsilver.syntax.node.PPosition;
import com.google.clearsilver.jsilver.syntax.node.PVariable;
import com.google.clearsilver.jsilver.syntax.node.TCsOpen;
import com.google.clearsilver.jsilver.syntax.node.TWord;
import com.google.clearsilver.jsilver.template.Macro;
import com.google.clearsilver.jsilver.template.RenderingContext;
import com.google.clearsilver.jsilver.template.Template;
import com.google.clearsilver.jsilver.template.TemplateLoader;
import com.google.clearsilver.jsilver.values.Value;
import com.google.clearsilver.jsilver.values.VariableValue;
import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedList;
/**
* Main JSilver interpreter. This walks a template's AST and renders the result out.
*/
public class TemplateInterpreter extends DepthFirstAdapter {
private final Template template;
private final ExpressionEvaluator expressionEvaluator;
private final VariableLocator variableLocator;
private final TemplateLoader templateLoader;
private final RenderingContext context;
private final DataContext dataContext;
public TemplateInterpreter(Template template, TemplateLoader templateLoader,
RenderingContext context, FunctionExecutor functionExecutor) {
this.template = template;
this.templateLoader = templateLoader;
this.context = context;
this.dataContext = context.getDataContext();
expressionEvaluator = new ExpressionEvaluator(dataContext, functionExecutor);
variableLocator = new VariableLocator(expressionEvaluator);
}
// ------------------------------------------------------------------------
// COMMAND PROCESSING
/**
* Chunk of data (i.e. not a CS command).
*/
@Override
public void caseADataCommand(ADataCommand node) {
context.writeUnescaped(node.getData().getText());
}
/**
* <?cs var:blah > expression. Evaluate as string and write output, using default escaping.
*/
@Override
public void caseAVarCommand(AVarCommand node) {
setLastPosition(node.getPosition());
// Evaluate expression.
Value value = expressionEvaluator.evaluate(node.getExpression());
writeVariable(value);
}
/**
* <?cs uvar:blah > expression. Evaluate as string and write output, but don't escape.
*/
@Override
public void caseAUvarCommand(AUvarCommand node) {
setLastPosition(node.getPosition());
// Evaluate expression.
Value value = expressionEvaluator.evaluate(node.getExpression());
context.writeUnescaped(value.asString());
}
/**
* <?cs lvar:blah > command. Evaluate expression and execute commands within.
*/
@Override
public void caseALvarCommand(ALvarCommand node) {
setLastPosition(node.getPosition());
evaluateVariable(node.getExpression(), "[lvar expression]");
}
/**
* <?cs evar:blah > command. Evaluate expression and execute commands within.
*/
@Override
public void caseAEvarCommand(AEvarCommand node) {
setLastPosition(node.getPosition());
evaluateVariable(node.getExpression(), "[evar expression]");
}
private void evaluateVariable(PExpression expression, String stackTraceDescription) {
// Evaluate expression.
Value value = expressionEvaluator.evaluate(expression);
// Now parse result, into new mini template.
Template template =
templateLoader.createTemp(stackTraceDescription, value.asString(), context
.getAutoEscapeMode());
// Intepret new template.
try {
template.render(context);
} catch (IOException e) {
throw new JSilverInterpreterException(e.getMessage());
}
}
/**
* <?cs linclude!'somefile.cs' > command. Lazily includes another template (at render time).
* Throw an error if file does not exist.
*/
@Override
public void caseAHardLincludeCommand(AHardLincludeCommand node) {
setLastPosition(node.getPosition());
include(node.getExpression(), false);
}
/**
* <?cs linclude:'somefile.cs' > command. Lazily includes another template (at render time).
* Silently ignore if the included file does not exist.
*/
@Override
public void caseALincludeCommand(ALincludeCommand node) {
setLastPosition(node.getPosition());
include(node.getExpression(), true);
}
/**
* <?cs include!'somefile.cs' > command. Throw an error if file does not exist.
*/
@Override
public void caseAHardIncludeCommand(AHardIncludeCommand node) {
setLastPosition(node.getPosition());
include(node.getExpression(), false);
}
/**
* <?cs include:'somefile.cs' > command. Silently ignore if the included file does not
* exist.
*/
@Override
public void caseAIncludeCommand(AIncludeCommand node) {
setLastPosition(node.getPosition());
include(node.getExpression(), true);
}
/**
* <?cs set:x='y' > command.
*/
@Override
public void caseASetCommand(ASetCommand node) {
setLastPosition(node.getPosition());
String variableName = variableLocator.getVariableName(node.getVariable());
try {
Data variable = dataContext.findVariable(variableName, true);
Value value = expressionEvaluator.evaluate(node.getExpression());
variable.setValue(value.asString());
// TODO: what about nested structures?
// "set" was used to set a variable to a constant or escaped value like
// X" ?> or
// Keep track of this so autoescaping code can take it into account.
variable.setEscapeMode(value.getEscapeMode());
} catch (UnsupportedOperationException e) {
// An error occurred - probably due to trying to modify an UnmodifiableData
throw new UnsupportedOperationException(createUnsupportedOperationMessage(node, context
.getIncludedTemplateNames()), e);
}
}
/**
* <?cs name:blah > command. Writes out the name of the original variable referred to by a
* given node.
*/
@Override
public void caseANameCommand(ANameCommand node) {
setLastPosition(node.getPosition());
String variableName = variableLocator.getVariableName(node.getVariable());
Data variable = dataContext.findVariable(variableName, false);
if (variable != null) {
context.writeEscaped(variable.getSymlink().getName());
}
}
/**
* <?cs if:blah > ... <?cs else > ... <?cs /if > command.
*/
@Override
public void caseAIfCommand(AIfCommand node) {
setLastPosition(node.getPosition());
Value value = expressionEvaluator.evaluate(node.getExpression());
if (value.asBoolean()) {
node.getBlock().apply(this);
} else {
node.getOtherwise().apply(this);
}
}
/**
* <?cs escape:'html' > command. Changes default escaping function.
*/
@Override
public void caseAEscapeCommand(AEscapeCommand node) {
setLastPosition(node.getPosition());
Value value = expressionEvaluator.evaluate(node.getExpression());
String escapeStrategy = value.asString();
context.pushEscapingFunction(escapeStrategy);
node.getCommand().apply(this);
context.popEscapingFunction();
}
/**
* A fake command injected by AutoEscaper.
*
* AutoEscaper determines the html context in which an include or lvar or evar command is called
* and stores this context in the AAutoescapeCommand node.
*/
@Override
public void caseAAutoescapeCommand(AAutoescapeCommand node) {
setLastPosition(node.getPosition());
Value value = expressionEvaluator.evaluate(node.getExpression());
String escapeStrategy = value.asString();
EscapeMode mode = EscapeMode.computeEscapeMode(escapeStrategy);
context.pushAutoEscapeMode(mode);
node.getCommand().apply(this);
context.popAutoEscapeMode();
}
/**
* <?cs with:x=Something > ... <?cs /with > command. Aliases a value within a specific
* scope.
*/
@Override
public void caseAWithCommand(AWithCommand node) {
setLastPosition(node.getPosition());
VariableLocator variableLocator = new VariableLocator(expressionEvaluator);
String withVar = variableLocator.getVariableName(node.getVariable());
Value value = expressionEvaluator.evaluate(node.getExpression());
if (value instanceof VariableValue) {
if (((VariableValue) value).getReference() == null) {
// With refers to a non-existent variable. Do nothing.
return;
}
}
dataContext.pushVariableScope();
setTempVariable(withVar, value);
node.getCommand().apply(this);
dataContext.popVariableScope();
}
/**
* <?cs loop:10 > ... <?cs /loop > command. Loops over a range of numbers, starting at
* zero.
*/
@Override
public void caseALoopToCommand(ALoopToCommand node) {
setLastPosition(node.getPosition());
int end = expressionEvaluator.evaluate(node.getExpression()).asNumber();
// Start is always zero, increment is always 1, so end < 0 is invalid.
if (end < 0) {
return; // Incrementing the wrong way. Avoid infinite loop.
}
loop(node.getVariable(), 0, end, 1, node.getCommand());
}
/**
* <?cs loop:0,10 > ... <?cs /loop > command. Loops over a range of numbers.
*/
@Override
public void caseALoopCommand(ALoopCommand node) {
setLastPosition(node.getPosition());
int start = expressionEvaluator.evaluate(node.getStart()).asNumber();
int end = expressionEvaluator.evaluate(node.getEnd()).asNumber();
// Start is always zero, increment is always 1, so end < 0 is invalid.
if (end < start) {
return; // Incrementing the wrong way. Avoid infinite loop.
}
loop(node.getVariable(), start, end, 1, node.getCommand());
}
/**
* <?cs loop:0,10,2 > ... <?cs /loop > command. Loops over a range of numbers, with a
* specific increment.
*/
@Override
public void caseALoopIncCommand(ALoopIncCommand node) {
setLastPosition(node.getPosition());
int start = expressionEvaluator.evaluate(node.getStart()).asNumber();
int end = expressionEvaluator.evaluate(node.getEnd()).asNumber();
int incr = expressionEvaluator.evaluate(node.getIncrement()).asNumber();
if (incr == 0) {
return; // No increment. Avoid infinite loop.
}
if (incr > 0 && start > end) {
return; // Incrementing the wrong way. Avoid infinite loop.
}
if (incr < 0 && start < end) {
return; // Incrementing the wrong way. Avoid infinite loop.
}
loop(node.getVariable(), start, end, incr, node.getCommand());
}
/**
* <?cs each:x=Stuff > ... <?cs /each > command. Loops over child items of a data
* node.
*/
@Override
public void caseAEachCommand(AEachCommand node) {
setLastPosition(node.getPosition());
Value expression = expressionEvaluator.evaluate(node.getExpression());
if (expression instanceof VariableValue) {
VariableValue variableValue = (VariableValue) expression;
Data parent = variableValue.getReference();
if (parent != null) {
each(node.getVariable(), variableValue.getName(), parent, node.getCommand());
}
}
}
/**
* <?cs alt:someValue > ... <?cs /alt > command. If value exists, write it, otherwise
* write the body of the command.
*/
@Override
public void caseAAltCommand(AAltCommand node) {
setLastPosition(node.getPosition());
Value value = expressionEvaluator.evaluate(node.getExpression());
if (value.asBoolean()) {
writeVariable(value);
} else {
node.getCommand().apply(this);
}
}
private void writeVariable(Value value) {
if (template.getEscapeMode().isAutoEscapingMode()) {
autoEscapeAndWriteVariable(value);
} else if (value.isPartiallyEscaped()) {
context.writeUnescaped(value.asString());
} else {
context.writeEscaped(value.asString());
}
}
private void autoEscapeAndWriteVariable(Value value) {
if (isTrustedValue(value) || value.isPartiallyEscaped()) {
context.writeUnescaped(value.asString());
} else {
context.writeEscaped(value.asString());
}
}
private boolean isTrustedValue(Value value) {
// True if PropagateEscapeStatus is enabled and value has either been
// escaped or contains a constant string.
return context.getAutoEscapeOptions().getPropagateEscapeStatus()
&& !value.getEscapeMode().equals(EscapeMode.ESCAPE_NONE);
}
// ------------------------------------------------------------------------
// MACROS
/**
* <?cs def:someMacro(x,y) > ... <?cs /def > command. Define a macro (available for
* the remainder of the interpreter context.
*/
@Override
public void caseADefCommand(ADefCommand node) {
String macroName = makeWord(node.getMacro());
LinkedList
* This interface always expects to take a ResourceLoader object from the caller. This helps
* guarantee that per-Template resourceLoaders are respected.
*/
public interface TemplateFactory {
/**
* Load a template from the source.
*
* @param templateName e.g. some/path/to/template.cs
* @param resourceLoader use this ResourceLoader to locate the named template file and any
* included files.
* @param escapeMode the type of escaping to apply to the entire template.
*/
TemplateSyntaxTree find(String templateName, ResourceLoader resourceLoader, EscapeMode escapeMode);
/**
* Create a temporary template from content.
*
* @param content e.g. "Hello <cs var:name >"
* @param escapeMode
* @param escapeMode the type of escaping to apply to the entire template.
*/
TemplateSyntaxTree createTemp(String content, EscapeMode escapeMode);
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/interpreter/VariableLocator.java 0000644 0001750 0001750 00000007377 11427052602 031157 0 ustar chris chris /*
* 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.interpreter;
import com.google.clearsilver.jsilver.syntax.analysis.DepthFirstAdapter;
import com.google.clearsilver.jsilver.syntax.node.ADecNumberVariable;
import com.google.clearsilver.jsilver.syntax.node.ADescendVariable;
import com.google.clearsilver.jsilver.syntax.node.AExpandVariable;
import com.google.clearsilver.jsilver.syntax.node.AHexNumberVariable;
import com.google.clearsilver.jsilver.syntax.node.ANameVariable;
import com.google.clearsilver.jsilver.syntax.node.PVariable;
import com.google.clearsilver.jsilver.values.Value;
/**
* Walks a PVariable node from the parse tree and returns a Data path name.
*
* @see #getVariableName(com.google.clearsilver.jsilver.syntax.node.PVariable)
*/
public class VariableLocator extends DepthFirstAdapter {
private StringBuilder currentName;
private final ExpressionEvaluator expressionEvaluator;
public VariableLocator(ExpressionEvaluator expressionEvaluator) {
this.expressionEvaluator = expressionEvaluator;
}
/**
* If the root PVariable we are evaluating is a simple one then skip creating the StringBuilder
* and descending the tree.
*
* @param variable the variable node to evaluate.
* @return a String representing the Variable name, or {@code null} if it is a compound variable
* node.
*/
private String quickEval(PVariable variable) {
if (variable instanceof ANameVariable) {
return ((ANameVariable) variable).getWord().getText();
} else if (variable instanceof ADecNumberVariable) {
return ((ADecNumberVariable) variable).getDecNumber().getText();
} else if (variable instanceof AHexNumberVariable) {
return ((AHexNumberVariable) variable).getHexNumber().getText();
} else {
// This is a compound variable. Evaluate the slow way.
return null;
}
}
/**
* Returns a Data variable name extracted during evaluation.
*
* @param variable the parsed variable name node to traverse
*/
public String getVariableName(PVariable variable) {
String result = quickEval(variable);
if (result != null) {
return result;
}
StringBuilder lastName = currentName;
currentName = new StringBuilder(10);
variable.apply(this);
result = currentName.toString();
currentName = lastName;
return result;
}
@Override
public void caseANameVariable(ANameVariable node) {
descendVariable(node.getWord().getText());
}
@Override
public void caseADecNumberVariable(ADecNumberVariable node) {
descendVariable(node.getDecNumber().getText());
}
@Override
public void caseAHexNumberVariable(AHexNumberVariable node) {
descendVariable(node.getHexNumber().getText());
}
@Override
public void caseADescendVariable(ADescendVariable node) {
node.getParent().apply(this);
node.getChild().apply(this);
}
@Override
public void caseAExpandVariable(AExpandVariable node) {
node.getParent().apply(this);
Value value = expressionEvaluator.evaluate(node.getChild());
descendVariable(value.asString());
}
private void descendVariable(String name) {
if (currentName.length() != 0) {
currentName.append('.');
}
currentName.append(name);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/adaptor/ 0000755 0001750 0001750 00000000000 11767454572 024337 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/adaptor/LoadPathToFileCache.java 0000644 0001750 0001750 00000012146 11427052602 030706 0 ustar chris chris /*
* 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.adaptor;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* This class implements a cache of a list of loadpaths and a file name to the absolute file name
* where the file is located on the filesystem. The purpose is to avoid filesystem calls for common
* operations, like in which of these directories does this file exist? This class is threadsafe.
*
* Some of this code is copied from {@link com.google.clearsilver.base.CSFileCache}.
*/
public class LoadPathToFileCache {
private final LRUCache
* We don't use the builtin hashCode because it is only 32-bits, and while the expect different
* values of loadpaths is very small, we want to minimize any chance of collision since we use the
* hash as the key and throw away the loadpath list
*
* @param list an ordered list of loadpaths.
* @return a long representing a hash of the loadpaths.
*/
static long hashLoadPath(List
* Necessary to override because HashMap increases the capacity of the hashtable before
* inserting the elements. However, here we have set the max capacity already and will instead
* remove eldest elements instead of increasing capacity.
*/
@Override
public void putAll(Map m) {
for (Map.Entry e : m.entrySet()) {
put(e.getKey(), e.getValue());
}
}
/**
* This method is called by LinkedHashMap to check whether the eldest entry should be removed.
*
* @param eldest
* @return true if element should be removed.
*/
@Override
protected boolean removeEldestEntry(Map.Entry
* This is copied from {@link org.clearsilver.CSUtil#locateFile(java.util.List, String)} but has
* one important difference. It calls our subclassable newFile method.
*
* @param loadPaths the ordered list of paths to search.
* @param filename the name of the file.
* @return a File object corresponding to the file.
* Note: this function does not validate that the URI is well-formed beyond the scheme part
* (and if the URI appears to be relative, not even then). Note in particular that this function
* considers strings of the form "www.google.com:80" to be invalid.
*/
public abstract class BaseUrlValidateFunction implements TextFilter {
@Override
public void filter(String in, Appendable out) throws IOException {
if (!isValidUri(in)) {
out.append('#');
return;
}
applyEscaping(in, out);
}
/**
* Called by {@code filter} after verifying that the input is a valid URI. Should apply any
* appropriate escaping to the input string.
*
* @throws IOException
*/
protected abstract void applyEscaping(String in, Appendable out) throws IOException;
/**
* @return true if a given string either looks like a relative URI, or like an absolute URI with
* an allowed scheme.
*/
protected boolean isValidUri(String in) {
// Quick check for the allowed absolute URI schemes.
String maybeScheme = toLowerCaseAsciiOnly(in.substring(0, Math.min(in.length(), 8)));
if (maybeScheme.startsWith("http://") || maybeScheme.startsWith("https://")
|| maybeScheme.startsWith("ftp://") || maybeScheme.startsWith("mailto:")) {
return true;
}
// If it's an absolute URI with a different scheme, it's invalid.
// ClearSilver defines an absolute URI as one that contains a colon prior
// to any slash.
int slashPos = in.indexOf('/');
if (slashPos != -1) {
// only colons before this point are bad.
return in.lastIndexOf(':', slashPos - 1) == -1;
} else {
// then any colon is bad.
return in.indexOf(':') == -1;
}
}
/**
* Converts an ASCII string to lowercase. Non-ASCII characters are replaced with '?'.
*/
private String toLowerCaseAsciiOnly(String string) {
char[] ca = string.toCharArray();
for (int i = 0; i < ca.length; i++) {
char ch = ca[i];
ca[i] =
(Character.UnicodeBlock.of(ch) == UnicodeBlock.BASIC_LATIN)
? Character.toLowerCase(ch)
: '?';
}
return new String(ca);
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/html/HtmlUrlValidateFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/html/HtmlUrlValidateFunction.ja0000644 0001750 0001750 00000002624 11427052602 032725 0 ustar chris chris /*
* 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.functions.html;
import com.google.clearsilver.jsilver.functions.escape.HtmlEscapeFunction;
import java.io.IOException;
/**
* Validates that a given string is a valid URI and return the HTML escaped string if it is.
* Otherwise the string {@code #} is returned.
*
* @see BaseUrlValidateFunction
*/
public class HtmlUrlValidateFunction extends BaseUrlValidateFunction {
private final HtmlEscapeFunction htmlEscape;
/**
* isUnquoted should be true if the URL appears in an unquoted attribute. like: <a href=<?cs
* var: uri ?>>
*/
public HtmlUrlValidateFunction(boolean isUnquoted) {
htmlEscape = new HtmlEscapeFunction(isUnquoted);
}
protected void applyEscaping(String in, Appendable out) throws IOException {
htmlEscape.filter(in, out);
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/html/CssUrlValidateFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/html/CssUrlValidateFunction.jav0000644 0001750 0001750 00000004601 11427052602 032734 0 ustar chris chris /*
* 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.functions.html;
import java.io.IOException;
/**
* Validates that input string is a valid URI. If it is not valid, the string {@code #} is returned.
* If it is valid, the characters [\n\r\\'"()<>*] are URL encoded to ensure the string can be safely
* inserted in a CSS URL context. In particular:
*
* References:
*
* Loadtests indicate that this class can strip whitespace almost as quickly
* as just reading every character from a string (20% slower).
*
* While not strictly compatible with the JNI Clearsilver whitestripping
* function, we are not aware of any differences that yield functionally
* different HTML output. However, we encourage users to verify for themselves
* and report any differences.
*/
public class HtmlWhiteSpaceStripper implements Appendable {
// Object to output stripped content to.
private final Appendable out;
// Level of whitespace stripping to perform. (Currently not used).
// TODO: Determine what the exact differences are in levels in
// JNI Clearsilver and see if it is worth porting it.
private final int level;
// Has any non-whitespace character been seen since the start of the line.
private boolean nonWsSeen = false;
// Was there previously one or more whitespace chars? If so, we should output
// the first whitespace char in the sequence before any other non-whitespace
// character. 0 signifies no pending whitespace.
private char pendingWs = 0;
// We just saw the start of an HTML tag '<'.
private boolean startHtmlTag = false;
// Are we currently in an opening HTML tag (not " tags
private int textAreaScope = 0;
// Are we between For example, suppose the classpath contains:
* You can access the resources in the class's package like this:
*
* For example, suppose the classpath contains:
*
*
* You can access the resources like this:
*
*
* Set value should not be {@code null} as it can cause {@link NullPointerException}.
*
* @param stringInternStrategy - {@link StringInternStrategy} object
*/
public void setStringInternStrategy(StringInternStrategy stringInternStrategy) {
if (stringInternStrategy == null) {
throw new IllegalArgumentException("StringInternStrategy should not be null.");
}
this.stringInternStrategy = stringInternStrategy;
}
/**
* Returns {@link StringInternStrategy} object that is used for optimization of HDF parsing.
*
*
* The returned value should never be {@code null}.
*
* @return currently used {@link StringInternStrategy} object.
*/
public StringInternStrategy getStringInternStrategy() {
return stringInternStrategy;
}
/**
* If {@code true}, then use a threadlocal buffer pool for holding rendered output when outputting
* to String. Assumes that render() is called from a thread and that thread will not reenter
* render() while it is running. If {@code false}, a new buffer is allocated for each request
* where an Appendable output object was not provided.
*/
public JSilverOptions setUseOutputBufferPool(boolean value) {
this.useOutputBufferPool = value;
return this;
}
/**
* @see #setUseOutputBufferPool(boolean)
*/
public boolean getUseOutputBufferPool() {
return useOutputBufferPool;
}
/**
* If {@code true}, then unnecessary whitespace will be stripped from the output. 'Unnecessary' is
* meant in terms of HTML output. See
* {@link com.google.clearsilver.jsilver.template.HtmlWhiteSpaceStripper} for more info.
*/
public JSilverOptions setStripHtmlWhiteSpace(boolean value) {
this.stripHtmlWhiteSpace = value;
return this;
}
/**
* @see #setStripHtmlWhiteSpace(boolean)
*/
public boolean getStripHtmlWhiteSpace() {
return stripHtmlWhiteSpace;
}
/**
* If {@code true}, then structural whitespace will be stripped from the output. This allows
* templates to be written to more closely match normal programming languages. See
* {@link com.google.clearsilver.jsilver.syntax.StructuralWhitespaceStripper} for more info.
*/
public JSilverOptions setStripStructuralWhiteSpace(boolean value) {
this.stripStructuralWhiteSpace = value;
return this;
}
/**
* @see #setStripHtmlWhiteSpace(boolean)
*/
public boolean getStripStructuralWhiteSpace() {
return stripStructuralWhiteSpace;
}
/**
* Use this method to disable wrapping the global HDF with an UnmodifiableData object which
* prevents modification. This flag is here in case there are corner cases or performance reasons
* that someone may want to disable this protection.
*
* Should not be set to {@code true} unless incompatibilities or performance issues found. Note,
* that setting to {@code true} could introduce bugs in templates that acquire local references to
* the global data structure and then try to modify them, which is not the intended behavior.
* Allowing global data modification during rendering is not compatible with the recently fixed
* JNI Clearsilver library.
*
* TODO: Remove once legacy mode is no longer needed.
*
* @param allowGlobalDataModification {@code true} if you want to avoid wrapping the global HDF so
* that all writes to it during rendering are prevented and throw an exception.
* @return this object.
*/
public JSilverOptions setAllowGlobalDataModification(boolean allowGlobalDataModification) {
this.allowGlobalDataModification = allowGlobalDataModification;
return this;
}
/**
* @see #setAllowGlobalDataModification(boolean)
*/
public boolean getAllowGlobalDataModification() {
return allowGlobalDataModification;
}
/**
* @param keepTemplateCacheFresh {@code true} to have the template cache call
* {@link com.google.clearsilver.jsilver.resourceloader.ResourceLoader#getResourceVersionId(String)}
* to check if it should refresh its cache entries (this incurs a small performance penalty
* each time the cache is accessed)
* @return this object
*/
public JSilverOptions setKeepTemplateCacheFresh(boolean keepTemplateCacheFresh) {
this.keepTemplateCacheFresh = keepTemplateCacheFresh;
return this;
}
/**
* @see #setKeepTemplateCacheFresh(boolean)
*/
public boolean getKeepTemplateCacheFresh() {
return keepTemplateCacheFresh;
}
@Override
public JSilverOptions clone() {
try {
return (JSilverOptions) super.clone();
} catch (CloneNotSupportedException impossible) {
throw new AssertionError(impossible);
}
}
/**
* @see #setLogEscapedVariables
*/
public boolean getLogEscapedVariables() {
return logEscapedVariables;
}
/**
* Use this method to enable logging of all variables whose values are modified by auto escaping
* or <cs escape> commands. These will be logged at {@code Level.WARNING}. This is useful
* for detecting variables that should be exempt from auto escaping.
*
*
* It is recommended to only enable this flag during testing or debugging and not for production
* jobs.
*
* @see #setEscapeMode
*/
public JSilverOptions setLogEscapedVariables(boolean logEscapedVariables) {
this.logEscapedVariables = logEscapedVariables;
return this;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/DataLoader.java 0000644 0001750 0001750 00000002420 11427052602 025523 0 ustar chris chris /*
* 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;
import com.google.clearsilver.jsilver.data.Data;
import com.google.clearsilver.jsilver.exceptions.JSilverBadSyntaxException;
import java.io.IOException;
/**
* Loads data from resources.
*/
public interface DataLoader {
/**
* Create new Data instance, ready to be populated.
*/
Data createData();
/**
* Loads data in Hierarchical Data Format (HDF) into an existing Data object.
*/
void loadData(final String dataFileName, Data output) throws JSilverBadSyntaxException,
IOException;
/**
* Loads data in Hierarchical Data Format (HDF) into a new Data object.
*/
Data loadData(String dataFileName) throws IOException;
}
jsilver-1.0.0.dfsg.orig/src/org/ 0000755 0001750 0001750 00000000000 11767454572 015451 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/org/clearsilver/ 0000755 0001750 0001750 00000000000 11767454572 017764 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/org/clearsilver/ClearsilverFactory.java 0000644 0001750 0001750 00000002536 11427052602 024415 0 ustar chris chris /*
* 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 org.clearsilver;
/**
* A factory for constructing new CS and HDF objects. Allows applications to
* provide subclasses of HDF or CS to be used by the Java Clearsilver
* templating system.
*/
public interface ClearsilverFactory {
/**
* Create a new CS object.
* @param hdf the HDF object to use in constructing the CS object.
* @return a new CS object
*/
public CS newCs(HDF hdf);
/**
* Create a new CS object.
* @param hdf the HDF object to use in constructing the CS object.
* @param globalHdf the global HDF object to use in constructing the
* CS object.
* @return a new CS object
*/
public CS newCs(HDF hdf, HDF globalHdf);
/**
* Create a new HDF object.
* @return a new HDF object
*/
public HDF newHdf();
}
jsilver-1.0.0.dfsg.orig/src/org/clearsilver/FactoryLoader.java 0000644 0001750 0001750 00000011441 11427052602 023343 0 ustar chris chris /*
* 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 org.clearsilver;
import java.lang.reflect.Constructor;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* This class holds static methods for getting and setting the CS and HDF
* factory used throughout the Java Clearsilver Framework.
* Clients are strongly encouraged to not use this class, and
* instead directly inject {@link ClearsilverFactory} into the classes that
* need to create {@link HDF} and {@link CS} instances.
* For now, projects should set the {@link ClearsilverFactory} in FactoryLoader
* and use the singleton accessor {@link #getClearsilverFactory()} if proper
* dependency injection is not easy to implement.
*
* Allows the default implementation to be the original JNI version without
* requiring users that don't want to use the JNI version to have to link
* it in. The ClearsilverFactory object to use can be either passed into the
* {@link #setClearsilverFactory} method or the class name can be specified
* in the Java property {@code org.clearsilver.defaultClearsilverFactory}.
*/
public final class FactoryLoader {
private static final Logger logger =
Logger.getLogger(FactoryLoader.class.getName());
private static final String DEFAULT_CS_FACTORY_CLASS_PROPERTY_NAME =
"org.clearsilver.defaultClearsilverFactory";
private static final String DEFAULT_CS_FACTORY_CLASS_NAME =
"org.clearsilver.jni.JniClearsilverFactory";
// ClearsilverFactory to be used when constructing objects. Allows
// applications to subclass the CS and HDF objects used in Java Clearsilver
private static ClearsilverFactory clearsilverFactory = null;
// Read/Write lock for global factory pointer.
private static final ReadWriteLock factoryLock = new ReentrantReadWriteLock();
// Getters and setters
/**
* Get the {@link org.clearsilver.ClearsilverFactory} object to be used by
* disparate parts of the application.
*/
public static ClearsilverFactory getClearsilverFactory() {
factoryLock.readLock().lock();
if (clearsilverFactory == null) {
factoryLock.readLock().unlock();
factoryLock.writeLock().lock();
try {
if (clearsilverFactory == null) {
clearsilverFactory = newDefaultClearsilverFactory();
}
factoryLock.readLock().lock();
} finally {
factoryLock.writeLock().unlock();
}
}
ClearsilverFactory returned = clearsilverFactory;
factoryLock.readLock().unlock();
return returned;
}
/**
* Set the {@link org.clearsilver.ClearsilverFactory} to be used by
* the application. If parameter is {@code null}, then the default factory
* implementation will be used the next time {@link #getClearsilverFactory()}
* is called.
*
* @return the previous factory (may return {@code null})
*/
public static ClearsilverFactory setClearsilverFactory(
ClearsilverFactory clearsilverFactory) {
factoryLock.writeLock().lock();
try {
ClearsilverFactory previousFactory = FactoryLoader.clearsilverFactory;
FactoryLoader.clearsilverFactory = clearsilverFactory;
return previousFactory;
} finally {
factoryLock.writeLock().unlock();
}
}
private static ClearsilverFactory newDefaultClearsilverFactory() {
String factoryClassName =
System.getProperty(DEFAULT_CS_FACTORY_CLASS_PROPERTY_NAME,
DEFAULT_CS_FACTORY_CLASS_NAME);
try {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
Class By default, it attempts to load the library 'clearsilver-jni' from the
* path specified in the 'java.library.path' system property. However, this
* can be overriden by calling {@link #setLibraryName(String)} and
* {@link #setLibrarySearchPaths(String[])}. If this fails, the JVM exits with a code of 1. However, this strategy
* can be changed using {@link #setFailureCallback(Runnable)}.
* This method copies over the attributes and value of the node and recurses
* through all the children of the source node. Any symlink in the source
* node becomes a symlink in the copy.
*
* @param hdfpath the node within this HDF where the source structure should
* be copied to.
* @param src the source HDF to copy over.
*/
void copy(String hdfpath, HDF src);
/**
* Generates a string representing the content of the HDF tree rooted at
* this node.
*/
String dump();
}
jsilver-1.0.0.dfsg.orig/src/org/clearsilver/DelegatedCs.java 0000644 0001750 0001750 00000004700 11427052602 022751 0 ustar chris chris /*
* 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 org.clearsilver;
import java.io.IOException;
/**
* Utility class that delegates all methods of an CS object. Made to
* facilitate the transition to CS being an interface and thus not
* extensible in the same way as it was.
*
* This class, and its subclasses must take care to wrap or unwrap HDF and CS
* objects as they are passed through from the callers to the delegate object.
*
*/
public abstract class DelegatedCs implements CS {
private final CS cs;
public DelegatedCs(CS cs) {
// Give it an empty HDF. We aren't going to be using the super object anyways.
this.cs = cs;
}
public CS getCs() {
return cs;
}
/**
* Method subclasses are required to override with a method that returns a
* new DelegatedHdf object that wraps the specified HDF object.
*
* @param hdf an HDF object that should be wrapped in a new DelegatedHdf
* object of the same type as this current object.
* @return an object that is a subclass of DelegatedHdf and which wraps the
* given HDF object.
*/
protected abstract DelegatedHdf newDelegatedHdf(HDF hdf);
public void setGlobalHDF(HDF global) {
if (global != null && global instanceof DelegatedHdf) {
global = ((DelegatedHdf)global).getHdf();
}
getCs().setGlobalHDF(global);
}
public HDF getGlobalHDF() {
HDF hdf = getCs().getGlobalHDF();
return hdf != null ? newDelegatedHdf(hdf) : null;
}
public void close() {
getCs().close();
}
public void parseFile(String filename) throws IOException {
getCs().parseFile(filename);
}
public void parseStr(String content) {
getCs().parseStr(content);
}
public String render() {
return getCs().render();
}
public CSFileLoader getFileLoader() {
return getCs().getFileLoader();
}
public void setFileLoader(CSFileLoader fileLoader) {
getCs().setFileLoader(fileLoader);
}
}
jsilver-1.0.0.dfsg.orig/src/org/clearsilver/CS.java 0000644 0001750 0001750 00000003555 11427052602 021121 0 ustar chris chris /*
* 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 org.clearsilver;
import java.io.Closeable;
import java.io.IOException;
public interface CS extends Closeable {
/**
* Specify a new/different global HDF
*/
void setGlobalHDF(HDF global);
/**
* Return global hdf in use
*/
HDF getGlobalHDF();
/**
* Clean up CS object state.
*/
void close();
/**
* Parses the specified file as if it has template content. The file will
* be located using the HDF's loadpaths.
* @param filename the name of file to read in and parse.
* @throws java.io.FileNotFoundException if the specified file does not
* exist.
* @throws IOException other problems reading the file.
*/
void parseFile(String filename) throws IOException;
/**
* Parse the given string as a CS template.
* @param content string to parse.
*/
void parseStr(String content);
/**
* Generate output from the CS templates and HDF objects that have been read
* in.
* @return the output of the template rendering.
*/
String render();
/**
* Get the file loader in use, if any.
* @return the file loader in use.
*/
CSFileLoader getFileLoader();
/**
* Set the CS file loader to use
* @param fileLoader the file loader that should be used.
*/
void setFileLoader(CSFileLoader fileLoader);
}
jsilver-1.0.0.dfsg.orig/src/org/clearsilver/DelegatedHdf.java 0000644 0001750 0001750 00000011740 11427052602 023107 0 ustar chris chris /*
* 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 org.clearsilver;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Date;
import java.util.TimeZone;
/**
* Utility class that delegates all methods of an HDF object. Made to
* facilitate the transition to HDF being an interface and thus not
* extensible in the same way as it was.
*
* This class, and its subclasses must take care to wrap or unwrap HDF and CS
* objects as they are passed through from the callers to the delegate object.
*/
public abstract class DelegatedHdf implements HDF {
private final HDF hdf;
public DelegatedHdf(HDF hdf) {
if (hdf == null) {
throw new NullPointerException("Null HDF is not allowed in constructor of DelegatedHdf.");
}
this.hdf = hdf;
}
/**
* Utility function for concrete ClearsilverFactories to unwrap DelegatedHdfs
* and get down to a concrete (or unknown) HDF object.
* @param hdf the possibly DelegatedHdf to unwrap
* @return the innermost non-DelegatedHdf HDF object.
*/
public static HDF getFullyUnwrappedHdf(HDF hdf) {
while (hdf instanceof DelegatedHdf) {
hdf = ((DelegatedHdf)hdf).getHdf();
}
return hdf;
}
public HDF getHdf() {
return hdf;
}
/**
* Method subclasses are required to override with a method that returns a
* new DelegatedHdf object that wraps the specified HDF object.
*
* @param hdf an HDF object that should be wrapped in a new DelegatedHdf
* object of the same type as this current object.
* @return an object that is a subclass of DelegatedHdf and which wraps the
* given HDF object.
*/
protected abstract DelegatedHdf newDelegatedHdf(HDF hdf);
public void close() {
getHdf().close();
}
public boolean readFile(String filename) throws IOException, FileNotFoundException {
return getHdf().readFile(filename);
}
public CSFileLoader getFileLoader() {
return getHdf().getFileLoader();
}
public void setFileLoader(CSFileLoader fileLoader) {
getHdf().setFileLoader(fileLoader);
}
public boolean writeFile(String filename) throws IOException {
return getHdf().writeFile(filename);
}
public boolean readString(String data) {
return getHdf().readString(data);
}
public String writeString() {
return getHdf().writeString();
}
public int getIntValue(String hdfname,
int default_value) {
return getHdf().getIntValue(hdfname, default_value);
}
public String getValue(String hdfname, String default_value) {
return getHdf().getValue(hdfname, default_value);
}
public void setValue(
String hdfname, String value) {
getHdf().setValue(hdfname, value);
}
public void removeTree(String hdfname) {
getHdf().removeTree(hdfname);
}
public void setSymLink(String hdf_name_src,
String hdf_name_dest) {
getHdf().setSymLink(hdf_name_src, hdf_name_dest);
}
public void exportDate(
String hdfname, TimeZone timeZone, Date date) {
getHdf().exportDate(hdfname, timeZone, date);
}
public void exportDate(
String hdfname, String tz, int tt) {
getHdf().exportDate(hdfname, tz, tt);
}
public DelegatedHdf getObj(String hdfpath) {
HDF hdf = getHdf().getObj(hdfpath);
return hdf != null ? newDelegatedHdf(hdf) : null;
}
public DelegatedHdf getChild(String hdfpath) {
HDF hdf = getHdf().getChild(hdfpath);
return hdf != null ? newDelegatedHdf(hdf) : null;
}
public DelegatedHdf getRootObj() {
HDF hdf = getHdf().getRootObj();
return hdf != null ? newDelegatedHdf(hdf) : null;
}
public boolean belongsToSameRoot(HDF hdf) {
return getFullyUnwrappedHdf(this).belongsToSameRoot(getFullyUnwrappedHdf(hdf));
}
public DelegatedHdf getOrCreateObj(String hdfpath) {
HDF hdf = getHdf().getOrCreateObj(hdfpath);
return hdf != null ? newDelegatedHdf(hdf) : null;
}
public String objName() {
return getHdf().objName();
}
public String objValue() {
return getHdf().objValue();
}
public DelegatedHdf objChild() {
HDF hdf = getHdf().objChild();
return hdf != null ? newDelegatedHdf(hdf) : null;
}
public DelegatedHdf objNext() {
HDF hdf = getHdf().objNext();
return hdf != null ? newDelegatedHdf(hdf) : null;
}
public void copy(String hdfpath, HDF src) {
if (src != null && src instanceof DelegatedHdf) {
src = ((DelegatedHdf)src).getHdf();
}
getHdf().copy(hdfpath, src);
}
public String dump() {
return getHdf().dump();
}
}
ParserStateTable which is
* derived from a state-machine configuration file in the original C++ parser.
*
* InternalState instances are
* package-scope only as they are only needed by HtmlParserImpl
* and JavascriptParserImpl.
*/
class InternalState {
// An InternalState to represent an error condition for all parsers.
static final InternalState INTERNAL_ERROR_STATE = new InternalState();
// MAX_ID and FIRST_ID are only used for asserts against developer error.
private static final int MAX_ID = 255;
private static final int FIRST_ID = 1;
private static AtomicInteger htmlStates = new AtomicInteger(FIRST_ID);
private static AtomicInteger javascriptStates = new AtomicInteger(FIRST_ID);
private final String name;
private final int id;
/**
* @param name the {@code String} identifier for this state
* @param id the integer identiifer for this state, guaranteed to be unique
*/
private InternalState(String name, int id) {
Preconditions.checkNotNull(name);
Preconditions.checkArgument(id >= FIRST_ID);
Preconditions.checkArgument(id <= MAX_ID);
this.name = name;
this.id = id;
}
/**
* Used only for the error state. Bypasses assert checks.
*/
private InternalState() {
name = "InternalStateError";
id = 0;
}
/**
* @return {@code String} name of that state.
*/
public String getName() {
return name;
}
/**
* @return {@code int} id of that state.
*/
public int getId() {
return id;
}
/**
* @return {@code String} representation of that object, the format
* may change.
*/
@Override
public String toString() {
return String.format("InternalState: Name: %s; Id: %d", name, id);
}
/**
* Obtain a new {@code InternalState} instance for the HTML parser.
*
* @param name a unique identifier for this state useful during debugging
* @return a new {@code InternalState} object
*/
static InternalState getInstanceHtml(String name) {
int htmlStateId = htmlStates.getAndIncrement();
return new InternalState(name, htmlStateId);
}
/**
* Obtain a new InternalState instance for the Javascript parser.
*
* @param name A unique identifier for this state useful during debugging
* @return a new {@code InternalState} object
*/
static InternalState getInstanceJavascript(String name) {
int javascriptStateId = javascriptStates.getAndIncrement();
return new InternalState(name, javascriptStateId);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/impl/HtmlParserImpl.java 0000644 0001750 0001750 00000073751 11427052602 027012 0 ustar chris chris /*
* 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.streamhtmlparser.impl;
import com.google.common.base.Preconditions;
import com.google.common.collect.Maps;
import com.google.streamhtmlparser.ExternalState;
import com.google.streamhtmlparser.HtmlParser;
import com.google.streamhtmlparser.ParseException;
import com.google.streamhtmlparser.util.CharacterRecorder;
import com.google.streamhtmlparser.util.EntityResolver;
import com.google.streamhtmlparser.util.HtmlUtils;
import java.util.Map;
/**
* A custom specialized parser - ported from the main C++ version - used to
* implement context-aware escaping of run-time data in web-application
* templates.
*
* InternalState and
* ExternalState is a many-to-one relationship.
*/
private static final InternalState TEXT;
private static final InternalState TAG_START;
private static final InternalState TAG_NAME;
private static final InternalState DECL_START;
private static final InternalState DECL_BODY;
private static final InternalState COM_OPEN;
private static final InternalState COM_BODY;
private static final InternalState COM_DASH;
private static final InternalState COM_DASH_DASH;
private static final InternalState PI;
private static final InternalState PI_MAY_END;
private static final InternalState TAG_SPACE;
private static final InternalState TAG_CLOSE;
private static final InternalState ATTR;
private static final InternalState ATTR_SPACE;
private static final InternalState VALUE;
private static final InternalState VALUE_TEXT;
private static final InternalState VALUE_Q_START;
private static final InternalState VALUE_Q;
private static final InternalState VALUE_DQ_START;
private static final InternalState VALUE_DQ;
private static final InternalState CDATA_COM_START;
private static final InternalState CDATA_COM_START_DASH;
private static final InternalState CDATA_COM_BODY;
private static final InternalState CDATA_COM_DASH;
private static final InternalState CDATA_COM_DASH_DASH;
private static final InternalState CDATA_TEXT;
private static final InternalState CDATA_LT;
private static final InternalState CDATA_MAY_CLOSE;
private static final InternalState JS_FILE;
private static final InternalState CSS_FILE;
static {
TEXT = InternalState.getInstanceHtml("TEXT");
TAG_START = InternalState.getInstanceHtml("TAG_START");
TAG_NAME = InternalState.getInstanceHtml("TAG_NAME");
DECL_START = InternalState.getInstanceHtml("DECL_START");
DECL_BODY = InternalState.getInstanceHtml("DECL_BODY");
COM_OPEN = InternalState.getInstanceHtml("COM_OPEN");
COM_BODY = InternalState.getInstanceHtml("COM_BODY");
COM_DASH = InternalState.getInstanceHtml("COM_DASH");
COM_DASH_DASH = InternalState.getInstanceHtml("COM_DASH_DASH");
PI =InternalState.getInstanceHtml("PI");
PI_MAY_END = InternalState.getInstanceHtml("PI_MAY_END");
TAG_SPACE = InternalState.getInstanceHtml("TAG_SPACE");
TAG_CLOSE = InternalState.getInstanceHtml("TAG_CLOSE");
ATTR = InternalState.getInstanceHtml("ATTR");
ATTR_SPACE = InternalState.getInstanceHtml("ATTR_SPACE");
VALUE = InternalState.getInstanceHtml("VALUE");
VALUE_TEXT = InternalState.getInstanceHtml("VALUE_TEXT");
VALUE_Q_START = InternalState.getInstanceHtml("VALUE_Q_START");
VALUE_Q = InternalState.getInstanceHtml("VALUE_Q");
VALUE_DQ_START = InternalState.getInstanceHtml("VALUE_DQ_START");
VALUE_DQ = InternalState.getInstanceHtml("VALUE_DQ");
CDATA_COM_START = InternalState.getInstanceHtml("CDATA_COM_START");
CDATA_COM_START_DASH =
InternalState.getInstanceHtml("CDATA_COM_START_DASH");
CDATA_COM_BODY = InternalState.getInstanceHtml("CDATA_COM_BODY");
CDATA_COM_DASH = InternalState.getInstanceHtml("CDATA_COM_DASH");
CDATA_COM_DASH_DASH = InternalState.getInstanceHtml("CDATA_COM_DASH_DASH");
CDATA_TEXT = InternalState.getInstanceHtml("CDATA_TEXT");
CDATA_LT = InternalState.getInstanceHtml("CDATA_LT");
CDATA_MAY_CLOSE = InternalState.getInstanceHtml("CDATA_MAY_CLOSE");
JS_FILE = InternalState.getInstanceHtml("JS_FILE");
CSS_FILE = InternalState.getInstanceHtml("CSS_FILE");
}
private static final Map
*
*
* @return {@code true} if and only if the parser is inside CSS
*/
@Override
public boolean inCss() {
return (currentState == CSS_FILE
|| (getState() == STATE_VALUE
&& (getAttributeType() == ATTR_TYPE.STYLE))
|| ("style".equals(getTag())));
}
@Override
public ATTR_TYPE getAttributeType() {
String attribute = getAttribute();
if (!inAttribute()) {
return ATTR_TYPE.NONE;
}
if (HtmlUtils.isAttributeJavascript(attribute)) {
return ATTR_TYPE.JS;
}
if (HtmlUtils.isAttributeUri(attribute)) {
return ATTR_TYPE.URI;
}
if (HtmlUtils.isAttributeStyle(attribute)) {
return ATTR_TYPE.STYLE;
}
// Special logic to handle the "content" attribute of the "meta" tag.
if ("meta".equals(getTag()) && "content".equals(getAttribute())) {
HtmlUtils.META_REDIRECT_TYPE redirectType =
HtmlUtils.parseContentAttributeForUrl(getValue());
if (redirectType == HtmlUtils.META_REDIRECT_TYPE.URL_START ||
redirectType == HtmlUtils.META_REDIRECT_TYPE.URL)
return ATTR_TYPE.URI;
}
return ATTR_TYPE.REGULAR;
}
@Override
public ExternalState getJavascriptState() {
return jsParser.getState();
}
@Override
public boolean isAttributeQuoted() {
return (currentState == VALUE_Q_START
|| currentState == VALUE_Q
|| currentState == VALUE_DQ_START
|| currentState == VALUE_DQ);
}
@Override
public String getTag() {
return tag.getContent().toLowerCase();
}
@Override
public String getAttribute() {
return inAttribute() ? attr.getContent().toLowerCase() : "";
}
@Override
public String getValue() {
return (getState() == STATE_VALUE) ? value.getContent() : "";
}
@Override
public int getValueIndex() {
if (getState() != STATE_VALUE) {
return 0;
}
return valueIndex;
}
@Override
public boolean isUrlStart() {
// False when not inside an HTML attribute value
if (getState() != STATE_VALUE) {
return false;
}
// Or when the HTML attribute is not of URI type.
if (getAttributeType() != ATTR_TYPE.URI) {
return false;
}
// Or when we received an InsertText() directive at the start of a URL.
if (textInsideUrlValue) {
return false;
}
if ("meta".equals(getTag())) {
// At this point, we know we are in the "content" attribute
// or we would not have the URI attribute type.
return (HtmlUtils.parseContentAttributeForUrl(getValue()) ==
HtmlUtils.META_REDIRECT_TYPE.URL_START);
}
// For all other URI attributes, check if we are at index 0.
return (getValueIndex() == 0);
}
/**
* {@inheritDoc}
*
* Resets the state of the parser to a state consistent with the
* {@code Mode} provided. This will reset finer-grained state
* information back to a default value, hence use only when
* you want to parse text from a very clean slate.
*
*
*
*
* @throws ParseException if an unrecoverable error occurred during parsing
*/
@Override
public void insertText() throws ParseException {
// Case: Inside URL attribute value.
if (getState() == STATE_VALUE
&& getAttributeType() == ATTR_TYPE.URI
&& isUrlStart()) {
textInsideUrlValue = true;
}
// Case: Before parsing any attribute value.
if (currentState == VALUE) {
setNextState(VALUE_TEXT);
}
}
@Override
protected InternalState handleEnterState(InternalState currentState,
InternalState expectedNextState,
char input) {
InternalState nextState = expectedNextState;
if (currentState == TAG_NAME) {
enterTagName();
} else if (currentState == ATTR) {
enterAttribute();
} else if (currentState == TAG_CLOSE) {
nextState = tagClose(currentState);
} else if (currentState == CDATA_MAY_CLOSE) {
enterStateCdataMayClose();
} else if (currentState == VALUE) {
enterValue();
} else
if (currentState == VALUE_TEXT || currentState == VALUE_Q
|| currentState == VALUE_DQ) {
enterValueContent();
}
return nextState;
}
@Override
protected InternalState handleExitState(InternalState currentState,
InternalState expectedNextState,
char input) {
InternalState nextState = expectedNextState;
if (currentState == TAG_NAME) {
exitTagName();
} else if (currentState == ATTR) {
exitAttribute();
} else if (currentState == CDATA_MAY_CLOSE) {
nextState = exitStateCdataMayClose(nextState, input);
} else
if ((currentState == VALUE_TEXT) || (currentState == VALUE_Q)
|| (currentState == VALUE_DQ)) {
exitValueContent();
}
return nextState;
}
@Override
protected InternalState handleInState(InternalState currentState,
char input) throws ParseException {
if ((currentState == CDATA_TEXT)
|| (currentState == CDATA_COM_START)
|| (currentState == CDATA_COM_START_DASH)
|| (currentState == CDATA_COM_BODY)
|| (currentState == CDATA_COM_DASH)
|| (currentState == CDATA_COM_DASH_DASH)
|| (currentState == CDATA_LT)
|| (currentState == CDATA_MAY_CLOSE)
|| (currentState == JS_FILE)) {
inStateCdata(input);
} else if ((currentState == VALUE_TEXT)
|| (currentState == VALUE_Q)
|| (currentState == VALUE_DQ)) {
inStateValue(input);
}
return currentState;
}
/**
* Invokes recording on all CharacterRecorder objects. Currently we do
* not check that one and only one of them is recording. I did a fair
* bit of testing on the C++ parser and was not convinced there is
* such a guarantee.
*/
@Override
protected void record(char input) {
attr.maybeRecord(input);
tag.maybeRecord(input);
value.maybeRecord(input);
cdataCloseTag.maybeRecord(input);
}
/**
* Starts recording the name of the HTML tag. Called when the parser
* enters a new tag.
*/
private void enterTagName() {
tag.startRecording();
}
private void exitTagName() {
tag.stopRecording();
String tagString = tag.getContent();
if (!tagString.isEmpty() && tagString.charAt(0) == '/') {
tag.reset();
}
}
/**
* Starts recording the name of the HTML attribute. Called when the parser
* enters a new HTML attribute.
*/
private void enterAttribute() {
attr.startRecording();
}
private void exitAttribute() {
attr.stopRecording();
}
/**
* Tracks the index within the HTML attribute value and initializes
* the javascript parser for attributes that take javascript.
*
* Called when the parser enters a new HTML attribute value.
*/
private void enterValue() {
valueIndex = 0;
textInsideUrlValue = false;
if (HtmlUtils.isAttributeJavascript(getAttribute())) {
entityResolver.reset();
jsParser.reset();
insideJavascript = true;
} else {
insideJavascript = false;
}
}
/**
* Starts recordning the contents of the attribute value.
*
* Called when entering an attribute value.
*/
private void enterValueContent() {
value.startRecording();
}
/**
* Stops the recording of the attribute value and exits javascript
* (in case we were inside it).
*/
private void exitValueContent() {
value.stopRecording();
insideJavascript = false;
}
/**
* Processes javascript after performing entity resolution and updates
* the position within the attribute value.
* If the status of the entity resolution is IN_PROGRESS,
* we don't invoke the javascript parser.
*
*
*
*
* JavascriptParser.
* Currently each instance is a new object given these are fairly
* light-weight.
*
* JavascriptParser since one is already
* embedded in the more general-purpose HtmlParser. We still
* make it possible to require one as it may be useful for more
* specialized needs.
*
*/
public class JavascriptParserFactory {
public static JavascriptParser getInstance() {
return new JavascriptParserImpl();
}
// Static class.
private JavascriptParserFactory() {
} // COV_NF_LINE
} jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/util/ 0000755 0001750 0001750 00000000000 11767454573 023267 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/util/JavascriptTokenBuffer.java 0000644 0001750 0001750 00000020256 11427052602 030354 0 ustar chris chris /*
* 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.streamhtmlparser.util;
import com.google.common.base.Preconditions;
import java.util.Arrays;
/**
* Implements a circular (ring) buffer of characters with specialized
* application logic in order to determine the context of some
* Javascript content that is being parsed.
*
* This is a specialized class - of no use to external code -
* which aims to be 100% compatible with the corresponding logic
* in the C-version of the HtmlParser, specifically
* jsparser.c. In particular:
*
*
*/
public class JavascriptTokenBuffer {
/**
* Size of the ring buffer used to lookup the last token in the javascript
* stream. The size is somewhat arbitrary but must be larger than
* the biggest token we want to lookup plus three: Two delimiters plus
* an empty ring buffer slot.
*/
private static final int BUFFER_SIZE = 18;
/** Storage implementing the circular buffer. */
private final char[] buffer;
/** Index of the first item in our circular buffer. */
private int startIndex;
/** Index of the last item in our circular buffer. */
private int endIndex;
/**
* Constructs an empty javascript token buffer. The size is fixed,
* see {@link #BUFFER_SIZE}.
*/
public JavascriptTokenBuffer() {
buffer = new char[BUFFER_SIZE];
startIndex = 0;
endIndex = 0;
}
/**
* Constructs a javascript token buffer that is identical to
* the one given. In particular, it has the same size and contents.
*
* @param aJavascriptTokenBuffer the {@code JavascriptTokenBuffer} to copy
*/
public JavascriptTokenBuffer(JavascriptTokenBuffer aJavascriptTokenBuffer) {
buffer = Arrays.copyOf(aJavascriptTokenBuffer.buffer,
aJavascriptTokenBuffer.buffer.length);
startIndex = aJavascriptTokenBuffer.startIndex;
endIndex = aJavascriptTokenBuffer.endIndex;
}
/**
* A simple wrapper over appendChar, it appends a string
* to the buffer. Sequences of whitespace and newlines
* are folded into one character to save space. Null strings are
* not allowed.
*
* @param input the {@code String} to append, cannot be {@code null}
*/
// TODO: Move to testing since not used in code.
public void appendString(String input) {
if (input == null) {
throw new NullPointerException("input == null is not allowed");
}
for (int i = 0; i < input.length(); i++) {
appendChar(input.charAt(i));
}
}
/**
* Appends a character to the buffer. We fold sequences of whitespace and
* newlines into one to save space.
*
* @param input the {@code char} to append
*/
public void appendChar(char input) {
if (HtmlUtils.isJavascriptWhitespace(input) &&
HtmlUtils.isJavascriptWhitespace(getChar(-1))) {
return;
}
buffer[endIndex] = input;
endIndex = (endIndex + 1) % buffer.length;
if (endIndex == startIndex) {
startIndex = (endIndex + 1) % buffer.length;
}
}
/**
* Returns the last character in the buffer and removes it from the buffer
* or the NUL character '\0' if the buffer is empty.
*
* @return last character in the buffer or '\0' if the buffer is empty
*/
public char popChar() {
if (startIndex == endIndex) {
return '\0';
}
endIndex--;
if (endIndex < 0) {
endIndex += buffer.length;
}
return buffer[endIndex];
}
/**
* Returns the character at a given index in the buffer or nul ('\0')
* if the index is outside the range of the buffer. Such could happen
* if the buffer is not filled enough or the index is larger than the
* size of the buffer.
*
* statemachine.c. In particular:
*
*
*/
public class CharacterRecorder {
/**
* How many characters can be recorded before stopping to accept new
* ones. Set to one less than in the C-version as we do not need
* to reserve a character for the terminating null.
*/
public static final int RECORDING_BUFFER_SIZE = 255;
/**
* This is where characters provided for recording are stored. Given
* that the CharacterRecorder object is re-used, might as well
* allocate the full size from the get-go.
*/
private final StringBuilder sb;
/** Holds whether we are currently recording characters or not. */
private boolean recording;
/**
* Constructs an empty character recorder of fixed size currently
* not recording. See {@link #RECORDING_BUFFER_SIZE} for the size.
*/
public CharacterRecorder() {
sb = new StringBuilder(RECORDING_BUFFER_SIZE);
recording = false;
}
/**
* Constructs a character recorder of fixed size that is a copy
* of the one provided. In particular it has the same recording
* setting and the same contents.
*
* @param aCharacterRecorder the {@code CharacterRecorder} to copy
*/
public CharacterRecorder(CharacterRecorder aCharacterRecorder) {
recording = aCharacterRecorder.recording;
sb = new StringBuilder(RECORDING_BUFFER_SIZE);
sb.append(aCharacterRecorder.getContent());
}
/**
* Enables recording for incoming characters. The recording buffer is cleared
* of content it may have contained.
*/
public void startRecording() {
// This is very fast, no memory (re-) allocation will take place.
sb.setLength(0);
recording = true;
}
/**
* Disables recording further characters.
*/
public void stopRecording() {
recording = false;
}
/**
* Records the {@code input} if recording is currently on and we
* have space available in the buffer. If recording is not
* currently on, this method will not perform any action.
*
* @param input the character to record
*/
public void maybeRecord(char input) {
if (recording && (sb.length() < RECORDING_BUFFER_SIZE)) {
sb.append(input);
}
}
/**
* Empties the underlying storage but does not change the recording
* state [i.e whether we are recording or not incoming characters].
*/
public void clear() {
sb.setLength(0);
}
/**
* Empties the underlying storage and resets the recording indicator
* to indicate we are not recording currently.
*/
public void reset() {
clear();
recording = false;
}
/**
* Returns the characters recorded in a {@code String} form. This
* method has no side-effects, the characters remain stored as is.
*
* @return the contents in a {@code String} form
*/
public String getContent() {
return sb.toString();
}
/**
* Returns whether or not we are currently recording incoming characters.
*
* @return {@code true} if we are recording, {@code false} otherwise
*/
public boolean isRecording() {
return recording;
}
/**
* Returns the full state of the object in a human readable form. The
* format of the returned {@code String} is not specified and is
* subject to change.
*
* @return the full state of this object
*/
@Override
public String toString() {
return String.format("In recording: %s; Value: %s", isRecording(),
sb.toString());
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/util/HtmlUtils.java 0000644 0001750 0001750 00000034220 11427052602 026034 0 ustar chris chris /*
* 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.streamhtmlparser.util;
import com.google.common.collect.ImmutableSortedSet;
import java.util.Set;
import java.util.regex.Pattern;
import java.util.regex.Matcher;
/**
* Utility functions for HTML and Javascript that are most likely
* not interesting to users outside this package.
*
* HtmlParser will be open-sourced hence we took the
* decision to keep these utilities in this package as well as not to
* leverage others that may exist in the google3 code base.
*
*
*
*/
public enum META_REDIRECT_TYPE {
NONE,
URL_START,
URL
}
/**
* A regular expression matching the format of a {@code content} attribute
* that contains a URL. Used by {@link #parseContentAttributeForUrl}.
*/
private static final String META_REDIRECT_REGEX =
"^\\s*\\d*\\s*;\\s*URL\\s*=\\s*[\'\"]?";
// Safe for use by concurrent threads so we compile once.
private static final Pattern META_REDIRECT_PATTERN =
Pattern.compile(META_REDIRECT_REGEX, Pattern.CASE_INSENSITIVE);
/**
* Set of keywords that can precede a regular expression literal. Taken from:
*
* Language Syntax
*
*
*
*
* Note: The list includes the zero-width space (Space character
* Tab character
* Line feed character
* Carriage Return character
* Zero-Width Space character
* ​)
* which is not included in the C version.
*
* @param chr the {@code char} to check
* @return {@code true} if the character is an HTML whitespace character
*
* White space
*/
public static boolean isHtmlSpace(char chr) {
return HTML_WHITESPACE.contains(chr);
}
/**
* Determines if the specified character is an ECMAScript whitespace or line
* terminator character. A character is a whitespace or line terminator if
* and only if it is one of the characters below:
*
*
*
* Tab, Vertical Tab,
* Form Feed, Space,
* No-break space)
* Line Feed,
* Carriage Return, Line separator,
* Paragraph Separator).
* Character.isWhitespace.
*
* ECMAScript Language Specification
*
* @param chr the {@code char} to check
* @return {@code true} or {@code false}
*
*/
public static boolean isJavascriptWhitespace(char chr) {
return JAVASCRIPT_WHITESPACE.contains(chr);
}
/**
* Determines if the specified character is a valid character in an
* ECMAScript identifier. This determination is currently not exact,
* in particular:
*
*
*
* We are considering leveraging Character.isJavaIdentifierStart
* and Character.isJavaIdentifierPart given that Java
* and Javascript follow similar identifier naming rules but we lose
* compatibility with the C-version.
*
* @param chr {@code char} to check
* @return {@code true} if the {@code chr} is a Javascript whitespace
* character; otherwise {@code false}
*/
public static boolean isJavascriptIdentifier(char chr) {
return ((chr >= 'a' && chr <= 'z')
|| (chr >= 'A' && chr <= 'Z')
|| (chr >= '0' && chr <= '9')
|| chr == '_' || chr == '$');
}
/**
* Determines if the input token provided is a valid token prefix to a
* javascript regular expression. The token argument is compared against
* a {@code Set} of identifiers that can precede a regular expression in the
* javascript grammar, and returns {@code true} if the provided
* {@code String} is in that {@code Set}.
*
* @param input the {@code String} token to check
* @return {@code true} iff the token is a valid prefix of a regexp
*/
public static boolean isJavascriptRegexpPrefix(String input) {
return REGEXP_TOKEN_PREFIXS.contains(input);
}
/**
* Encodes the specified character using Ascii for convenient insertion into
* a single-quote enclosed {@code String}. Printable characters
* are returned as-is. Carriage Return, Line Feed, Horizontal Tab,
* back-slash and single quote are all backslash-escaped. All other characters
* are returned hex-encoded.
*
* @param chr {@code char} to encode
* @return an Ascii-friendly encoding of the given {@code char}
*/
public static String encodeCharForAscii(char chr) {
if (chr == '\'') {
return "\\'";
} else if (chr == '\\') {
return "\\\\";
} else if (chr >= 32 && chr <= 126) {
return String.format("%c", chr);
} else if (chr == '\n') {
return "\\n";
} else if (chr == '\r') {
return "\\r";
} else if (chr == '\t') {
return "\\t";
} else {
// Cannot apply a precision specifier for integral types. Specifying
// 0-padded hex-encoding with minimum width of two.
return String.format("\\u%04x", (int)chr);
}
}
/**
* Parses the given {@code String} to determine if it contains a URL in the
* format followed by the {@code content} attribute of the {@code meta}
* HTML tag.
*
*
*
*
*
*
*
* @param value {@code String} to parse
* @return {@link HtmlUtils.META_REDIRECT_TYPE} indicating the presence
* of a URL in the given value
*/
public static META_REDIRECT_TYPE parseContentAttributeForUrl(String value) {
if (value == null)
return META_REDIRECT_TYPE.NONE;
Matcher matcher = META_REDIRECT_PATTERN.matcher(value);
if (!matcher.find())
return META_REDIRECT_TYPE.NONE;
// We have more content.
if (value.length() > matcher.end())
return META_REDIRECT_TYPE.URL;
return META_REDIRECT_TYPE.URL_START;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/util/EntityResolver.java 0000644 0001750 0001750 00000022055 11427052602 027110 0 ustar chris chris /*
* 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.streamhtmlparser.util;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import java.util.Map;
/**
*
* <meta http-equiv="refresh" content="5; URL=http://www.google.com">
*
*
* <meta http-equiv="refresh" content="5; URL=">
*
*
* <meta http-equiv="content-type" content="text/html">
*
* htmlparser.c. There are however a few intentional
* differences outlines below:
*
*
*
* processChar
* returns the output {@code String} whereas in Java, we return
* a status code and then provide the {@code String} in a separate
* method getEntity. It is cleaner as it avoids the
* need to return empty {@code String}s during incomplete processing.
*
*
*
* ⅆ where dd is a number in decimal (base 10) form.
* &x|Xyy; where yy is a hex-number (base 16).
* &<html-entity>; where
* <html-entity> is one of lt,
* gt, amp, quot or
* apos.
* reset method is provided to facilitate object re-use.
*/
public class EntityResolver {
/**
* Returned in processChar method.
*
*
*/
public enum Status {
NOT_STARTED("Not Started"),
IN_PROGRESS("In Progress"),
COMPLETED("Completed");
private final String message;
private Status(String message) {
this.message = message;
}
/**
* Returns a brief description of the {@code Status} for
* debugging purposes. The format of the returned {@code String}
* is not fully specified nor guaranteed to remain the same.
*/
@Override
public String toString() {
return message;
}
}
/**
* How many characters to store as we are processing an entity. Once we
* reach that size, we know the entity is definitely invalid. The size
* is higher than needed but keeping it as-is for compatibility with
* the C-version.
*/
private static final int MAX_ENTITY_SIZE = 10;
/**
* Map containing the recognized HTML entities and their decoded values.
* The trailing ';' is not included in the key but it is accounted for.
*/
private static final MapNOT_STARTED indicates we are still processing
* trailing characters before the start of an entity.
* The caller may want to save the characters it provided us.
* IN_PROGRESS indicates we are currently processing
* characters part of an entity.
* COMPLETED indicates we have finished processing
* an entity. The caller can then invoke getEntity
* then re-set the object for future re-use.
* StreamEntityResolver
* in a human readable form. The format of the returned String
* is not specified and is subject to change.
*
* @return full state of this object
*/
@Override
public String toString() {
return String.format("Status: %s; Contents (%d): %s", status.toString(),
sb.length(), sb.toString());
}
/**
* Returns the decoded HTML Entity. Should only be called
* after {@code processChar} returned status {@code COMPLETED}.
*
* @return the decoded HTML Entity or an empty {@code String} if
* we were called with any status other than {@code COMPLETED}
*/
public String getEntity() {
return entity;
}
/**
* Processes a character from the input stream and decodes any html entities
* from that processed input stream.
*
* @param input the {@code char} to process
* @return the processed {@code String}. Typically returns an empty
* {@code String} while awaiting for more characters to complete
* processing of the entity.
*/
public Status processChar(char input) {
// Developer error if the precondition fails.
Preconditions.checkState(status != Status.NOT_STARTED || sb.length() == 0);
if (status == Status.NOT_STARTED) {
if (input == '&') {
sb.append(input);
status = Status.IN_PROGRESS;
}
} else if (status == Status.IN_PROGRESS) {
if ((input == ';') || (HtmlUtils.isHtmlSpace(input))) {
status = Status.COMPLETED;
entity = convertEntity(input);
} else {
if (sb.length() < MAX_ENTITY_SIZE) {
sb.append(input);
} else {
status = Status.COMPLETED;
entity = uncovertedInput(input);
}
}
} else {
// Status.COMPLETED, ignore character, do nothing.
}
return status;
}
/**
* Performs the decoding of a complete HTML entity and saves the
* result back into the buffer.
*
* Numeric Character References
*
* @param terminator the last character read, unused on successful
* conversions since it is the end delimiter of the entity
* @return The decoded entity or the original input if we could not decode it.
*/
private String convertEntity(char terminator) {
// Developer error if the buffer was empty or does not start with '&'.
Preconditions.checkArgument(sb.length() > 0);
Preconditions.checkArgument(sb.charAt(0) == '&');
if (sb.length() > 1) {
if (sb.charAt(1) == '#') {
if (sb.length() <= 2) { // Error => return content as-is.
return uncovertedInput(terminator);
}
try {
if ((sb.charAt(2) == 'x') || (sb.charAt(2) == 'X')) { // Hex NCR
return new String(Character.toChars(
Integer.parseInt(sb.substring(3), 16)));
} else { // Decimal NCR
return new String(Character.toChars(
Integer.parseInt(sb.substring(2))));
}
} catch (NumberFormatException e) {
return uncovertedInput(terminator);
}
}
// See if it matches any of the few recognized entities.
String key = sb.toString();
if (HTML_ENTITIES_MAP.containsKey(key)) {
return HTML_ENTITIES_MAP.get(key);
}
}
// Covers the case of a lonely '&' given or valid/invalid unknown entities.
return uncovertedInput(terminator);
}
private String uncovertedInput(char terminator) {
return String.format("%s%c", sb.toString(), terminator);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/streamhtmlparser/HtmlParserFactory.java 0000644 0001750 0001750 00000027246 11427052602 026555 0 ustar chris chris /*
* 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.streamhtmlparser;
import com.google.streamhtmlparser.impl.HtmlParserImpl;
import java.util.Set;
import java.util.logging.Logger;
/**
* A factory class to obtain instances of an {@link HtmlParser}.
* Currently each instance is a new object given these are fairly
* light-weight.
*
*
* createParserInAttribute(HtmlParser.ATTR_TYPE.URI, true)}
*
*
*
*
*
* @throws ParseException if parsing failed.
*/
private static void initializeParsers() throws ParseException {
parserInDefaultAttr.parse("null if file not found.
* null if file not found.
*/
File locateFile(List
*
* In both cases, enclosing quotes are optional but parenthesis are not. This filter ensures that
* the URL cannot exit the parens enclosure, close a STYLE tag or reset the browser's CSS parser
* (via comments or newlines).
*
*
*
* @see BaseUrlValidateFunction
*/
public class CssUrlValidateFunction extends BaseUrlValidateFunction {
protected void applyEscaping(String in, Appendable out) throws IOException {
for (int i = 0; i < in.length(); i++) {
char ch = in.charAt(i);
switch (ch) {
case '\n':
out.append("%0A");
break;
case '\r':
out.append("%0D");
break;
case '"':
out.append("%22");
break;
case '\'':
out.append("%27");
break;
case '(':
out.append("%28");
break;
case ')':
out.append("%29");
break;
case '*':
out.append("%2A");
break;
case '<':
out.append("%3C");
break;
case '>':
out.append("%3E");
break;
case '\\':
out.append("%5C");
break;
default:
out.append(ch);
}
}
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/html/HtmlStripFunction.java 0000644 0001750 0001750 00000015410 11427052602 032136 0 ustar chris chris /*
* 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.functions.html;
import com.google.clearsilver.jsilver.functions.TextFilter;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* This class implements the html_strip function. It removes html tags from text, and expands
* numbered and named html entities to their corresponding special characters.
*/
public class HtmlStripFunction implements TextFilter {
// The maximum length of an entity (preceded by an &)
private static final int MAX_AMP_LENGTH = 9;
// The state the strip function can be, normal, in an amp escaped entity or
// inside a html tag.
private enum State {
DEFAULT, IN_AMP, IN_TAG
}
// Map of entity names to special characters.
private static final Map
\n";
case '\r':
return "";
default:
return null;
}
}
};
@Override
public void filter(String in, Appendable out) throws IOException {
boolean hasAsciiArt = hasAsciiArt(in);
// Add 'tt' tag to a string that contains 'ascii-art'.
if (hasAsciiArt) {
out.append("");
}
splitAndConvert(in, out);
if (hasAsciiArt) {
out.append("");
}
}
/**
* Splits the input string into blocks of normal text or linkable text. The linkable text is
* converted into anchor tags before being appended to the output. The normal text is escaped and
* appended to the output.
*/
private void splitAndConvert(String in, Appendable out) throws IOException {
Matcher matcher = LINKABLES.matcher(in);
int end = in.length();
int matchStart;
int matchEnd;
int regionStart = 0;
// Keep looking for email addresses and web links until there are none left.
while (matcher.find()) {
matchStart = matcher.start();
matchEnd = matcher.end();
// Escape all the text from the end of the previous match to the start of
// this match, and append it to the output.
htmlCharEscaper.filter(in.subSequence(regionStart, matchStart).toString(), out);
// Don't include a . or , in the text that is linked.
if (in.charAt(matchEnd - 1) == ',' || in.charAt(matchEnd - 1) == '.') {
matchEnd--;
}
if (matcher.group(EMAIL_GROUP) != null) {
formatEmail(in, matchStart, matchEnd, out);
} else {
formatUrl(in, matchStart, matchEnd,
// Add a scheme if the one wasn't found.
matcher.group(WITH_SCHEME_GROUP) == null, out);
}
regionStart = matchEnd;
}
// Escape the text after the last match, and append it to the output.
htmlCharEscaper.filter(in.substring(regionStart, end), out);
}
/**
* Formats the input sequence into a suitable mailto: anchor tag and appends it to the output.
*
* @param in The string that contains the email.
* @param start The start of the email address in the whole string.
* @param end The end of the email in the whole string.
* @param out The text output that the email address should be appended to.
* @throws IOException
*/
private void formatEmail(String in, int start, int end, Appendable out) throws IOException {
String emailPart = in.substring(start, end);
out.append("");
htmlEscaper.filter(emailPart, out);
out.append("");
}
/**
* Formats the input sequence into a suitable anchor tag and appends it to the output.
*
* @param in The string that contains the url.
* @param start The start of the url in the containing string.
* @param end The end of the url in the containing string.
* @param addScheme true if 'http://' should be added to the anchor.
* @param out The text output that the url should be appended to.
* @throws IOException
*/
private void formatUrl(String in, int start, int end, boolean addScheme, Appendable out)
throws IOException {
String urlPart = in.substring(start, end);
out.append(" ");
htmlEscaper.filter(urlPart, out);
out.append("");
}
/**
* Attempts to detect if a string contains ascii art, whitespace such as tabs will suppress ascii
* art detection.
*
* This method takes its conditions from ClearSilver to maintain compatibility. See
* has_space_formatting in html.c in the ClearSilver source.
*
* @param in The string to analyze for ascii art.
* @return true if it is believed that the string contains ascii art.
*/
private boolean hasAsciiArt(String in) {
int spaces = 0;
int returns = 0;
int asciiArt = 0;
int x = 0;
char[] inChars = in.toCharArray();
int length = in.length();
for (x = 0; x < length; x++) {
switch (inChars[x]) {
case '\t':
return false;
case '\r':
break;
case ' ':
// Ignore spaces after full stops.
if (x == 0 || inChars[x - 1] != '.') {
spaces++;
}
break;
case '\n':
spaces = 0;
returns++;
break;
// Characters to count towards the art total.
case '/':
case '\\':
case '<':
case '>':
case ':':
case '[':
case ']':
case '!':
case '@':
case '#':
case '$':
case '%':
case '^':
case '&':
case '*':
case '(':
case ')':
case '|':
asciiArt++;
if (asciiArt > 3) {
return true;
}
break;
default:
if (returns > 2) {
return false;
}
if (spaces > 2) {
return false;
}
returns = 0;
spaces = 0;
asciiArt = 0;
break;
}
}
return false;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/NonEscapingFunction.java 0000644 0001750 0001750 00000001425 11427052602 031451 0 ustar chris chris /*
* 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.functions;
public abstract class NonEscapingFunction implements Function {
@Override
public boolean isEscapingFunction() {
return false;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/Function.java 0000644 0001750 0001750 00000001714 11427052602 027325 0 ustar chris chris /*
* 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.functions;
import com.google.clearsilver.jsilver.values.Value;
/**
* Plugin for JSilver functions made available to templates. e.g <cs var:my_function(x, y) >
*/
public interface Function {
/**
* Execute a function. Should always return a result.
*/
Value execute(Value... args);
boolean isEscapingFunction();
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/string/ 0000755 0001750 0001750 00000000000 11767454572 026223 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/string/SliceFunction.java 0000644 0001750 0001750 00000003765 11427052602 031623 0 ustar chris chris /*
* 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.functions.string;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import static com.google.clearsilver.jsilver.values.Value.literalValue;
import static java.lang.Math.max;
import static java.lang.Math.min;
/**
* Returns the string slice starting at start and ending at end, similar to the Python slice
* operator.
*/
public class SliceFunction extends NonEscapingFunction {
/**
* @param args 1 string values then 2 numeric values (start and end).
* @return Sliced string
*/
public Value execute(Value... args) {
Value stringValue = args[0];
Value startValue = args[1];
Value endValue = args[2];
String string = stringValue.asString();
int start = startValue.asNumber();
int end = endValue.asNumber();
int length = string.length();
if (start < 0) {
start += max(-start, length);
if (end == 0) {
end = length;
}
}
if (end < 0) {
end += length;
}
end = min(end, length);
if (end < start) {
return literalConstant("", args[0]);
}
return literalValue(string.substring(start, end), stringValue.getEscapeMode(), stringValue
.isPartiallyEscaped()
|| startValue.isPartiallyEscaped() || endValue.isPartiallyEscaped());
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/string/CrcFunction.java 0000644 0001750 0001750 00000003417 11427052602 031265 0 ustar chris chris /*
* 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.functions.string;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import java.io.UnsupportedEncodingException;
import java.util.zip.CRC32;
import java.util.zip.Checksum;
/**
* Returns the CRC-32 of a string.
*/
public class CrcFunction extends NonEscapingFunction {
/**
* @param args 1 string expression
* @return CRC-32 of string as number value
*/
public Value execute(Value... args) {
String string = args[0].asString();
// This function produces a 'standard' CRC-32 (IV -1, reflected polynomial,
// and final complement step). The CRC-32 of "123456789" is 0xCBF43926.
Checksum crc = new CRC32();
byte[] b;
try {
b = string.getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
throw new AssertionError("UTF-8 must be supported");
}
crc.update(b, 0, b.length);
// Note that we need to cast to signed int, but that's okay because the
// CRC fits into 32 bits by definition.
return literalConstant((int) crc.getValue(), args[0]);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/string/LengthFunction.java 0000644 0001750 0001750 00000002245 11427052602 031775 0 ustar chris chris /*
* 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.functions.string;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* Returns the length of the string expression.
*/
public class LengthFunction extends NonEscapingFunction {
/**
* @param args A single string value
* @return Length as number value
*/
public Value execute(Value... args) {
Value value = args[0];
return literalConstant(value.asString().length(), value);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/string/FindFunction.java 0000644 0001750 0001750 00000002677 11427052602 031445 0 ustar chris chris /*
* 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.functions.string;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* Returns the numeric position of the substring in the string (if found), otherwise returns -1
* similar to the Python string.find method.
*/
public class FindFunction extends NonEscapingFunction {
/**
* @param args 2 string expressions (full string and substring)
* @return Position of the start of substring (or -1 if not found) as number value
*/
public Value execute(Value... args) {
Value fullStringValue = args[0];
Value subStringValue = args[1];
return literalConstant(fullStringValue.asString().indexOf(subStringValue.asString()),
fullStringValue, subStringValue);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/ 0000755 0001750 0001750 00000000000 11767454572 026733 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NotFunction.java 0000644 0001750 0001750 00000002036 11427052602 032022 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* !X.
*/
public class NotFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value value = args[0];
return literalConstant(!value.asBoolean(), value);
}
}
././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/GreaterOrEqualFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/GreaterOrEqualFunctio0000644 0001750 0001750 00000002141 11427052602 033043 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X >= Y.
*/
public class GreaterOrEqualFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() >= right.asNumber(), left, right);
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/LessOrEqualFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/LessOrEqualFunction.j0000644 0001750 0001750 00000002136 11427052602 032772 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X <= Y.
*/
public class LessOrEqualFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() <= right.asNumber(), left, right);
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NumericAddFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NumericAddFunction.ja0000644 0001750 0001750 00000002142 11427052602 032744 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X + Y (numeric).
*/
public class NumericAddFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() + right.asNumber(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/ModuloFunction.java 0000644 0001750 0001750 00000002124 11427052602 032517 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X % Y.
*/
public class ModuloFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() % right.asNumber(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/OrFunction.java 0000644 0001750 0001750 00000002124 11427052602 031640 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X || Y.
*/
public class OrFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asBoolean() || right.asBoolean(), left, right);
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/SubtractFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/SubtractFunction.java0000644 0001750 0001750 00000002343 11427052602 033052 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X - Y.
*/
public class SubtractFunction extends NonEscapingFunction {
public Value execute(Value... args) {
if (args.length == 1) {
Value value = args[0];
return literalConstant(0 - value.asNumber(), value);
} else {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() - right.asNumber(), left, right);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000151 00000000000 011562 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NumericEqualFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NumericEqualFunction.0000644 0001750 0001750 00000002146 11427052602 033014 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X == Y (numeric).
*/
public class NumericEqualFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() == right.asNumber(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/AddFunction.java 0000644 0001750 0001750 00000002447 11427052602 031760 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.autoescape.EscapeMode;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalValue;
/**
* X + Y (string).
*/
public class AddFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
EscapeMode mode = EscapeMode.combineModes(left.getEscapeMode(), right.getEscapeMode());
return literalValue(left.asString() + right.asString(), mode, left.isPartiallyEscaped()
|| right.isPartiallyEscaped());
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/AndFunction.java 0000644 0001750 0001750 00000002125 11427052602 031763 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X && Y.
*/
public class AndFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asBoolean() && right.asBoolean(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/GreaterFunction.java 0000644 0001750 0001750 00000002130 11427052602 032646 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X > Y.
*/
public class GreaterFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() > right.asNumber(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/ExistsFunction.java 0000644 0001750 0001750 00000002035 11427052602 032540 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* ?X.
*/
public class ExistsFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value value = args[0];
return literalConstant(value.exists(), value);
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NotEqualFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NotEqualFunction.java0000644 0001750 0001750 00000002121 11427052602 033005 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X != Y (string).
*/
public class NotEqualFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(!left.equals(right), left, right);
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/MultiplyFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/MultiplyFunction.java0000644 0001750 0001750 00000002126 11427052602 033101 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X * Y.
*/
public class MultiplyFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() * right.asNumber(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/DivideFunction.java 0000644 0001750 0001750 00000002124 11427052602 032464 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X / Y.
*/
public class DivideFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() / right.asNumber(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/EqualFunction.java 0000644 0001750 0001750 00000002115 11427052602 032327 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X == Y (string).
*/
public class EqualFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.equals(right), left, right);
}
}
././@LongLink 0000000 0000000 0000000 00000000154 00000000000 011565 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NumericNotEqualFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NumericNotEqualFuncti0000644 0001750 0001750 00000002151 11427052602 033056 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X != Y (numeric).
*/
public class NumericNotEqualFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() != right.asNumber(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/LessFunction.java 0000644 0001750 0001750 00000002125 11427052602 032167 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* X < Y.
*/
public class LessFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(left.asNumber() < right.asNumber(), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/operators/NumericFunction.java 0000644 0001750 0001750 00000002106 11427052602 032662 0 ustar chris chris /*
* 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.functions.operators;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
/**
* #X (numeric). Forces a value to a number.
*/
public class NumericFunction extends NonEscapingFunction {
public Value execute(Value... args) {
Value value = args[0];
return literalConstant(value.asNumber(), value);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/ 0000755 0001750 0001750 00000000000 11767454572 026155 5 ustar chris chris ././@LongLink 0000000 0000000 0000000 00000000153 00000000000 011564 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/JsValidateUnquotedLiteral.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/JsValidateUnquotedLitera0000644 0001750 0001750 00000004436 11427052602 033000 0 ustar chris chris /*
* 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.functions.escape;
import com.google.clearsilver.jsilver.functions.TextFilter;
import java.io.IOException;
/**
* This function will be used to sanitize variables introduced into javascript that are not string
* literals. e.g.
*
* Currently it only accepts boolean and numeric literals. All other values are replaced with a
* 'null'. This behavior may be extended if required at a later time. This replicates the
* autoescaping behavior of Clearsilver.
*/
public class JsValidateUnquotedLiteral implements TextFilter {
public void filter(String in, Appendable out) throws IOException {
/* Permit boolean literals */
if (in.equals("true") || in.equals("false")) {
out.append(in);
return;
}
boolean valid = true;
if (in.startsWith("0x") || in.startsWith("0X")) {
/*
* There must be at least one hex digit after the 0x for it to be valid. Hex number. Check
* that it is of the form 0(x|X)[0-9A-Fa-f]+
*/
for (int i = 2; i < in.length(); i++) {
char c = in.charAt(i);
if (!((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F') || (c >= '0' && c <= '9'))) {
valid = false;
break;
}
}
} else {
/*
* Must be a base-10 (or octal) number. Check that it has the form [0-9+-.eE]+
*/
for (int i = 0; i < in.length(); i++) {
char c = in.charAt(i);
if (!((c >= '0' && c <= '9') || c == '+' || c == '-' || c == '.' || c == 'e' || c == 'E')) {
valid = false;
break;
}
}
}
if (valid) {
out.append(in);
} else {
out.append("null");
}
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/StyleEscapeFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/StyleEscapeFunction.java0000644 0001750 0001750 00000005616 11427052602 032734 0 ustar chris chris /*
* 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.functions.escape;
import com.google.clearsilver.jsilver.functions.TextFilter;
import java.io.IOException;
/**
* This function will be used to sanitize variables in 'style' attributes. It strips out any
* characters that are not part of a whitelist of safe characters. This replicates the autoescaping
* behavior of Clearsilver.
*
* It does not extend SimpleEscapingFunction because SimpleEscapingFunction requires a blacklist of
* characters to escape. The StyleAttrEscapeFunction instead applies a whitelist, and strips out any
* characters not in the whitelist.
*/
public class StyleEscapeFunction implements TextFilter {
private static final boolean[] UNQUOTED_VALID_CHARS;
private static final boolean[] VALID_CHARS;
private static final int MAX_CHARS = 0x80;
static {
// Allow characters likely to occur inside a style property value.
// Refer http://www.w3.org/TR/CSS21/ for more details.
String SPECIAL_CHARS = "_.,!#%- ";
String UNQUOTED_SPECIAL_CHARS = "_.,!#%-";
VALID_CHARS = new boolean[MAX_CHARS];
UNQUOTED_VALID_CHARS = new boolean[MAX_CHARS];
for (int n = 0; n < MAX_CHARS; n++) {
VALID_CHARS[n] = false;
UNQUOTED_VALID_CHARS[n] = false;
if (Character.isLetterOrDigit(n)) {
VALID_CHARS[n] = true;
UNQUOTED_VALID_CHARS[n] = true;
} else {
if (SPECIAL_CHARS.indexOf(n) != -1) {
VALID_CHARS[n] = true;
}
if (UNQUOTED_SPECIAL_CHARS.indexOf(n) != -1) {
UNQUOTED_VALID_CHARS[n] = true;
}
}
}
}
private final boolean[] validChars;
/**
* isUnquoted should be true if the function is escaping a string that will appear inside an
* unquoted style attribute.
*
*/
public StyleEscapeFunction(boolean isUnquoted) {
if (isUnquoted) {
validChars = UNQUOTED_VALID_CHARS;
} else {
validChars = VALID_CHARS;
}
}
public void filter(String in, Appendable out) throws IOException {
for (char c : in.toCharArray()) {
if (c < MAX_CHARS && validChars[c]) {
out.append(c);
} else if (c >= MAX_CHARS) {
out.append(c);
}
}
}
public void dumpInfo() {
for (int i = 0; i < MAX_CHARS; i++) {
System.out.println(i + "(" + (char) i + ")" + " :" + VALID_CHARS[i]);
}
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/NullEscapeFunction.java 0000644 0001750 0001750 00000002121 11427052602 032532 0 ustar chris chris /*
* 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.functions.escape;
import com.google.clearsilver.jsilver.functions.TextFilter;
import java.io.IOException;
/**
* Returns the input string without any modification.
*
* This function is intended to be registered as an {@code EscapingFunction} so that it can be used
* to disable autoescaping of expressions.
*/
public class NullEscapeFunction implements TextFilter {
public void filter(String in, Appendable out) throws IOException {
out.append(in);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/JsEscapeFunction.java 0000644 0001750 0001750 00000004545 11427052602 032210 0 ustar chris chris /*
* 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.functions.escape;
/**
* This Javascript escapes the string so it will be valid data for placement into a Javascript
* string. This converts characters such as ", ', and \ into their Javascript string safe
* equivilants \", \', and \\.
*
* This behaves in the same way as the ClearSilver js_escape function.
*
* This implementation has been optimized for performance.
*/
public class JsEscapeFunction extends SimpleEscapingFunction {
private static final char[] DIGITS = "0123456789ABCDEF".toCharArray();
private static final char[] ESCAPE_CHARS;
private static final char[] UNQUOTED_ESCAPE_CHARS;
static {
char[] SPECIAL_CHARS = {'/', '"', '\'', '\\', '>', '<', '&', ';'};
char[] UNQUOTED_SPECIAL_CHARS = {'/', '"', '\'', '\\', '>', '<', '&', ';', '=', ' '};
ESCAPE_CHARS = new char[32 + SPECIAL_CHARS.length];
UNQUOTED_ESCAPE_CHARS = new char[33 + UNQUOTED_SPECIAL_CHARS.length];
for (int n = 0; n < 32; n++) {
ESCAPE_CHARS[n] = (char) n;
UNQUOTED_ESCAPE_CHARS[n] = (char) n;
}
System.arraycopy(SPECIAL_CHARS, 0, ESCAPE_CHARS, 32, SPECIAL_CHARS.length);
UNQUOTED_ESCAPE_CHARS[32] = 0x7F;
System.arraycopy(UNQUOTED_SPECIAL_CHARS, 0, UNQUOTED_ESCAPE_CHARS, 33,
UNQUOTED_SPECIAL_CHARS.length);
}
/**
* isUnquoted should be true if the function is escaping a string that will appear inside an
* unquoted JS attribute (like onClick or onMouseover).
*
*/
public JsEscapeFunction(boolean isAttrUnquoted) {
if (isAttrUnquoted) {
super.setEscapeChars(UNQUOTED_ESCAPE_CHARS);
} else {
super.setEscapeChars(ESCAPE_CHARS);
}
}
@Override
protected String getEscapeString(char c) {
return "\\x" + DIGITS[(c >> 4) & 0xF] + DIGITS[c & 0xF];
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/UrlEscapeFunction.java 0000644 0001750 0001750 00000003563 11427052602 032375 0 ustar chris chris /*
* 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.functions.escape;
import com.google.clearsilver.jsilver.functions.TextFilter;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
/**
* This URL encodes the string. This converts characters such as ?, ampersands, and = into their URL
* safe equivilants using the %hh syntax.
*/
public class UrlEscapeFunction implements TextFilter {
private final String encoding;
public UrlEscapeFunction(String encoding) {
try {
// Sanity check. Fail at construction time rather than render time.
new OutputStreamWriter(new ByteArrayOutputStream(), encoding);
} catch (UnsupportedEncodingException e) {
throw new IllegalArgumentException("Unsupported encoding : " + encoding);
}
this.encoding = encoding;
}
@Override
public void filter(String in, Appendable out) throws IOException {
try {
out.append(URLEncoder.encode(in, encoding));
} catch (UnsupportedEncodingException e) {
// The sanity check in the constructor should have caught this.
// Things must be really broken for this to happen, so throw an Error.
throw new Error("Unsuported encoding : " + encoding);
}
}
}
././@LongLink 0000000 0000000 0000000 00000000150 00000000000 011561 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/SimpleEscapingFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/SimpleEscapingFunction.j0000644 0001750 0001750 00000007403 11427052602 032722 0 ustar chris chris /*
* 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.functions.escape;
import com.google.clearsilver.jsilver.functions.TextFilter;
import java.io.IOException;
/**
* Base class to make writing fast, simple escaping functions easy. A simple escaping function is
* one where each character in the input is treated independently and there is no runtime state. The
* only decision you make is whether the current character should be escaped into some different
* string or not.
*
* The only serious limitation on using this class it that only low valued characters can be
* escaped. This is because (for speed) we use an array of escaped strings, indexed by character
* value. In future this limitation may be lifted if there's a call for it.
*/
public abstract class SimpleEscapingFunction implements TextFilter {
// The limit for how many strings we can store here (max)
private static final int CHAR_INDEX_LIMIT = 256;
// Our fast lookup array of escaped strings. This array is indexed by char
// value so it's important not to have it grow too large. For now we have
// an artificial limit on it.
private String[] ESCAPE_STRINGS;
/**
* Creates an instance to escape the given set of characters.
*/
protected SimpleEscapingFunction(char[] ESCAPE_CHARS) {
setEscapeChars(ESCAPE_CHARS);
}
protected SimpleEscapingFunction() {
ESCAPE_STRINGS = new String[0];
}
protected void setEscapeChars(char[] ESCAPE_CHARS) throws AssertionError {
int highestChar = -1;
for (char c : ESCAPE_CHARS) {
if (c > highestChar) {
highestChar = c;
}
}
if (highestChar >= CHAR_INDEX_LIMIT) {
throw new AssertionError("Cannot escape characters with values above " + CHAR_INDEX_LIMIT);
}
ESCAPE_STRINGS = new String[highestChar + 1];
for (char c : ESCAPE_CHARS) {
ESCAPE_STRINGS[c] = getEscapeString(c);
}
}
/**
* Given one of the escape characters supplied to this instance's constructor, return the escape
* string for it. This method does not need to be efficient.
*/
protected abstract String getEscapeString(char c);
/**
* Algorithm is as follows:
*
*
*/
@Override
public void filter(String in, Appendable out) throws IOException {
final int len = in.length();
int pos = 0;
int start = pos;
while (pos < len) {
// We really hope that the hotspot compiler inlines this call properly
// (without optimization it accounts for > 50% of the time in this call)
final char chr = in.charAt(pos);
final String escapeString;
if (chr < ESCAPE_STRINGS.length && (escapeString = ESCAPE_STRINGS[chr]) != null) {
// We really hope our appendable handles sub-strings nicely
// (we know that StringBuilder / StringBuffer does).
if (pos > start) {
out.append(in, start, pos);
}
out.append(escapeString);
pos += 1;
start = pos;
continue;
}
pos += 1;
}
if (pos > start) {
out.append(in, start, pos);
}
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/escape/HtmlEscapeFunction.java 0000644 0001750 0001750 00000006406 11427052602 032536 0 ustar chris chris /*
* 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.functions.escape;
/**
* This class HTML escapes a string in the same way as the ClearSilver html_escape function.
*
* This implementation has been optimized for performance.
*
*/
public class HtmlEscapeFunction extends SimpleEscapingFunction {
// The escape chars
private static final char[] ESCAPE_CHARS = {'<', '>', '&', '\'', '"'};
// UNQUOTED_ESCAPE_CHARS = ESCAPE_CHARS + UNQUOTED_EXTRA_CHARS + chars < 0x20 + 0x7f
private static final char[] UNQUOTED_ESCAPE_CHARS;
private static final char[] UNQUOTED_EXTRA_CHARS = {'=', ' '};
// The corresponding escape strings for all ascii characters.
// With control characters, we simply strip them out if necessary.
private static String[] ESCAPE_CODES =
{"", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
"", "", "", "", "", "", "", "", "", "", "!", """, "#", "$", "%", "&", "'",
"(", ")", "*", "+", ",", "-", ".", "/", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
":", ";", "<", "=", ">", "?", "@", "A", "B", "C", "D", "E", "F", "G", "H", "I",
"J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[",
"\\", "]", "^", "_", "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l",
"m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~",
""};
static {
UNQUOTED_ESCAPE_CHARS = new char[33 + ESCAPE_CHARS.length + UNQUOTED_EXTRA_CHARS.length];
// In unquoted HTML attributes, strip out control characters also, as they could
// get interpreted as end of attribute, just like spaces.
for (int n = 0; n <= 0x1f; n++) {
UNQUOTED_ESCAPE_CHARS[n] = (char) n;
}
UNQUOTED_ESCAPE_CHARS[32] = (char) 0x7f;
System.arraycopy(ESCAPE_CHARS, 0, UNQUOTED_ESCAPE_CHARS, 33, ESCAPE_CHARS.length);
System.arraycopy(UNQUOTED_EXTRA_CHARS, 0, UNQUOTED_ESCAPE_CHARS, 33 + ESCAPE_CHARS.length,
UNQUOTED_EXTRA_CHARS.length);
}
/**
* isUnquoted should be true if the function is escaping a string that will appear inside an
* unquoted HTML attribute.
*
* If the string is unquoted, we strip out all characters 0 - 0x1f and 0x7f for security reasons.
*/
public HtmlEscapeFunction(boolean isUnquoted) {
if (isUnquoted) {
super.setEscapeChars(UNQUOTED_ESCAPE_CHARS);
} else {
super.setEscapeChars(ESCAPE_CHARS);
}
}
@Override
protected String getEscapeString(char c) {
if (c < 0x80) {
return ESCAPE_CODES[c];
}
throw new IllegalArgumentException("Unexpected escape character " + c + "[" + (int) c + "]");
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/EscapingFunction.java 0000644 0001750 0001750 00000001421 11427052602 030772 0 ustar chris chris /*
* 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.functions;
public abstract class EscapingFunction implements Function {
@Override
public boolean isEscapingFunction() {
return true;
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/numeric/ 0000755 0001750 0001750 00000000000 11767454572 026357 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/numeric/MinFunction.java 0000644 0001750 0001750 00000002355 11427052602 031435 0 ustar chris chris /*
* 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.functions.numeric;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import static java.lang.Math.min;
/**
* Returns the smaller of two numeric expressions.
*/
public class MinFunction extends NonEscapingFunction {
/**
* @param args Two numeric values
* @return Smallest of these
*/
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(min(left.asNumber(), right.asNumber()), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/numeric/MaxFunction.java 0000644 0001750 0001750 00000002354 11427052602 031436 0 ustar chris chris /*
* 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.functions.numeric;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import static java.lang.Math.max;
/**
* Returns the larger of two numeric expressions.
*/
public class MaxFunction extends NonEscapingFunction {
/**
* @param args Two numeric values
* @return Largest of these
*/
public Value execute(Value... args) {
Value left = args[0];
Value right = args[1];
return literalConstant(max(left.asNumber(), right.asNumber()), left, right);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/numeric/AbsFunction.java 0000644 0001750 0001750 00000002275 11427052602 031420 0 ustar chris chris /*
* 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.functions.numeric;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import static java.lang.Math.abs;
/**
* Returns the absolute value of the numeric expressions.
*/
public class AbsFunction extends NonEscapingFunction {
/**
* @param args Single numeric value
* @return Absolute value
*/
public Value execute(Value... args) {
Value arg = args[0];
return literalConstant(abs(arg.asNumber()), arg);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/structure/ 0000755 0001750 0001750 00000000000 11767454572 026755 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/structure/NameFunction.java 0000644 0001750 0001750 00000003231 11427052602 032162 0 ustar chris chris /*
* 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.functions.structure;
import com.google.clearsilver.jsilver.data.Data;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import static com.google.clearsilver.jsilver.values.Value.literalValue;
import com.google.clearsilver.jsilver.values.VariableValue;
/**
* Returns the Data variable name for a local variable alias.
*/
public class NameFunction extends NonEscapingFunction {
/**
* @param args A local variable
* @return Name (as string)
*/
public Value execute(Value... args) {
Value value = args[0];
if (value instanceof VariableValue) {
VariableValue variableValue = (VariableValue) value;
Data variable = variableValue.getReference();
if (variable != null) {
return literalValue(variable.getSymlink().getName(), variableValue.getEscapeMode(),
variableValue.isPartiallyEscaped());
}
}
return literalConstant("", value);
}
}
././@LongLink 0000000 0000000 0000000 00000000145 00000000000 011565 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/structure/SubcountFunction.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/structure/SubcountFunction.java0000644 0001750 0001750 00000002715 11427052602 033112 0 ustar chris chris /*
* 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.functions.structure;
import com.google.clearsilver.jsilver.data.Data;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import com.google.clearsilver.jsilver.values.VariableValue;
/**
* Returns the number of child nodes for the HDF variable.
*/
public class SubcountFunction extends NonEscapingFunction {
/**
* @param args A variable value referring to an HDF node
* @return Number of children
*/
public Value execute(Value... args) {
VariableValue arg = (VariableValue) args[0];
if (arg.getReference() == null) {
return literalConstant(0, arg);
}
Data thisNode = arg.getReference().getSymlink();
return literalConstant(thisNode.getChildCount(), arg);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/structure/FirstFunction.java 0000644 0001750 0001750 00000002676 11427052602 032405 0 ustar chris chris /*
* 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.functions.structure;
import com.google.clearsilver.jsilver.data.Data;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import com.google.clearsilver.jsilver.values.VariableValue;
/**
* Returns true if the local variable is the first in a loop or each.
*/
public class FirstFunction extends NonEscapingFunction {
/**
* @param args A local variable.
* @return Boolean value.
*/
public Value execute(Value... args) {
VariableValue arg = (VariableValue) args[0];
if (arg.getReference() == null) {
return literalConstant(false, arg);
}
Data thisNode = arg.getReference().getSymlink();
return literalConstant(thisNode.isFirstSibling(), arg);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/structure/LastFunction.java 0000644 0001750 0001750 00000002673 11427052602 032216 0 ustar chris chris /*
* 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.functions.structure;
import com.google.clearsilver.jsilver.data.Data;
import com.google.clearsilver.jsilver.functions.NonEscapingFunction;
import com.google.clearsilver.jsilver.values.Value;
import static com.google.clearsilver.jsilver.values.Value.literalConstant;
import com.google.clearsilver.jsilver.values.VariableValue;
/**
* Returns true if the local variable is the last in a loop or each.
*/
public class LastFunction extends NonEscapingFunction {
/**
* @param args A local variable.
* @return Boolean value.
*/
public Value execute(Value... args) {
VariableValue arg = (VariableValue) args[0];
if (arg.getReference() == null) {
return literalConstant(false, arg);
}
Data thisNode = arg.getReference().getSymlink();
return literalConstant(thisNode.isLastSibling(), arg);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/bundles/ 0000755 0001750 0001750 00000000000 11767454572 026351 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/bundles/CoreOperators.java 0000644 0001750 0001750 00000007137 11427052602 031770 0 ustar chris chris /*
* 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.functions.bundles;
import com.google.clearsilver.jsilver.functions.FunctionRegistry;
import com.google.clearsilver.jsilver.functions.operators.AddFunction;
import com.google.clearsilver.jsilver.functions.operators.AndFunction;
import com.google.clearsilver.jsilver.functions.operators.DivideFunction;
import com.google.clearsilver.jsilver.functions.operators.EqualFunction;
import com.google.clearsilver.jsilver.functions.operators.ExistsFunction;
import com.google.clearsilver.jsilver.functions.operators.GreaterFunction;
import com.google.clearsilver.jsilver.functions.operators.GreaterOrEqualFunction;
import com.google.clearsilver.jsilver.functions.operators.LessFunction;
import com.google.clearsilver.jsilver.functions.operators.LessOrEqualFunction;
import com.google.clearsilver.jsilver.functions.operators.ModuloFunction;
import com.google.clearsilver.jsilver.functions.operators.MultiplyFunction;
import com.google.clearsilver.jsilver.functions.operators.NotEqualFunction;
import com.google.clearsilver.jsilver.functions.operators.NotFunction;
import com.google.clearsilver.jsilver.functions.operators.NumericAddFunction;
import com.google.clearsilver.jsilver.functions.operators.NumericEqualFunction;
import com.google.clearsilver.jsilver.functions.operators.NumericFunction;
import com.google.clearsilver.jsilver.functions.operators.NumericNotEqualFunction;
import com.google.clearsilver.jsilver.functions.operators.OrFunction;
import com.google.clearsilver.jsilver.functions.operators.SubtractFunction;
import com.google.clearsilver.jsilver.functions.structure.NameFunction;
/**
* Function registry containing core operators used in expressions.
*
* These are: + - * / % ? ! && || == != < > <= >=, name.
*
* @see FunctionRegistry
*/
public class CoreOperators extends FunctionRegistry {
@Override
protected void setupDefaultFunctions() {
super.setupDefaultFunctions();
registerFunction("+", new AddFunction());
registerFunction("#+", new NumericAddFunction());
registerFunction("-", new SubtractFunction());
registerFunction("*", new MultiplyFunction());
registerFunction("/", new DivideFunction());
registerFunction("%", new ModuloFunction());
registerFunction("?", new ExistsFunction());
registerFunction("!", new NotFunction());
registerFunction("&&", new AndFunction());
registerFunction("||", new OrFunction());
registerFunction("==", new EqualFunction());
registerFunction("#==", new NumericEqualFunction());
registerFunction("!=", new NotEqualFunction());
registerFunction("#!=", new NumericNotEqualFunction());
registerFunction("<", new LessFunction());
registerFunction(">", new GreaterFunction());
registerFunction("<=", new LessOrEqualFunction());
registerFunction(">=", new GreaterOrEqualFunction());
registerFunction("#", new NumericFunction());
// Not an operator, but JSilver cannot function without as it's used by
// the command.
registerFunction("name", new NameFunction());
}
}
././@LongLink 0000000 0000000 0000000 00000000161 00000000000 011563 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/bundles/ClearSilverCompatibleFunctions.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/bundles/ClearSilverCompatibleFu0000644 0001750 0001750 00000010547 11427052602 032766 0 ustar chris chris /*
* 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.functions.bundles;
import com.google.clearsilver.jsilver.functions.escape.*;
import com.google.clearsilver.jsilver.functions.html.CssUrlValidateFunction;
import com.google.clearsilver.jsilver.functions.html.HtmlStripFunction;
import com.google.clearsilver.jsilver.functions.html.HtmlUrlValidateFunction;
import com.google.clearsilver.jsilver.functions.html.TextHtmlFunction;
import com.google.clearsilver.jsilver.functions.numeric.AbsFunction;
import com.google.clearsilver.jsilver.functions.numeric.MaxFunction;
import com.google.clearsilver.jsilver.functions.numeric.MinFunction;
import com.google.clearsilver.jsilver.functions.string.CrcFunction;
import com.google.clearsilver.jsilver.functions.string.FindFunction;
import com.google.clearsilver.jsilver.functions.string.LengthFunction;
import com.google.clearsilver.jsilver.functions.string.SliceFunction;
import com.google.clearsilver.jsilver.functions.structure.FirstFunction;
import com.google.clearsilver.jsilver.functions.structure.LastFunction;
import com.google.clearsilver.jsilver.functions.structure.SubcountFunction;
/**
* Set of functions required to allow JSilver to be compatible with ClearSilver.
*/
public class ClearSilverCompatibleFunctions extends CoreOperators {
@Override
protected void setupDefaultFunctions() {
super.setupDefaultFunctions();
// Structure functions.
registerFunction("subcount", new SubcountFunction());
registerFunction("first", new FirstFunction());
registerFunction("last", new LastFunction());
// Deprecated - but here for ClearSilver compatibility.
registerFunction("len", new SubcountFunction());
// Numeric functions.
registerFunction("abs", new AbsFunction());
registerFunction("max", new MaxFunction());
registerFunction("min", new MinFunction());
// String functions.
registerFunction("string.slice", new SliceFunction());
registerFunction("string.find", new FindFunction());
registerFunction("string.length", new LengthFunction());
registerFunction("string.crc", new CrcFunction());
// Escaping functions.
registerFunction("url_escape", new UrlEscapeFunction("UTF-8"), true);
registerEscapeMode("url", new UrlEscapeFunction("UTF-8"));
registerFunction("html_escape", new HtmlEscapeFunction(false), true);
registerEscapeMode("html", new HtmlEscapeFunction(false));
registerFunction("js_escape", new JsEscapeFunction(false), true);
registerEscapeMode("js", new JsEscapeFunction(false));
// These functions are available as arguments to
// though they aren't in ClearSilver. This is so that auto escaping
// can automatically add nodes with these modes
registerEscapeMode("html_unquoted", new HtmlEscapeFunction(true));
registerEscapeMode("js_attr_unquoted", new JsEscapeFunction(true));
registerEscapeMode("js_check_number", new JsValidateUnquotedLiteral());
registerEscapeMode("url_validate_unquoted", new HtmlUrlValidateFunction(true));
registerEscapeMode("css", new StyleEscapeFunction(false));
registerEscapeMode("css_unquoted", new StyleEscapeFunction(true));
// HTML functions.
registerFunction("html_strip", new HtmlStripFunction());
registerFunction("text_html", new TextHtmlFunction());
// url_validate is available as an argument to
// though it isn't in ClearSilver.
registerFunction("url_validate", new HtmlUrlValidateFunction(false), true);
registerEscapeMode("url_validate", new HtmlUrlValidateFunction(false));
registerFunction("css_url_validate", new CssUrlValidateFunction(), true);
// Register as an EscapingFunction so that autoescaping will be disabled
// for the output of this function.
registerFunction("null_escape", new NullEscapeFunction(), true);
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/functions/FunctionRegistry.java 0000644 0001750 0001750 00000011120 11427052602 031046 0 ustar chris chris /*
* 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.functions;
import com.google.clearsilver.jsilver.autoescape.EscapeMode;
import com.google.clearsilver.jsilver.exceptions.JSilverInterpreterException;
import com.google.clearsilver.jsilver.values.Value;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
/**
* Simple implementation of FunctionFinder that you can register your own functions with.
*
* @see FunctionExecutor
*/
public class FunctionRegistry implements FunctionExecutor {
protected Map
*
* It also strips out empty lines and leading whitespace inside HTML tags (i.e.
* between '<' and '>') and inside SCRIPT elements. It leaves trailing
* whitespace since that is more costly to remove and tends to not be common
* based on how templates are created (they don't have trailing whitespace).
* tags
private int preScope = 0;
// Are we between verbatim flags
private int verbatimScope = 0;
// Are we between
return AutoEscapeState.JS;
} else {
//
// No quotes around the variable, hence it can inject arbitrary javascript.
// So severely restrict the values it may contain.
return AutoEscapeState.JS_UNQUOTED;
}
}
// Inside an HTML tag or attribute name
if (state.equals(HtmlParser.STATE_ATTR) || state.equals(HtmlParser.STATE_TAG)) {
return AutoEscapeState.ATTR;
// TODO: Need a strict validation function for tag and attribute names.
} else if (state.equals(HtmlParser.STATE_VALUE)) {
// Inside an HTML attribute value
return getCurrentAttributeState();
} else if (state.equals(HtmlParser.STATE_COMMENT) || state.equals(HtmlParser.STATE_TEXT)) {
// Default is assumed to be HTML body
// Hello :
return AutoEscapeState.HTML;
}
throw new JSilverAutoEscapingException("Invalid state received from HtmlParser: "
+ state.toString(), resourceName, htmlParser.getLineNumber(), htmlParser.getColumnNumber());
}
private AutoEscapeState getCurrentAttributeState() {
HtmlParser.ATTR_TYPE type = htmlParser.getAttributeType();
boolean attrQuoted = htmlParser.isAttributeQuoted();
switch (type) {
case REGULAR:
// :
if (attrQuoted) {
return AutoEscapeState.ATTR;
} else {
return AutoEscapeState.UNQUOTED_ATTR;
}
case URI:
if (htmlParser.isUrlStart()) {
//
if (attrQuoted) {
return AutoEscapeState.ATTR_URI_START;
} else {
return AutoEscapeState.UNQUOTED_ATTR_URI_START;
}
} else {
//
if (attrQuoted) {
// TODO: Html escaping because that is what Clearsilver does right now.
// May change this to url escaping soon.
return AutoEscapeState.ATTR_URI;
} else {
return AutoEscapeState.UNQUOTED_ATTR_URI;
}
}
case JS:
if (htmlParser.isJavascriptQuoted()) {
/*
* Note: js_escape() hex encodes all html metacharacters. Therefore it is safe to not do
* an HTML escape around this.
*/
if (attrQuoted) {
//
return AutoEscapeState.ATTR_JS;
} else {
// ');>
return AutoEscapeState.UNQUOTED_ATTR_JS;
}
} else {
if (attrQuoted) {
/* */
return AutoEscapeState.ATTR_UNQUOTED_JS;
} else {
/* );> */
return AutoEscapeState.UNQUOTED_ATTR_UNQUOTED_JS;
}
}
case STYLE:
// :
if (attrQuoted) {
return AutoEscapeState.ATTR_CSS;
} else {
return AutoEscapeState.UNQUOTED_ATTR_CSS;
}
default:
throw new JSilverAutoEscapingException("Invalid attribute type in HtmlParser: " + type,
resourceName, htmlParser.getLineNumber(), htmlParser.getColumnNumber());
}
}
/**
* Resets the state of the underlying html parser to a state consistent with the {@code
* contentType} provided. This method should be used when the starting auto escaping context of a
* resource cannot be determined from its contents - for example, a CSS stylesheet or a javascript
* source file.
*
* @param contentType MIME type header representing the content being parsed.
* @see #CONTENT_TYPE_LIST
*/
public void setContentType(String contentType) {
HtmlParser.Mode mode = CONTENT_TYPE_LIST.get(contentType);
if (mode == null) {
throw new JSilverAutoEscapingException("Invalid content type specified: " + contentType,
resourceName, htmlParser.getLineNumber(), htmlParser.getColumnNumber());
}
htmlParser.resetMode(mode);
}
/**
* Enum representing states of the data being parsed.
*
* This enumeration lists all the states in which autoescaping would have some effect.
*
*/
public static enum AutoEscapeState {
HTML("html", ESCAPE_AUTO_HTML), JS("js", ESCAPE_AUTO_JS), STYLE("css", ESCAPE_AUTO_STYLE), JS_UNQUOTED(
"js_check_number", ESCAPE_AUTO_JS_UNQUOTED), ATTR("html", ESCAPE_AUTO_ATTR), UNQUOTED_ATTR(
"html_unquoted", ESCAPE_AUTO_UNQUOTED_ATTR), ATTR_URI("html", ESCAPE_AUTO_ATTR_URI), UNQUOTED_ATTR_URI(
"html_unquoted", ESCAPE_AUTO_UNQUOTED_ATTR_URI), ATTR_URI_START("url_validate",
ESCAPE_AUTO_ATTR_URI_START), UNQUOTED_ATTR_URI_START("url_validate_unquoted",
ESCAPE_AUTO_UNQUOTED_ATTR_URI_START), ATTR_JS("js", ESCAPE_AUTO_ATTR_JS), ATTR_UNQUOTED_JS(
"js_check_number", ESCAPE_AUTO_ATTR_UNQUOTED_JS), UNQUOTED_ATTR_JS("js_attr_unquoted",
ESCAPE_AUTO_UNQUOTED_ATTR_JS), UNQUOTED_ATTR_UNQUOTED_JS("js_check_number",
ESCAPE_AUTO_UNQUOTED_ATTR_UNQUOTED_JS), ATTR_CSS("css", ESCAPE_AUTO_ATTR_CSS), UNQUOTED_ATTR_CSS(
"css_unquoted", ESCAPE_AUTO_UNQUOTED_ATTR_CSS);
private final String functionName;
private final EscapeMode escapeMode;
private AutoEscapeState(String functionName, EscapeMode mode) {
this.functionName = functionName;
this.escapeMode = mode;
}
public String getFunctionName() {
return functionName;
}
public EscapeMode getEscapeMode() {
return escapeMode;
}
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/ 0000755 0001750 0001750 00000000000 11767454572 025723 5 ustar chris chris jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/ResourceLoader.java 0000644 0001750 0001750 00000007403 11427052602 031465 0 ustar chris chris /*
* 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.resourceloader;
import com.google.clearsilver.jsilver.exceptions.JSilverTemplateNotFoundException;
import java.io.IOException;
import java.io.Reader;
/**
* Loads resources, from somewhere.
*
* This is a service provider interface (SPI) for JSilver. Users of JSilver can easily create their
* own implementations. However, it is recommended that new implementations don't implement this
* interface directly, but instead extends {@link BaseResourceLoader}. This allows API changes to be
* made to JSilver that maintain compatibility with existing ResourceLoader implementations.
*
* @see BaseResourceLoader
* @see InMemoryResourceLoader
* @see FileSystemResourceLoader
* @see ClassLoaderResourceLoader
* @see ClassResourceLoader
*/
public interface ResourceLoader {
/**
* Open a resource. If this resource is not found, null should be returned.
*
* The caller of this method is guaranteed to call {@link #close(Reader)} when done with the
* reader.
*
* @param name the name of the resource
* @return Reader, or null if not found.
* @throws IOException if resource fails to open
*/
Reader open(String name) throws IOException;
/**
* Open a resource or throw an exception if no such resource is found.
*
* The caller of this method is guaranteed to call {@link #close(Reader)} when done with the
* reader.
*
* @param name the name of the resource
* @return Reader, or null if not found.
* @throws JSilverTemplateNotFoundException if resource is not found
* @throws IOException if resource fails to open
*/
Reader openOrFail(String name) throws JSilverTemplateNotFoundException, IOException;
/**
* Close the reader. Allows ResourceLoader to perform any additional clean up.
*
* @param reader the reader to close
* @throws IOException if reader fasils to close
*/
void close(Reader reader) throws IOException;
/**
* Returns an object that can be used to uniquely identify the file corresponding to the given
* file name in the context of this ResourceLoader. (e.g. ordered list of directories + filename,
* or absolute file path.).
*
* @param filename the name we want to identify
* @return unique identifier
*/
Object getKey(String filename);
/**
* Returns an object that can be used to identify when a resource has changed. This key should be
* based on some piece(s) of metadata that strongly indicates the resource has changed, for
* example a file's last modified time. Since the object is expected to be used as part of a cache
* key, it should be immutable and implement {@link Object#equals(Object)} and
* {@link Object#hashCode()} .
*
* If the ResourceLoader does not or cannot compute a version identifier then it is sufficient to
* always return the same Object, e.g. the resource name. Null, however, should only be returned
* if a call to {@link #open(String)} would also return null.
*
* @param name the name of the resource to check for resources
* @return unique identifier for the current version of the resource or null if the resource
* cannot be found
*/
Object getResourceVersionId(String name);
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/ClassResourceLoader.java 0000644 0001750 0001750 00000005110 11431117716 032447 0 ustar chris chris /*
* 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.resourceloader;
import com.google.clearsilver.jsilver.exceptions.JSilverTemplateNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
/**
* Loads resources from classpath, alongside a given class.
*
*
* com/foo/SomeThing.class
* com/foo/my-template.cs
* com/foo/subdir/another-template.cs
*
*
*
* ResourceLoader loader = new ClassResourceLoader(SomeThing.class);
* loader.open("my-template.cs");
* loader.open("subdir/my-template.cs");
*
* Or by using a relative path:
*
* ResourceLoader loader = new ClassResourceLoader(Something.class, "subdir");
* loader.open("my-template.cs");
*
*
* @see ResourceLoader
* @see ClassLoaderResourceLoader
*/
public class ClassResourceLoader extends BufferedResourceLoader {
private final Class cls;
private final String basePath;
public ClassResourceLoader(Class cls) {
this.cls = cls;
this.basePath = "/" + cls.getPackage().getName().replace('.', '/');
}
/**
* Load resources from the given subdirectory {@code basePath},
* relative to the .class file of {@code cls}.
*/
public ClassResourceLoader(Class cls, String basePath) {
this.cls = cls;
this.basePath = basePath;
}
@Override
public Reader open(String name) throws IOException {
InputStream stream = cls.getResourceAsStream(basePath + '/' + name);
return stream == null ? null : buffer(new InputStreamReader(stream, getCharacterSet()));
}
@Override
public Reader openOrFail(String name) throws JSilverTemplateNotFoundException, IOException {
Reader reader = open(name);
if (reader == null) {
throw new JSilverTemplateNotFoundException("No '" + name + "' as class resource of "
+ cls.getName());
} else {
return reader;
}
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/BufferedResourceLoader.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/BufferedResourceLoader.jav0000644 0001750 0001750 00000003226 11427052602 032766 0 ustar chris chris /*
* 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.resourceloader;
import java.io.Reader;
import java.io.BufferedReader;
/**
* Base class for ResourceLoader implementations that require the Reader to be buffered (i.e.
* there's IO latency involved).
*
* @see ResourceLoader
*/
public abstract class BufferedResourceLoader extends BaseResourceLoader {
public static final int DEFAULT_BUFFER_SIZE = 1024;
public static final String DEFAULT_CHARACTER_SET = "UTF-8";
private int bufferSize = DEFAULT_BUFFER_SIZE;
private String characterSet = DEFAULT_CHARACTER_SET;
/**
* Subclasses can wrap a Reader in a BufferedReader by calling this method.
*/
protected Reader buffer(Reader reader) {
return reader == null ? null : new BufferedReader(reader, bufferSize);
}
public int getBufferSize() {
return bufferSize;
}
public void setBufferSize(int bufferSize) {
this.bufferSize = bufferSize;
}
public void setCharacterSet(String characterSet) {
this.characterSet = characterSet;
}
public String getCharacterSet() {
return characterSet;
}
}
././@LongLink 0000000 0000000 0000000 00000000147 00000000000 011567 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/CompositeResourceLoader.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/CompositeResourceLoader.ja0000644 0001750 0001750 00000007020 11427052602 033014 0 ustar chris chris /*
* 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.resourceloader;
import com.google.clearsilver.jsilver.exceptions.JSilverTemplateNotFoundException;
import java.io.FilterReader;
import java.io.IOException;
import java.io.Reader;
import java.util.ArrayList;
import java.util.List;
/**
* ResourceLoader composed of other ResourceLoaders. When a resource is loaded, it will search
* through each ResourceLoader until it finds something.
*
* @see ResourceLoader
*/
public class CompositeResourceLoader implements ResourceLoader {
private final List
* com/foo/my-template.cs
* com/foo/subdir/another-template.cs
*
*
*
* ResourceLoader loader =
* new ClassPathResourceLoader(getClassLoader(), "com/foo");
* loader.open("my-template.cs");
* loader.open("subdir/my-template.cs");
*
*
* @see ResourceLoader
* @see ClassResourceLoader
*/
public class ClassLoaderResourceLoader extends BufferedResourceLoader {
private final ClassLoader classLoader;
private String basePath;
public ClassLoaderResourceLoader(ClassLoader classLoader, String basePath) {
this.classLoader = classLoader;
this.basePath = basePath;
}
public ClassLoaderResourceLoader(ClassLoader classLoader) {
this(classLoader, ".");
}
@Override
public Reader open(String name) throws IOException {
String path = basePath + '/' + name;
InputStream stream = classLoader.getResourceAsStream(path);
return stream == null ? null : buffer(new InputStreamReader(stream, getCharacterSet()));
}
@Override
public Reader openOrFail(String name) throws JSilverTemplateNotFoundException, IOException {
Reader reader = open(name);
if (reader == null) {
throw new JSilverTemplateNotFoundException("No class loader resource '" + name + "' in '"
+ basePath + "'");
} else {
return reader;
}
}
}
jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/BaseResourceLoader.java 0000644 0001750 0001750 00000003300 11427052602 032250 0 ustar chris chris /*
* 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.resourceloader;
import java.io.IOException;
import java.io.Reader;
/**
* Implementations of ResourceLoader should extend this class rather than directly implement the
* ResourceLoader interface - this allows changes to be made to the ResourceLoader interface whilst
* retaining backwards compatibility with existing implementations.
*
* @see ResourceLoader
*/
public abstract class BaseResourceLoader implements ResourceLoader {
@Override
public void close(Reader reader) throws IOException {
reader.close();
}
/**
* Default implementation returns the filename as the ResourceLoaders that subclass this class
* tend to assume they are the only ResourceLoader in use. Or at least that the filename is the
* only necessary form of uniqueness between two instances of this same ResourceLoader.
*/
@Override
public Object getKey(String filename) {
return filename;
}
/**
* Default implementation does not check whether the resource has changed.
*/
@Override
public Object getResourceVersionId(String filename) {
return filename;
}
}
././@LongLink 0000000 0000000 0000000 00000000146 00000000000 011566 L ustar root root jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/InMemoryResourceLoader.java jsilver-1.0.0.dfsg.orig/src/com/google/clearsilver/jsilver/resourceloader/InMemoryResourceLoader.jav0000644 0001750 0001750 00000003732 11427052602 033005 0 ustar chris chris /*
* 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.resourceloader;
import com.google.clearsilver.jsilver.exceptions.JSilverTemplateNotFoundException;
import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
* ResourceLoader that pulls all items from memory. This is particularly useful for small templates
* that can be embedded in code (e.g. in unit tests).
*
* Content needs to be stored first using the {@link #store(String, String)} method.
*
* @see ResourceLoader
*/
public class InMemoryResourceLoader extends BaseResourceLoader {
private ConcurrentMapnull if file not found.
* @param loadpaths the ordered list of paths to search.
* @param filename the name of the file.
* @return a File object corresponding to the file. null if
* file not found.
*/
public static File locateFile(List
* Developers that want strict checking that the HDF passed to newCs matches
* HDF objects constructed by newHDF may want to pass in {@code false}.
*
* @param unwrapDelegatedHdfs true if {@link org.clearsilver.HDF}s passed to
* {@link #newCs} should be unwrapped if they are
* {@link org.clearsilver.DelegatedHdf} objects, false otherwise.
*/
public JniClearsilverFactory(boolean unwrapDelegatedHdfs) {
this.unwrapDelegatedHdfs = unwrapDelegatedHdfs;
}
/**
* Create a new CS object.
* @param hdf the HDF object to use in constructing the CS object.
* @return a new CS object
*/
public CS newCs(HDF hdf) {
if (unwrapDelegatedHdfs) {
hdf = DelegatedHdf.getFullyUnwrappedHdf(hdf);
}
return new JniCs(JniHdf.cast(hdf));
}
/**
* Create a new CS object. Also checks and unwraps any DelegatedHdfs
* passed into the method.
* @param hdf the HDF object to use in constructing the CS object.
* @param globalHdf the global HDF object to use in constructing the
* CS object.
* @return a new CS object
*/
public CS newCs(HDF hdf, HDF globalHdf) {
if (unwrapDelegatedHdfs) {
hdf = DelegatedHdf.getFullyUnwrappedHdf(hdf);
globalHdf = DelegatedHdf.getFullyUnwrappedHdf(globalHdf);
}
return new JniCs(JniHdf.cast(hdf), JniHdf.cast(globalHdf));
}
/**
* Create a new HDF object.
* @return a new HDF object
*/
public HDF newHdf() {
return new JniHdf();
}
}
jsilver-1.0.0.dfsg.orig/src/org/clearsilver/jni/JniHdf.java 0000644 0001750 0001750 00000033210 11427052602 022525 0 ustar chris chris /*
* 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 org.clearsilver.jni;
import org.clearsilver.CSFileLoader;
import org.clearsilver.HDF;
import java.io.IOException;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
/**
* This class is a wrapper around the HDF C API. Many features of the C API
* are not yet exposed through this wrapper.
*/
public class JniHdf implements HDF {
long hdfptr; // stores the C HDF* pointer
JniHdf root; // If this is a child HDF node, points at the root node of
// the tree. For root nodes this is null. A child node needs
// to hold a reference on the root to prevent the root from
// being GC-ed.
static {
JNI.loadLibrary();
}
static JniHdf cast(HDF hdf) {
if (!(hdf instanceof JniHdf)) {
throw new IllegalArgumentException("HDF object not of type JniHdf. "
+ "Make sure you use the same ClearsilverFactory to construct all "
+ "related HDF and CS objects.");
}
return (JniHdf)hdf;
}
/**
* Default public constructor.
*/
public JniHdf() {
hdfptr = _init();
root = null;
}
protected JniHdf(long hdfptr, JniHdf parent) {
this.hdfptr = hdfptr;
this.root = (parent.root != null) ? parent.root : parent;
}
/** Constructs an HDF child node. Used by other methods in this class when
* a child node needs to be constructed.
*/
protected JniHdf newHdf(long hdfptr, HDF parent) {
return new JniHdf(hdfptr, cast(parent));
}
/** Clean up allocated memory if neccesary. close() allows application
* to force clean up.
*/
public void close() {
// Only root nodes have ownership of the C HDF pointer, so only a root
// node needs to dealloc hdfptr.dir
if (root == null) {
if (hdfptr != 0) {
_dealloc(hdfptr);
hdfptr = 0;
}
}
}
/** Call close() just in case when deallocating Java object.
*/
protected void finalize() throws Throwable {
close();
super.finalize();
}
/** Loads the contents of the specified HDF file from disk into the current
* HDF object. The loaded contents are merged with the existing contents.
* @param filename the name of file to read in and parse.
* @throws java.io.FileNotFoundException if the specified file does not
* exist.
* @throws IOException other problems reading the file.
*/
public boolean readFile(String filename) throws IOException {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _readFile(hdfptr, filename, fileLoader != null);
}
protected String fileLoad(String filename) throws IOException {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
CSFileLoader aFileLoader = fileLoader;
if (aFileLoader == null) {
throw new NullPointerException("No fileLoader specified.");
} else {
String result = aFileLoader.load(this, filename);
if (result == null) {
throw new NullPointerException("CSFileLoader.load() returned null");
}
return result;
}
}
// The optional CS file loader to use to read in files
private CSFileLoader fileLoader = null;
/**
* Get the file loader in use, if any.
* @return the file loader in use.
*/
public CSFileLoader getFileLoader() {
return fileLoader;
}
/**
* Set the CS file loader to use
* @param fileLoader the file loader that should be used.
*/
public void setFileLoader(CSFileLoader fileLoader) {
this.fileLoader = fileLoader;
}
/** Serializes HDF contents to a file (readable by readFile)
*/
public boolean writeFile(String filename) throws IOException {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _writeFile(hdfptr, filename);
}
/** Parses/loads the contents of the given string as HDF into the current
* HDF object. The loaded contents are merged with the existing contents.
*/
public boolean readString(String data) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _readString(hdfptr, data);
}
/** Serializes HDF contents to a string (readable by readString)
*/
public String writeString() {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _writeString(hdfptr);
}
/** Retrieves the integer value at the specified path in this HDF node's
* subtree. If the value does not exist, or cannot be converted to an
* integer, default_value will be returned. */
public int getIntValue(String hdfname, int default_value) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _getIntValue(hdfptr,hdfname,default_value);
}
/** Retrieves the value at the specified path in this HDF node's subtree.
*/
public String getValue(String hdfname, String default_value) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _getValue(hdfptr,hdfname,default_value);
}
/** Sets the value at the specified path in this HDF node's subtree. */
public void setValue(String hdfname, String value) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
_setValue(hdfptr,hdfname,value);
}
/** Remove the specified subtree. */
public void removeTree(String hdfname) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
_removeTree(hdfptr,hdfname);
}
/** Links the src hdf name to the dest. */
public void setSymLink(String hdf_name_src, String hdf_name_dest) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
_setSymLink(hdfptr,hdf_name_src,hdf_name_dest);
}
/** Export a date to a clearsilver tree using a specified timezone */
public void exportDate(String hdfname, TimeZone timeZone, Date date) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
Calendar cal = Calendar.getInstance(timeZone);
cal.setTime(date);
String sec = Integer.toString(cal.get(Calendar.SECOND));
setValue(hdfname + ".sec", sec.length() == 1 ? "0" + sec : sec);
String min = Integer.toString(cal.get(Calendar.MINUTE));
setValue(hdfname + ".min", min.length() == 1 ? "0" + min : min);
setValue(hdfname + ".24hour",
Integer.toString(cal.get(Calendar.HOUR_OF_DAY)));
// java.util.Calendar uses represents 12 o'clock as 0
setValue(hdfname + ".hour",
Integer.toString(
cal.get(Calendar.HOUR) == 0 ? 12 : cal.get(Calendar.HOUR)));
setValue(hdfname + ".am",
cal.get(Calendar.AM_PM) == Calendar.AM ? "1" : "0");
setValue(hdfname + ".mday",
Integer.toString(cal.get(Calendar.DAY_OF_MONTH)));
setValue(hdfname + ".mon",
Integer.toString(cal.get(Calendar.MONTH)+1));
setValue(hdfname + ".year",
Integer.toString(cal.get(Calendar.YEAR)));
setValue(hdfname + ".2yr",
Integer.toString(cal.get(Calendar.YEAR)).substring(2));
// Java DAY_OF_WEEK puts Sunday .. Saturday as 1 .. 7 respectively
// See http://java.sun.com/j2se/1.5.0/docs/api/java/util/Calendar.html#DAY_OF_WEEK
// However, C and Python export Sun .. Sat as 0 .. 6, because
// POSIX localtime_r produces wday 0 .. 6. So, adjust.
setValue(hdfname + ".wday",
Integer.toString(cal.get(Calendar.DAY_OF_WEEK) - 1));
boolean tzNegative = timeZone.getRawOffset() < 0;
int tzAbsolute = java.lang.Math.abs(timeZone.getRawOffset()/1000);
String tzHour = Integer.toString(tzAbsolute/3600);
String tzMin = Integer.toString(tzAbsolute/60 - (tzAbsolute/3600)*60);
String tzString = (tzNegative ? "-" : "+")
+ (tzHour.length() == 1 ? "0" + tzHour : tzHour)
+ (tzMin.length() == 1 ? "0" + tzMin : tzMin);
setValue(hdfname + ".tzoffset", tzString);
}
/** Export a date to a clearsilver tree using a specified timezone */
public void exportDate(String hdfname, String tz, int tt) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
TimeZone timeZone = TimeZone.getTimeZone(tz);
if (timeZone == null) {
throw new RuntimeException("Unknown timezone: " + tz);
}
Date date = new Date((long)tt * 1000);
exportDate(hdfname, timeZone, date);
}
/** Retrieves the HDF object that is the root of the subtree at hdfpath, or
* null if no object exists at that path. */
public JniHdf getObj(String hdfpath) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
long obj_ptr = _getObj(hdfptr, hdfpath);
if ( obj_ptr == 0 ) {
return null;
}
return newHdf(obj_ptr, this);
}
/** Retrieves the HDF for the first child of the root of the subtree
* at hdfpath, or null if no child exists of that path or if the
* path doesn't exist. */
public JniHdf getChild(String hdfpath) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
long obj_ptr = _getChild(hdfptr, hdfpath);
if ( obj_ptr == 0 ) {
return null;
}
return newHdf(obj_ptr, this);
}
/** Return the root of the tree where the current node lies. If the
* current node is the root, return this. */
public JniHdf getRootObj() {
return root != null ? root : this;
}
public boolean belongsToSameRoot(HDF hdf) {
JniHdf jniHdf = cast(hdf);
return this.getRootObj() == jniHdf.getRootObj();
}
/** Retrieves the HDF object that is the root of the subtree at
* hdfpath, create the subtree if it doesn't exist */
public JniHdf getOrCreateObj(String hdfpath) {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
long obj_ptr = _getObj(hdfptr, hdfpath);
if ( obj_ptr == 0 ) {
// Create a node
_setValue(hdfptr, hdfpath, "");
obj_ptr = _getObj( hdfptr, hdfpath );
if ( obj_ptr == 0 ) {
return null;
}
}
return newHdf(obj_ptr, this);
}
/** Returns the name of this HDF node. The root node has no name, so
* calling this on the root node will return null. */
public String objName() {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _objName(hdfptr);
}
/** Returns the value of this HDF node, or null if this node has no value.
* Every node in the tree can have a value, a child, and a next peer. */
public String objValue() {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _objValue(hdfptr);
}
/** Returns the child of this HDF node, or null if there is no child.
* Use this in conjunction with objNext to walk the HDF tree. Every node
* in the tree can have a value, a child, and a next peer.
*/
public JniHdf objChild() {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
long child_ptr = _objChild(hdfptr);
if ( child_ptr == 0 ) {
return null;
}
return newHdf(child_ptr, this);
}
/** Returns the next sibling of this HDF node, or null if there is no next
* sibling. Use this in conjunction with objChild to walk the HDF tree.
* Every node in the tree can have a value, a child, and a next peer.
*/
public JniHdf objNext() {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
long next_ptr = _objNext(hdfptr);
if ( next_ptr == 0 ) {
return null;
}
return newHdf(next_ptr, this);
}
public void copy(String hdfpath, HDF src) {
JniHdf source = cast(src);
if (hdfptr == 0 || source.hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
_copy(hdfptr, hdfpath, source.hdfptr);
}
/**
* Generates a string representing the content of the HDF tree rooted at
* this node.
*/
public String dump() {
if (hdfptr == 0) {
throw new NullPointerException("HDF is closed.");
}
return _dump(hdfptr);
}
private static native long _init();
private static native void _dealloc(long ptr);
private native boolean _readFile(long ptr, String filename, boolean use_cb)
throws IOException;
private static native boolean _writeFile(long ptr, String filename);
private static native boolean _readString(long ptr, String data);
private static native String _writeString(long ptr);
private static native int _getIntValue(long ptr, String hdfname,
int default_value);
private static native String _getValue(long ptr, String hdfname,
String default_value);
private static native void _setValue(long ptr, String hdfname,
String hdf_value);
private static native void _removeTree(long ptr, String hdfname);
private static native void _setSymLink(long ptr, String hdf_name_src,
String hdf_name_dest);
private static native long _getObj(long ptr, String hdfpath);
private static native long _getChild(long ptr, String hdfpath);
private static native long _objChild(long ptr);
private static native long _objNext(long ptr);
private static native String _objName(long ptr);
private static native String _objValue(long ptr);
private static native void _copy(long destptr, String hdfpath, long srcptr);
private static native String _dump(long ptr);
}
jsilver-1.0.0.dfsg.orig/src/org/clearsilver/jni/JniCs.java 0000644 0001750 0001750 00000007622 11427052602 022401 0 ustar chris chris /*
* 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 org.clearsilver.jni;
import org.clearsilver.CS;
import org.clearsilver.CSFileLoader;
import org.clearsilver.HDF;
import java.io.FileNotFoundException;
import java.io.IOException;
/**
* JNI implementation of the CS interface.
*/
public class JniCs implements CS {
long csptr;
protected JniHdf globalHDF;
protected JniHdf localHDF;
static {
JNI.loadLibrary();
}
JniCs(JniHdf ho) {
this.globalHDF = null;
this.localHDF = ho;
csptr = _init(ho.hdfptr);
}
JniCs(JniHdf ho, JniHdf global) {
this(ho);
this.globalHDF = global;
if (global != null) {
_setGlobalHdf(csptr,global.hdfptr);
}
}
// Specify a new/different global HDF
public void setGlobalHDF(HDF global) {
JniHdf globalHdf = JniHdf.cast(global);
_setGlobalHdf(csptr, globalHdf.hdfptr);
this.globalHDF = globalHdf;
}
// Return global hdf in use
public HDF getGlobalHDF() {
return this.globalHDF;
}
public void close() {
if (csptr != 0) {
_dealloc(csptr);
csptr = 0;
}
}
// Don't rely on this being called.
protected void finalize() {
close();
}
/**
* Parses the specified file as if it has template content. The file will
* be located using the HDF's loadpaths.
* @param filename the name of file to read in and parse.
* @throws java.io.FileNotFoundException if the specified file does not
* exist.
* @throws IOException other problems reading the file.
*/
public void parseFile(String filename) throws IOException {
if (csptr == 0) {
throw new NullPointerException("CS is closed.");
}
_parseFile(csptr, filename, fileLoader != null);
}
public void parseStr(String content) {
if (csptr == 0) {
throw new NullPointerException("CS is closed.");
}
_parseStr(csptr,content);
}
public String render() {
if (csptr == 0) {
throw new NullPointerException("CS is closed.");
}
return _render(csptr, fileLoader != null);
}
protected String fileLoad(String filename) throws IOException,
FileNotFoundException {
if (csptr == 0) {
throw new NullPointerException("CS is closed.");
}
CSFileLoader aFileLoader = fileLoader;
if (aFileLoader == null) {
throw new NullPointerException("No fileLoader specified.");
} else {
String result = aFileLoader.load(localHDF, filename);
if (result == null) {
throw new NullPointerException("CSFileLoader.load() returned null");
}
return result;
}
}
// The optional CS file loader to use to read in files
private CSFileLoader fileLoader = null;
/**
* Get the file loader in use, if any.
* @return the file loader in use.
*/
public CSFileLoader getFileLoader() {
return fileLoader;
}
/**
* Set the CS file loader to use
* @param fileLoader the file loader that should be used.
*/
public void setFileLoader(CSFileLoader fileLoader) {
this.fileLoader = fileLoader;
}
// Native methods
private native long _init(long ptr);
private native void _dealloc(long ptr);
private native void _parseFile(long ptr, String filename,
boolean use_cb) throws IOException;
private native void _parseStr(long ptr, String content);
private native String _render(long ptr, boolean use_cb);
private native void _setGlobalHdf(long csptr, long hdfptr);
}
jsilver-1.0.0.dfsg.orig/src/org/clearsilver/jni/JNI.java 0000644 0001750 0001750 00000010126 11427052602 022004 0 ustar chris chris /*
* 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 org.clearsilver.jni;
import java.io.File;
import java.util.regex.Pattern;
/**
* Loads the ClearSilver JNI library.
*
*