freemarker-notifications mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ddek...@apache.org
Subject [36/54] [partial] incubator-freemarker git commit: Unifying the o.a.f.core and o.a.f.core.ast
Date Thu, 23 Feb 2017 21:36:03 GMT
http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateClassResolver.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateClassResolver.java b/src/main/java/org/apache/freemarker/core/TemplateClassResolver.java
new file mode 100644
index 0000000..78d8025
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateClassResolver.java
@@ -0,0 +1,82 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import org.apache.freemarker.core.util._ClassUtil;
+
+/**
+ * Used by built-ins and other template language features that get a class
+ * based on a string. This can be handy both for implementing security
+ * restrictions and for working around local class-loader issues. 
+ * 
+ * The implementation should be thread-safe, unless an
+ * instance is always only used in a single {@link Environment} object.
+ * 
+ * @see Configurable#setNewBuiltinClassResolver(TemplateClassResolver)
+ * 
+ * @since 2.3.17
+ */
+public interface TemplateClassResolver {
+    
+    /**
+     * Simply calls {@link _ClassUtil#forName(String)}.
+     */
+    TemplateClassResolver UNRESTRICTED_RESOLVER = new TemplateClassResolver() {
+
+        @Override
+        public Class resolve(String className, Environment env, Template template)
+        throws TemplateException {
+            try {
+                return _ClassUtil.forName(className);
+            } catch (ClassNotFoundException e) {
+                throw new _MiscTemplateException(e, env);
+            }
+        }
+        
+    };
+    
+    /**
+     * Doesn't allow resolving any classes.
+     */
+    TemplateClassResolver ALLOWS_NOTHING_RESOLVER =  new TemplateClassResolver() {
+
+        @Override
+        public Class resolve(String className, Environment env, Template template)
+        throws TemplateException {
+            throw MessageUtil.newInstantiatingClassNotAllowedException(className, env);
+        }
+        
+    };
+
+    /**
+     * Gets a {@link Class} based on the class name.
+     * 
+     * @param className the full-qualified class name
+     * @param env the environment in which the template executes
+     * @param template the template where the operation that require the
+     *        class resolution resides in. This is <code>null</code> if the
+     *        call doesn't come from a template.
+     *        
+     * @throws TemplateException if the class can't be found or shouldn't be
+     *   accessed from a template for security reasons.
+     */
+    Class resolve(String className, Environment env, Template template) throws TemplateException;
+    
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateCombinedMarkupOutputModel.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateCombinedMarkupOutputModel.java b/src/main/java/org/apache/freemarker/core/TemplateCombinedMarkupOutputModel.java
new file mode 100644
index 0000000..fef06d6
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateCombinedMarkupOutputModel.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+/**
+ * Stores combined markup to be printed; used with {@link CombinedMarkupOutputFormat}.
+ * 
+ * @since 2.3.24
+ */
+public final class TemplateCombinedMarkupOutputModel
+        extends CommonTemplateMarkupOutputModel<TemplateCombinedMarkupOutputModel> {
+    
+    private final CombinedMarkupOutputFormat outputFormat;
+    
+    /**
+     * See {@link CommonTemplateMarkupOutputModel#CommonTemplateMarkupOutputModel(String, String)}.
+     * 
+     * @param outputFormat
+     *            The {@link CombinedMarkupOutputFormat} format this value is bound to. Because
+     *            {@link CombinedMarkupOutputFormat} has no singleton, we have to pass it in, unlike with most other
+     *            {@link CommonTemplateMarkupOutputModel}-s.
+     */
+    TemplateCombinedMarkupOutputModel(String plainTextContent, String markupContent,
+            CombinedMarkupOutputFormat outputFormat) {
+        super(plainTextContent, markupContent);
+        this.outputFormat = outputFormat; 
+    }
+
+    @Override
+    public CombinedMarkupOutputFormat getOutputFormat() {
+        return outputFormat;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateConfiguration.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateConfiguration.java b/src/main/java/org/apache/freemarker/core/TemplateConfiguration.java
new file mode 100644
index 0000000..583f064
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateConfiguration.java
@@ -0,0 +1,921 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TimeZone;
+
+import org.apache.freemarker.core.model.ObjectWrapper;
+import org.apache.freemarker.core.templateresolver.impl.DefaultTemplateResolver;
+import org.apache.freemarker.core.util._NullArgumentException;
+
+/**
+ * Used for customizing the configuration settings for individual {@link Template}-s (or rather groups of templates),
+ * relatively to the common setting values coming from the {@link Configuration}. This was designed with the standard
+ * template loading mechanism of FreeMarker in mind ({@link Configuration#getTemplate(String)}
+ * and {@link DefaultTemplateResolver}), though can also be reused for custom template loading and caching solutions.
+ * 
+ * <p>
+ * Note on the {@code locale} setting: When used with the standard template loading/caching mechanism (
+ * {@link Configuration#getTemplate(String)} and its overloads), localized lookup happens before the {@code locale}
+ * specified here could have effect. The {@code locale} will be only set in the template that the localized lookup has
+ * already found.
+ * 
+ * <p>
+ * Note on the encoding setting {@code encoding}: See {@link #setEncoding(String)}.
+ * 
+ * <p>
+ * Note that the result value of the reader methods (getter and "is" methods) is usually not useful unless the value of
+ * that setting was already set on this object. Otherwise you will get the value from the parent {@link Configuration},
+ * or an {@link IllegalStateException} before this object is associated to a {@link Configuration}.
+ * 
+ * <p>
+ * If you are using this class for your own template loading and caching solution, rather than with the standard one,
+ * you should be aware of a few more details:
+ * 
+ * <ul>
+ * <li>This class implements both {@link Configurable} and {@link ParserConfiguration}. This means that it can influence
+ * both the template parsing phase and the runtime settings. For both aspects (i.e., {@link ParserConfiguration} and
+ * {@link Configurable}) to take effect, you have first pass this object to the {@link Template} constructor
+ * (this is where the {@link ParserConfiguration} interface is used), and then you have to call {@link #apply(Template)}
+ * on the resulting {@link Template} object (this is where the {@link Configurable} aspect is used).
+ * 
+ * <li>{@link #apply(Template)} only change the settings that weren't yet set on the {@link Template} (but are inherited
+ * from the {@link Configuration}). This is primarily because if the template configures itself via the {@code #ftl}
+ * header, those values should have precedence. A consequence of this is that if you want to configure the same
+ * {@link Template} with multiple {@link TemplateConfiguration}-s, you either should merge them to a single one before
+ * that (with {@link #merge(TemplateConfiguration)}), or you have to apply them in reverse order of their intended
+ * precedence.
+ * </ul>
+ * 
+ * @see Template#Template(String, String, Reader, Configuration, ParserConfiguration, String)
+ * 
+ * @since 2.3.24
+ */
+public final class TemplateConfiguration extends Configurable implements ParserConfiguration {
+
+    private Integer tagSyntax;
+    private Integer namingConvention;
+    private Boolean whitespaceStripping;
+    private Integer autoEscapingPolicy;
+    private Boolean recognizeStandardFileExtensions;
+    private OutputFormat outputFormat;
+    private String encoding;
+    private Integer tabSize;
+
+    /**
+     * Creates a new instance. The parent will be {@code null} initially, but it will
+     * be changed to the real parent {@link Configuration} when this object is added to the {@link Configuration}. (It's
+     * not allowed to add the same instance to multiple {@link Configuration}-s).
+     */
+    public TemplateConfiguration() {
+        super((Configuration) null);
+    }
+
+    /**
+     * Same as {@link #setParentConfiguration(Configuration)}.
+     */
+    @Override
+    void setParent(Configurable cfg) {
+        _NullArgumentException.check("cfg", cfg);
+        if (!(cfg instanceof Configuration)) {
+            throw new IllegalArgumentException("The parent of a TemplateConfiguration can only be a Configuration");
+        }
+        
+        Configurable parent = getParent();
+        if (parent != null) {
+            if (parent != cfg) {
+                throw new IllegalStateException(
+                        "This TemplateConfiguration is already associated with a different Configuration instance.");
+            }
+            return;
+        }
+        
+        super.setParent(cfg);
+    }
+
+    /**
+     * Associates this instance with a {@link Configuration}; usually you don't call this, as it's called internally
+     * when this instance is added to a {@link Configuration}. This method can be called only once (except with the same
+     * {@link Configuration} parameter again, as that changes nothing anyway).
+     * 
+     * @throws IllegalArgumentException
+     *             if the argument is {@code null} or not a {@link Configuration}
+     * @throws IllegalStateException
+     *             if this object is already associated to a different {@link Configuration} object,
+     *             or if the {@code Configuration} has {@code #getIncompatibleImprovements()} less than 2.3.22 and
+     *             this object tries to change any non-parser settings  
+     */
+    public void setParentConfiguration(Configuration cfg) {
+        setParent(cfg);
+    }
+
+    /**
+     * Returns the parent {@link Configuration}, or {@code null} if none was associated yet.
+     */
+    public Configuration getParentConfiguration() {
+        return (Configuration) getParent();
+    }
+
+    private Configuration getNonNullParentConfiguration() {
+        Configurable parent = getParent();
+        if (parent == null) {
+            throw new IllegalStateException("The TemplateConfiguration wasn't associated with a Configuration yet.");
+        }
+        return (Configuration) parent;
+    }
+    
+    /**
+     * Set all settings in this {@link TemplateConfiguration} that were set in the parameter
+     * {@link TemplateConfiguration}, possibly overwriting the earlier value in this object. (A setting is said to be
+     * set in a {@link TemplateConfiguration} if it was explicitly set via a setter method, as opposed to be inherited.)
+     */
+    public void merge(TemplateConfiguration tc) {
+        if (tc.isAPIBuiltinEnabledSet()) {
+            setAPIBuiltinEnabled(tc.isAPIBuiltinEnabled());
+        }
+        if (tc.isArithmeticEngineSet()) {
+            setArithmeticEngine(tc.getArithmeticEngine());
+        }
+        if (tc.isAutoEscapingPolicySet()) {
+            setAutoEscapingPolicy(tc.getAutoEscapingPolicy());
+        }
+        if (tc.isAutoFlushSet()) {
+            setAutoFlush(tc.getAutoFlush());
+        }
+        if (tc.isBooleanFormatSet()) {
+            setBooleanFormat(tc.getBooleanFormat());
+        }
+        if (tc.isCustomDateFormatsSet()) {
+            setCustomDateFormats(mergeMaps(
+                    isCustomDateFormatsSet() ? getCustomDateFormats() : null, tc.getCustomDateFormats(), false));
+        }
+        if (tc.isCustomNumberFormatsSet()) {
+            setCustomNumberFormats(mergeMaps(
+                    isCustomNumberFormatsSet() ? getCustomNumberFormats() : null, tc.getCustomNumberFormats(), false));
+        }
+        if (tc.isDateFormatSet()) {
+            setDateFormat(tc.getDateFormat());
+        }
+        if (tc.isDateTimeFormatSet()) {
+            setDateTimeFormat(tc.getDateTimeFormat());
+        }
+        if (tc.isEncodingSet()) {
+            setEncoding(tc.getEncoding());
+        }
+        if (tc.isLocaleSet()) {
+            setLocale(tc.getLocale());
+        }
+        if (tc.isLogTemplateExceptionsSet()) {
+            setLogTemplateExceptions(tc.getLogTemplateExceptions());
+        }
+        if (tc.isNamingConventionSet()) {
+            setNamingConvention(tc.getNamingConvention());
+        }
+        if (tc.isNewBuiltinClassResolverSet()) {
+            setNewBuiltinClassResolver(tc.getNewBuiltinClassResolver());
+        }
+        if (tc.isNumberFormatSet()) {
+            setNumberFormat(tc.getNumberFormat());
+        }
+        if (tc.isObjectWrapperSet()) {
+            setObjectWrapper(tc.getObjectWrapper());
+        }
+        if (tc.isOutputEncodingSet()) {
+            setOutputEncoding(tc.getOutputEncoding());
+        }
+        if (tc.isOutputFormatSet()) {
+            setOutputFormat(tc.getOutputFormat());
+        }
+        if (tc.isRecognizeStandardFileExtensionsSet()) {
+            setRecognizeStandardFileExtensions(tc.getRecognizeStandardFileExtensions());
+        }
+        if (tc.isShowErrorTipsSet()) {
+            setShowErrorTips(tc.getShowErrorTips());
+        }
+        if (tc.isSQLDateAndTimeTimeZoneSet()) {
+            setSQLDateAndTimeTimeZone(tc.getSQLDateAndTimeTimeZone());
+        }
+        if (tc.isTagSyntaxSet()) {
+            setTagSyntax(tc.getTagSyntax());
+        }
+        if (tc.isTemplateExceptionHandlerSet()) {
+            setTemplateExceptionHandler(tc.getTemplateExceptionHandler());
+        }
+        if (tc.isTimeFormatSet()) {
+            setTimeFormat(tc.getTimeFormat());
+        }
+        if (tc.isTimeZoneSet()) {
+            setTimeZone(tc.getTimeZone());
+        }
+        if (tc.isURLEscapingCharsetSet()) {
+            setURLEscapingCharset(tc.getURLEscapingCharset());
+        }
+        if (tc.isWhitespaceStrippingSet()) {
+            setWhitespaceStripping(tc.getWhitespaceStripping());
+        }
+        if (tc.isTabSizeSet()) {
+            setTabSize(tc.getTabSize());
+        }
+        if (tc.isLazyImportsSet()) {
+            setLazyImports(tc.getLazyImports());
+        }
+        if (tc.isLazyAutoImportsSet()) {
+            setLazyAutoImports(tc.getLazyAutoImports());
+        }
+        if (tc.isAutoImportsSet()) {
+            setAutoImports(mergeMaps(isAutoImportsSet() ? getAutoImports() : null, tc.getAutoImports(), true));
+        }
+        if (tc.isAutoIncludesSet()) {
+            setAutoIncludes(mergeLists(isAutoIncludesSet() ? getAutoIncludes() : null, tc.getAutoIncludes()));
+        }
+        
+        tc.copyDirectCustomAttributes(this, true);
+    }
+
+    /**
+     * Sets those settings of the {@link Template} which aren't yet set in the {@link Template} and are set in this
+     * {@link TemplateConfiguration}, leaves the other settings as is. A setting is said to be set in a
+     * {@link TemplateConfiguration} or {@link Template} if it was explicitly set via a setter method on that object, as
+     * opposed to be inherited from the {@link Configuration}.
+     * 
+     * <p>
+     * Note that this method doesn't deal with settings that influence the parser, as those are already baked in at this
+     * point via the {@link ParserConfiguration}. 
+     * 
+     * <p>
+     * Note that the {@code encoding} setting of the {@link Template} counts as unset if it's {@code null},
+     * even if {@code null} was set via {@link Template#setEncoding(String)}.
+     *
+     * @throws IllegalStateException
+     *             If the parent configuration wasn't yet set.
+     */
+    public void apply(Template template) {
+        Configuration cfg = getNonNullParentConfiguration();
+        if (template.getConfiguration() != cfg) {
+            // This is actually not a problem right now, but for future BC we enforce this.
+            throw new IllegalArgumentException(
+                    "The argument Template doesn't belong to the same Configuration as the TemplateConfiguration");
+        }
+
+        if (isAPIBuiltinEnabledSet() && !template.isAPIBuiltinEnabledSet()) {
+            template.setAPIBuiltinEnabled(isAPIBuiltinEnabled());
+        }
+        if (isArithmeticEngineSet() && !template.isArithmeticEngineSet()) {
+            template.setArithmeticEngine(getArithmeticEngine());
+        }
+        if (isAutoFlushSet() && !template.isAutoFlushSet()) {
+            template.setAutoFlush(getAutoFlush());
+        }
+        if (isBooleanFormatSet() && !template.isBooleanFormatSet()) {
+            template.setBooleanFormat(getBooleanFormat());
+        }
+        if (isCustomDateFormatsSet()) {
+            template.setCustomDateFormats(
+                    mergeMaps(getCustomDateFormats(), template.getCustomDateFormatsWithoutFallback(), false));
+        }
+        if (isCustomNumberFormatsSet()) {
+            template.setCustomNumberFormats(
+                    mergeMaps(getCustomNumberFormats(), template.getCustomNumberFormatsWithoutFallback(), false));
+        }
+        if (isDateFormatSet() && !template.isDateFormatSet()) {
+            template.setDateFormat(getDateFormat());
+        }
+        if (isDateTimeFormatSet() && !template.isDateTimeFormatSet()) {
+            template.setDateTimeFormat(getDateTimeFormat());
+        }
+        if (isEncodingSet() && template.getEncoding() == null) {
+            template.setEncoding(getEncoding());
+        }
+        if (isLocaleSet() && !template.isLocaleSet()) {
+            template.setLocale(getLocale());
+        }
+        if (isLogTemplateExceptionsSet() && !template.isLogTemplateExceptionsSet()) {
+            template.setLogTemplateExceptions(getLogTemplateExceptions());
+        }
+        if (isNewBuiltinClassResolverSet() && !template.isNewBuiltinClassResolverSet()) {
+            template.setNewBuiltinClassResolver(getNewBuiltinClassResolver());
+        }
+        if (isNumberFormatSet() && !template.isNumberFormatSet()) {
+            template.setNumberFormat(getNumberFormat());
+        }
+        if (isObjectWrapperSet() && !template.isObjectWrapperSet()) {
+            template.setObjectWrapper(getObjectWrapper());
+        }
+        if (isOutputEncodingSet() && !template.isOutputEncodingSet()) {
+            template.setOutputEncoding(getOutputEncoding());
+        }
+        if (isShowErrorTipsSet() && !template.isShowErrorTipsSet()) {
+            template.setShowErrorTips(getShowErrorTips());
+        }
+        if (isSQLDateAndTimeTimeZoneSet() && !template.isSQLDateAndTimeTimeZoneSet()) {
+            template.setSQLDateAndTimeTimeZone(getSQLDateAndTimeTimeZone());
+        }
+        if (isTemplateExceptionHandlerSet() && !template.isTemplateExceptionHandlerSet()) {
+            template.setTemplateExceptionHandler(getTemplateExceptionHandler());
+        }
+        if (isTimeFormatSet() && !template.isTimeFormatSet()) {
+            template.setTimeFormat(getTimeFormat());
+        }
+        if (isTimeZoneSet() && !template.isTimeZoneSet()) {
+            template.setTimeZone(getTimeZone());
+        }
+        if (isURLEscapingCharsetSet() && !template.isURLEscapingCharsetSet()) {
+            template.setURLEscapingCharset(getURLEscapingCharset());
+        }
+        if (isLazyImportsSet() && !template.isLazyImportsSet()) {
+            template.setLazyImports(getLazyImports());
+        }
+        if (isLazyAutoImportsSet() && !template.isLazyAutoImportsSet()) {
+            template.setLazyAutoImports(getLazyAutoImports());
+        }
+        if (isAutoImportsSet()) {
+            // Regarding the order of the maps in the merge:
+            // - Existing template-level imports have precedence over those coming from the TC (just as with the others
+            //   apply()-ed settings), thus for clashing import prefixes they must win.
+            // - Template-level imports count as more specific, and so come after the more generic ones from TC.
+            template.setAutoImports(mergeMaps(getAutoImports(), template.getAutoImportsWithoutFallback(), true));
+        }
+        if (isAutoIncludesSet()) {
+            template.setAutoIncludes(mergeLists(getAutoIncludes(), template.getAutoIncludesWithoutFallback()));
+        }
+        
+        copyDirectCustomAttributes(template, false);
+    }
+
+    /**
+     * See {@link Configuration#setTagSyntax(int)}.
+     */
+    public void setTagSyntax(int tagSyntax) {
+        _TemplateAPI.valideTagSyntaxValue(tagSyntax);
+        this.tagSyntax = Integer.valueOf(tagSyntax);
+    }
+
+    /**
+     * The getter pair of {@link #setTagSyntax(int)}.
+     */
+    @Override
+    public int getTagSyntax() {
+        return tagSyntax != null ? tagSyntax.intValue() : getNonNullParentConfiguration().getTagSyntax();
+    }
+
+    /**
+     * Tells if this setting is set directly in this object or its value is coming from the {@link #getParent() parent}.
+     */
+    public boolean isTagSyntaxSet() {
+        return tagSyntax != null;
+    }
+
+    /**
+     * See {@link Configuration#setNamingConvention(int)}.
+     */
+    public void setNamingConvention(int namingConvention) {
+        _TemplateAPI.validateNamingConventionValue(namingConvention);
+        this.namingConvention = Integer.valueOf(namingConvention);
+    }
+
+    /**
+     * The getter pair of {@link #setNamingConvention(int)}.
+     */
+    @Override
+    public int getNamingConvention() {
+        return namingConvention != null ? namingConvention.intValue()
+                : getNonNullParentConfiguration().getNamingConvention();
+    }
+
+    /**
+     * Tells if this setting is set directly in this object or its value is coming from the {@link #getParent() parent}.
+     */
+    public boolean isNamingConventionSet() {
+        return namingConvention != null;
+    }
+
+    /**
+     * See {@link Configuration#setWhitespaceStripping(boolean)}.
+     */
+    public void setWhitespaceStripping(boolean whitespaceStripping) {
+        this.whitespaceStripping = Boolean.valueOf(whitespaceStripping);
+    }
+
+    /**
+     * The getter pair of {@link #getWhitespaceStripping()}.
+     */
+    @Override
+    public boolean getWhitespaceStripping() {
+        return whitespaceStripping != null ? whitespaceStripping.booleanValue()
+                : getNonNullParentConfiguration().getWhitespaceStripping();
+    }
+
+    /**
+     * Tells if this setting is set directly in this object or its value is coming from the {@link #getParent() parent}.
+     */
+    public boolean isWhitespaceStrippingSet() {
+        return whitespaceStripping != null;
+    }
+
+    /**
+     * Sets the output format of the template; see {@link Configuration#setAutoEscapingPolicy(int)} for more.
+     */
+    public void setAutoEscapingPolicy(int autoEscapingPolicy) {
+        _TemplateAPI.validateAutoEscapingPolicyValue(autoEscapingPolicy);
+        this.autoEscapingPolicy = Integer.valueOf(autoEscapingPolicy);
+    }
+
+    /**
+     * The getter pair of {@link #setAutoEscapingPolicy(int)}.
+     */
+    @Override
+    public int getAutoEscapingPolicy() {
+        return autoEscapingPolicy != null ? autoEscapingPolicy.intValue()
+                : getNonNullParentConfiguration().getAutoEscapingPolicy();
+    }
+
+    /**
+     * Tells if this setting is set directly in this object or its value is coming from the {@link #getParent() parent}.
+     */
+    public boolean isAutoEscapingPolicySet() {
+        return autoEscapingPolicy != null;
+    }
+
+    /**
+     * Sets the output format of the template; see {@link Configuration#setOutputFormat(OutputFormat)} for more.
+     */
+    public void setOutputFormat(OutputFormat outputFormat) {
+        _NullArgumentException.check("outputFormat", outputFormat);
+        this.outputFormat = outputFormat;
+    }
+
+    /**
+     * The getter pair of {@link #setOutputFormat(OutputFormat)}.
+     */
+    @Override
+    public OutputFormat getOutputFormat() {
+        return outputFormat != null ? outputFormat : getNonNullParentConfiguration().getOutputFormat();
+    }
+
+    /**
+     * Tells if this setting is set directly in this object or its value is coming from the {@link #getParent() parent}.
+     */
+    public boolean isOutputFormatSet() {
+        return outputFormat != null;
+    }
+    
+    /**
+     * See {@link Configuration#setRecognizeStandardFileExtensions(boolean)}. 
+     */
+    public void setRecognizeStandardFileExtensions(boolean recognizeStandardFileExtensions) {
+        this.recognizeStandardFileExtensions = Boolean.valueOf(recognizeStandardFileExtensions);
+    }
+
+    /**
+     * Getter pair of {@link #setRecognizeStandardFileExtensions(boolean)}.
+     */
+    @Override
+    public boolean getRecognizeStandardFileExtensions() {
+        return recognizeStandardFileExtensions != null ? recognizeStandardFileExtensions.booleanValue()
+                : getNonNullParentConfiguration().getRecognizeStandardFileExtensions();
+    }
+    
+    /**
+     * Tells if this setting is set directly in this object or its value is coming from the {@link #getParent() parent}.
+     */
+    public boolean isRecognizeStandardFileExtensionsSet() {
+        return recognizeStandardFileExtensions != null;
+    }
+
+    public String getEncoding() {
+        return encoding != null ? encoding : getNonNullParentConfiguration().getDefaultEncoding();
+    }
+
+    /**
+     * When the standard template loading/caching mechanism is used, this forces the charset used for reading the
+     * template "file", overriding everything but the encoding coming from the {@code #ftl} header. This setting
+     * overrides the locale-specific encodings set via {@link Configuration#setEncoding(java.util.Locale, String)}. It
+     * also overrides the {@code encoding} parameter of {@link Configuration#getTemplate(String, String)} (and of its
+     * overloads) and the {@code encoding} parameter of the {@code #include} directive. This works like that because
+     * specifying the encoding where you are requesting the template is error prone and deprecated.
+     * 
+     * <p>
+     * If you are developing your own template loading/caching mechanism instead of the standard one, note that the
+     * above behavior is not guaranteed by this class alone; you have to ensure it. Also, read the note on
+     * {@code encoding} in the documentation of {@link #apply(Template)}.
+     */
+    public void setEncoding(String encoding) {
+        _NullArgumentException.check("encoding", encoding);
+        this.encoding = encoding;
+    }
+
+    public boolean isEncodingSet() {
+        return encoding != null;
+    }
+    
+    /**
+     * See {@link Configuration#setTabSize(int)}. 
+     * 
+     * @since 2.3.25
+     */
+    public void setTabSize(int tabSize) {
+        this.tabSize = Integer.valueOf(tabSize);
+    }
+
+    /**
+     * Getter pair of {@link #setTabSize(int)}.
+     * 
+     * @since 2.3.25
+     */
+    @Override
+    public int getTabSize() {
+        return tabSize != null ? tabSize.intValue()
+                : getNonNullParentConfiguration().getTabSize();
+    }
+    
+    /**
+     * Tells if this setting is set directly in this object or its value is coming from the {@link #getParent() parent}.
+     * 
+     * @since 2.3.25
+     */
+    public boolean isTabSizeSet() {
+        return tabSize != null;
+    }
+    
+    /**
+     * Returns {@link Configuration#getIncompatibleImprovements()} from the parent {@link Configuration}. This mostly
+     * just exist to satisfy the {@link ParserConfiguration} interface.
+     * 
+     * @throws IllegalStateException
+     *             If the parent configuration wasn't yet set.
+     */
+    @Override
+    public Version getIncompatibleImprovements() {
+        return getNonNullParentConfiguration().getIncompatibleImprovements();
+    }
+    
+    
+
+    @Override
+    public Locale getLocale() {
+        try {
+            return super.getLocale();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public TimeZone getTimeZone() {
+        try {
+            return super.getTimeZone();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public TimeZone getSQLDateAndTimeTimeZone() {
+        try {
+            return super.getSQLDateAndTimeTimeZone();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public String getNumberFormat() {
+        try {
+            return super.getNumberFormat();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public Map<String, ? extends TemplateNumberFormatFactory> getCustomNumberFormats() {
+        try {
+            return super.getCustomNumberFormats();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public TemplateNumberFormatFactory getCustomNumberFormat(String name) {
+        try {
+            return super.getCustomNumberFormat(name);
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public boolean hasCustomFormats() {
+        try {
+            return super.hasCustomFormats();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public String getBooleanFormat() {
+        try {
+            return super.getBooleanFormat();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public String getTimeFormat() {
+        try {
+            return super.getTimeFormat();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public String getDateFormat() {
+        try {
+            return super.getDateFormat();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public String getDateTimeFormat() {
+        try {
+            return super.getDateTimeFormat();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public Map<String, ? extends TemplateDateFormatFactory> getCustomDateFormats() {
+        try {
+            return super.getCustomDateFormats();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public TemplateDateFormatFactory getCustomDateFormat(String name) {
+        try {
+            return super.getCustomDateFormat(name);
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public TemplateExceptionHandler getTemplateExceptionHandler() {
+        try {
+            return super.getTemplateExceptionHandler();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public ArithmeticEngine getArithmeticEngine() {
+        try {
+            return super.getArithmeticEngine();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public ObjectWrapper getObjectWrapper() {
+        try {
+            return super.getObjectWrapper();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public String getOutputEncoding() {
+        try {
+            return super.getOutputEncoding();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public String getURLEscapingCharset() {
+        try {
+            return super.getURLEscapingCharset();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public TemplateClassResolver getNewBuiltinClassResolver() {
+        try {
+            return super.getNewBuiltinClassResolver();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public boolean getAutoFlush() {
+        try {
+            return super.getAutoFlush();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public boolean getShowErrorTips() {
+        try {
+            return super.getShowErrorTips();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public boolean isAPIBuiltinEnabled() {
+        try {
+            return super.isAPIBuiltinEnabled();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public boolean getLogTemplateExceptions() {
+        try {
+            return super.getLogTemplateExceptions();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public boolean getLazyImports() {
+        try {
+            return super.getLazyImports();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public Boolean getLazyAutoImports() {
+        try {
+            return super.getLazyAutoImports();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public Map<String, String> getAutoImports() {
+        try {
+            return super.getAutoImports();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public List<String> getAutoIncludes() {
+        try {
+            return super.getAutoIncludes();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public String[] getCustomAttributeNames() {
+        try {
+            return super.getCustomAttributeNames();
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    @Override
+    public Object getCustomAttribute(String name) {
+        try {
+            return super.getCustomAttribute(name);
+        } catch (NullPointerException e) {
+            getNonNullParentConfiguration();
+            throw e;
+        }
+    }
+
+    private boolean hasAnyConfigurableSet() {
+        return
+                isAPIBuiltinEnabledSet()
+                || isArithmeticEngineSet()
+                || isAutoFlushSet()
+                || isAutoImportsSet()
+                || isAutoIncludesSet()
+                || isBooleanFormatSet()
+                || isCustomDateFormatsSet()
+                || isCustomNumberFormatsSet()
+                || isDateFormatSet()
+                || isDateTimeFormatSet()
+                || isLazyImportsSet()
+                || isLazyAutoImportsSet()
+                || isLocaleSet()
+                || isLogTemplateExceptionsSet()
+                || isNewBuiltinClassResolverSet()
+                || isNumberFormatSet()
+                || isObjectWrapperSet()
+                || isOutputEncodingSet()
+                || isShowErrorTipsSet()
+                || isSQLDateAndTimeTimeZoneSet()
+                || isTemplateExceptionHandlerSet()
+                || isTimeFormatSet()
+                || isTimeZoneSet()
+                || isURLEscapingCharsetSet();
+    }
+    
+    private Map mergeMaps(Map m1, Map m2, boolean overwriteUpdatesOrder) {
+        if (m1 == null) return m2;
+        if (m2 == null) return m1;
+        if (m1.isEmpty()) return m2 != null ? m2 : m1;
+        if (m2.isEmpty()) return m1 != null ? m1 : m2;
+        
+        LinkedHashMap mergedM = new LinkedHashMap((m1.size() + m2.size()) * 4 / 3 + 1, 0.75f);
+        mergedM.putAll(m1);
+        for (Object m2Key : m2.keySet()) {
+            mergedM.remove(m2Key); // So that duplicate keys are moved after m1 keys
+        }
+        mergedM.putAll(m2);
+        return mergedM;
+    }
+
+    private List<String> mergeLists(List<String> list1, List<String> list2) {
+        if (list1 == null) return list2;
+        if (list2 == null) return list1;
+        if (list1.isEmpty()) return list2 != null ? list2 : list1;
+        if (list2.isEmpty()) return list1 != null ? list1 : list2;
+        
+        ArrayList<String> mergedList = new ArrayList<>(list1.size() + list2.size());
+        mergedList.addAll(list1);
+        mergedList.addAll(list2);
+        return mergedList;
+    }
+    
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateDateFormat.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateDateFormat.java b/src/main/java/org/apache/freemarker/core/TemplateDateFormat.java
new file mode 100644
index 0000000..07ee8ee
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateDateFormat.java
@@ -0,0 +1,108 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import java.text.DateFormat;
+import java.util.Date;
+
+import org.apache.freemarker.core.model.TemplateDateModel;
+import org.apache.freemarker.core.model.TemplateModelException;
+
+/**
+ * Represents a date/time/dateTime format; used in templates for formatting and parsing with that format. This is
+ * similar to Java's {@link DateFormat}, but made to fit the requirements of FreeMarker. Also, it makes easier to define
+ * formats that can't be represented with Java's existing {@link DateFormat} implementations.
+ * 
+ * <p>
+ * Implementations need not be thread-safe if the {@link TemplateNumberFormatFactory} doesn't recycle them among
+ * different {@link Environment}-s. As far as FreeMarker's concerned, instances are bound to a single
+ * {@link Environment}, and {@link Environment}-s are thread-local objects.
+ * 
+ * @since 2.3.24
+ */
+public abstract class TemplateDateFormat extends TemplateValueFormat {
+    
+    /**
+     * @param dateModel
+     *            The date/time/dateTime to format; not {@code null}. Most implementations will just work with the return value of
+     *            {@link TemplateDateModel#getAsDate()}, but some may format differently depending on the properties of
+     *            a custom {@link TemplateDateModel} implementation.
+     * 
+     * @return The date/time/dateTime as text, with no escaping (like no HTML escaping); can't be {@code null}.
+     * 
+     * @throws TemplateValueFormatException
+     *             When a problem occurs during the formatting of the value. Notable subclass:
+     *             {@link UnknownDateTypeFormattingUnsupportedException}
+     * @throws TemplateModelException
+     *             Exception thrown by the {@code dateModel} object when calling its methods.
+     */
+    public abstract String formatToPlainText(TemplateDateModel dateModel)
+            throws TemplateValueFormatException, TemplateModelException;
+
+    /**
+     * Formats the model to markup instead of to plain text if the result markup will be more than just plain text
+     * escaped, otherwise falls back to formatting to plain text. If the markup result would be just the result of
+     * {@link #formatToPlainText(TemplateDateModel)} escaped, it must return the {@link String} that
+     * {@link #formatToPlainText(TemplateDateModel)} does.
+     * 
+     * <p>The implementation in {@link TemplateDateFormat} simply calls {@link #formatToPlainText(TemplateDateModel)}.
+     * 
+     * @return A {@link String} or a {@link TemplateMarkupOutputModel}; not {@code null}.
+     */
+    public Object format(TemplateDateModel dateModel) throws TemplateValueFormatException, TemplateModelException {
+        return formatToPlainText(dateModel);
+    }
+
+    /**
+     * Parsers a string to date/time/datetime, according to this format. Some format implementations may throw
+     * {@link ParsingNotSupportedException} here. 
+     * 
+     * @param s
+     *            The string to parse
+     * @param dateType
+     *            The expected date type of the result. Not all {@link TemplateDateFormat}-s will care about this;
+     *            though those who return a {@link TemplateDateModel} instead of {@link Date} often will. When strings
+     *            are parsed via {@code ?date}, {@code ?time}, or {@code ?datetime}, then this parameter is
+     *            {@link TemplateDateModel#DATE}, {@link TemplateDateModel#TIME}, or {@link TemplateDateModel#DATETIME},
+     *            respectively. This parameter rarely if ever {@link TemplateDateModel#UNKNOWN}, but the implementation
+     *            that cares about this parameter should be prepared for that. If nothing else, it should throw
+     *            {@link UnknownDateTypeParsingUnsupportedException} then.
+     * 
+     * @return The interpretation of the text either as a {@link Date} or {@link TemplateDateModel}. Typically, a
+     *         {@link Date}. {@link TemplateDateModel} is used if you have to attach some application-specific
+     *         meta-information thats also extracted during {@link #formatToPlainText(TemplateDateModel)} (so if you format
+     *         something and then parse it, you get back an equivalent result). It can't be {@code null}. Known issue
+     *         (at least in FTL 2): {@code ?date}/{@code ?time}/{@code ?datetime}, when not invoked as a method, can't
+     *         return the {@link TemplateDateModel}, only the {@link Date} from inside it, hence the additional
+     *         application-specific meta-info will be lost.
+     */
+    public abstract Object parse(String s, int dateType) throws TemplateValueFormatException;
+    
+    /**
+     * Tells if this formatter should be re-created if the locale changes.
+     */
+    public abstract boolean isLocaleBound();
+
+    /**
+     * Tells if this formatter should be re-created if the time zone changes. Currently always {@code true}.
+     */
+    public abstract boolean isTimeZoneBound();
+        
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateDateFormatFactory.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateDateFormatFactory.java b/src/main/java/org/apache/freemarker/core/TemplateDateFormatFactory.java
new file mode 100644
index 0000000..6a6fb14
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateDateFormatFactory.java
@@ -0,0 +1,91 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+import java.util.TimeZone;
+
+import org.apache.freemarker.core.model.TemplateDateModel;
+
+/**
+ * Factory for a certain kind of date/time/dateTime formatting ({@link TemplateDateFormat}). Usually a singleton
+ * (one-per-VM or one-per-{@link Configuration}), and so must be thread-safe.
+ * 
+ * @see Configurable#setCustomDateFormats(java.util.Map)
+ * 
+ * @since 2.3.24
+ */
+public abstract class TemplateDateFormatFactory extends TemplateValueFormatFactory {
+    
+    /**
+     * Returns a formatter for the given parameters.
+     * 
+     * <p>
+     * The returned formatter can be a new instance or a reused (cached) instance. Note that {@link Environment} itself
+     * caches the returned instances, though that cache is lost with the {@link Environment} (i.e., when the top-level
+     * template execution ends), also it might flushes lot of entries if the locale or time zone is changed during
+     * template execution. So caching on the factory level is still useful, unless creating the formatters is
+     * sufficiently cheap.
+     * 
+     * @param params
+     *            The string that further describes how the format should look. For example, when the
+     *            {@link Configurable#getDateFormat() dateFormat} is {@code "@fooBar 1, 2"}, then it will be
+     *            {@code "1, 2"} (and {@code "@fooBar"} selects the factory). The format of this string is up to the
+     *            {@link TemplateDateFormatFactory} implementation. Not {@code null}, often an empty string.
+     * @param dateType
+     *            {@link TemplateDateModel#DATE}, {@link TemplateDateModel#TIME}, {@link TemplateDateModel#DATETIME} or
+     *            {@link TemplateDateModel#UNKNOWN}. Supporting {@link TemplateDateModel#UNKNOWN} is not necessary, in
+     *            which case the method should throw an {@link UnknownDateTypeFormattingUnsupportedException} exception.
+     * @param locale
+     *            The locale to format for. Not {@code null}. The resulting format should be bound to this locale
+     *            forever (i.e. locale changes in the {@link Environment} must not be followed).
+     * @param timeZone
+     *            The time zone to format for. Not {@code null}. The resulting format must be bound to this time zone
+     *            forever (i.e. time zone changes in the {@link Environment} must not be followed).
+     * @param zonelessInput
+     *            Indicates that the input Java {@link Date} is not from a time zone aware source. When this is
+     *            {@code true}, the formatters shouldn't override the time zone provided to its constructor (most
+     *            formatters don't do that anyway), and it shouldn't show the time zone, if it can hide it (like a
+     *            {@link SimpleDateFormat} pattern-based formatter may can't do that, as the pattern prescribes what to
+     *            show).
+     *            <p>
+     *            As of FreeMarker 2.3.21, this is {@code true} exactly when the date is an SQL "date without time of
+     *            the day" (i.e., a {@link java.sql.Date java.sql.Date}) or an SQL "time of the day" value (i.e., a
+     *            {@link java.sql.Time java.sql.Time}, although this rule can change in future, depending on
+     *            configuration settings and such, so you shouldn't rely on this rule, just accept what this parameter
+     *            says.
+     * @param env
+     *            The runtime environment from which the formatting was called. This is mostly meant to be used for
+     *            {@link Environment#setCustomState(Object, Object)}/{@link Environment#getCustomState(Object)}.
+     * 
+     * @throws TemplateValueFormatException
+     *             If any problem occurs while parsing/getting the format. Notable subclasses:
+     *             {@link InvalidFormatParametersException} if {@code params} is malformed;
+     *             {@link UnknownDateTypeFormattingUnsupportedException} if {@code dateType} is
+     *             {@link TemplateDateModel#UNKNOWN} and that's unsupported by this factory.
+     */
+    public abstract TemplateDateFormat get(
+            String params,
+            int dateType, Locale locale, TimeZone timeZone, boolean zonelessInput,
+            Environment env)
+                    throws TemplateValueFormatException;
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateElementArrayBuilder.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateElementArrayBuilder.java b/src/main/java/org/apache/freemarker/core/TemplateElementArrayBuilder.java
new file mode 100644
index 0000000..cbe745c
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateElementArrayBuilder.java
@@ -0,0 +1,102 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import org.apache.freemarker.core.util._CollectionUtil;
+
+/**
+ * Holds an buffer (array) of {@link _ASTElement}-s with the count of the utilized items in it. The un-utilized tail
+ * of the array must only contain {@code null}-s.
+ * 
+ * @since 2.3.24
+ */
+class TemplateElements {
+    
+    static final TemplateElements EMPTY = new TemplateElements(null, 0);
+
+    private final _ASTElement[] buffer;
+    private final int count;
+
+    /**
+     * @param buffer
+     *            The buffer; {@code null} exactly if {@code count} is 0.
+     * @param count
+     *            The number of utilized buffer elements; if 0, then {@code null} must be {@code null}.
+     */
+    TemplateElements(_ASTElement[] buffer, int count) {
+        /*
+        // Assertion:
+        if (count == 0 && buffer != null) {
+            throw new IllegalArgumentException(); 
+        }
+        */
+        
+        this.buffer = buffer;
+        this.count = count;
+    }
+
+    _ASTElement[] getBuffer() {
+        return buffer;
+    }
+
+    int getCount() {
+        return count;
+    }
+
+    _ASTElement getFirst() {
+        return buffer != null ? buffer[0] : null;
+    }
+    
+    _ASTElement getLast() {
+        return buffer != null ? buffer[count - 1] : null;
+    }
+    
+    /**
+     * Used for some backward compatibility hacks.
+     */
+    _ASTElement asSingleElement() {
+        if (count == 0) {
+            return new ASTStaticText(_CollectionUtil.EMPTY_CHAR_ARRAY, false);
+        } else {
+            _ASTElement first = buffer[0];
+            if (count == 1) {
+                return first;
+            } else {
+                ASTImplicitParent mixedContent = new ASTImplicitParent();
+                mixedContent.setChildren(this);
+                mixedContent.setLocation(first.getTemplate(), first, getLast());
+                return mixedContent;
+            }
+        }
+    }
+    
+    /**
+     * Used for some backward compatibility hacks.
+     */
+    ASTImplicitParent asMixedContent() {
+        ASTImplicitParent mixedContent = new ASTImplicitParent();
+        if (count != 0) {
+            _ASTElement first = buffer[0];
+            mixedContent.setChildren(this);
+            mixedContent.setLocation(first.getTemplate(), first, getLast());
+        }
+        return mixedContent;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateElementsToVisit.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateElementsToVisit.java b/src/main/java/org/apache/freemarker/core/TemplateElementsToVisit.java
new file mode 100644
index 0000000..bd9d473
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateElementsToVisit.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * Used as the return value of {@link _ASTElement#accept(Environment)} when the invoked element has nested elements
+ * to invoke. It would be more natural to invoke child elements before returning from
+ * {@link _ASTElement#accept(Environment)}, however, if there's nothing to do after the child elements were invoked,
+ * that would mean wasting stack space.
+ * 
+ * @since 2.3.24
+ */
+class TemplateElementsToVisit {
+
+    private final Collection<_ASTElement> templateElements;
+
+    TemplateElementsToVisit(Collection<_ASTElement> templateElements) {
+        this.templateElements = null != templateElements ? templateElements : Collections.<_ASTElement> emptyList();
+    }
+
+    TemplateElementsToVisit(_ASTElement nestedBlock) {
+        this(Collections.singleton(nestedBlock));
+    }
+
+    Collection<_ASTElement> getTemplateElements() {
+        return templateElements;
+    }
+    
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateException.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateException.java b/src/main/java/org/apache/freemarker/core/TemplateException.java
index d1d9a02..4ed9beb 100644
--- a/src/main/java/org/apache/freemarker/core/TemplateException.java
+++ b/src/main/java/org/apache/freemarker/core/TemplateException.java
@@ -27,14 +27,6 @@ import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.lang.reflect.Method;
 
-import org.apache.freemarker.core.ast.Environment;
-import org.apache.freemarker.core.ast.Expression;
-import org.apache.freemarker.core.ast.InvalidReferenceException;
-import org.apache.freemarker.core.ast.ParseException;
-import org.apache.freemarker.core.ast.TemplateElement;
-import org.apache.freemarker.core.ast.TemplateObject;
-import org.apache.freemarker.core.ast._CoreAPI;
-import org.apache.freemarker.core.ast._ErrorDescriptionBuilder;
 import org.apache.freemarker.core.util._CollectionUtil;
 
 /**
@@ -49,8 +41,8 @@ public class TemplateException extends Exception {
     // Set in constructor:
     private transient _ErrorDescriptionBuilder descriptionBuilder;
     private final transient Environment env;
-    private final transient Expression blamedExpression;
-    private transient TemplateElement[] ftlInstructionStackSnapshot;
+    private final transient ASTExpression blamedExpression;
+    private transient _ASTElement[] ftlInstructionStackSnapshot;
     
     // Calculated on demand:
     private String renderedFtlInstructionStackSnapshot;  // clalc. from ftlInstructionStackSnapshot 
@@ -140,7 +132,7 @@ public class TemplateException extends Exception {
      *          with "template element" granularity, and this can be used to point to the expression inside the
      *          template element.    
      */
-    protected TemplateException(Throwable cause, Environment env, Expression blamedExpr,
+    protected TemplateException(Throwable cause, Environment env, ASTExpression blamedExpr,
             _ErrorDescriptionBuilder descriptionBuilder) {
         this(null, cause, env, blamedExpr, descriptionBuilder);
     }
@@ -148,7 +140,7 @@ public class TemplateException extends Exception {
     private TemplateException(
             String renderedDescription,
             Throwable cause,            
-            Environment env, Expression blamedExpression,
+            Environment env, ASTExpression blamedExpression,
             _ErrorDescriptionBuilder descriptionBuilder) {
         // Note: Keep this constructor lightweight.
         
@@ -194,7 +186,7 @@ public class TemplateException extends Exception {
         synchronized (lock) {
             if (!positionsCalculated) {
                 // The expressions is the argument of the template element, so we prefer it as it's more specific. 
-                TemplateObject templateObject = blamedExpression != null
+                ASTNode templateObject = blamedExpression != null
                         ? blamedExpression
                         : (
                                 ftlInstructionStackSnapshot != null && ftlInstructionStackSnapshot.length != 0
@@ -284,7 +276,7 @@ public class TemplateException extends Exception {
         }
     }
 
-    private TemplateElement getFailingInstruction() {
+    private _ASTElement getFailingInstruction() {
         if (ftlInstructionStackSnapshot != null && ftlInstructionStackSnapshot.length > 0) {
             return ftlInstructionStackSnapshot[0];
         } else {
@@ -539,7 +531,7 @@ public class TemplateException extends Exception {
         }
     }
     
-    Expression getBlamedExpression() {
+    ASTExpression getBlamedExpression() {
         return blamedExpression;
     }
 

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateExceptionHandler.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateExceptionHandler.java b/src/main/java/org/apache/freemarker/core/TemplateExceptionHandler.java
index ef871c1..baec030 100644
--- a/src/main/java/org/apache/freemarker/core/TemplateExceptionHandler.java
+++ b/src/main/java/org/apache/freemarker/core/TemplateExceptionHandler.java
@@ -23,9 +23,6 @@ import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.io.Writer;
 
-import org.apache.freemarker.core.ast.Configurable;
-import org.apache.freemarker.core.ast.Environment;
-import org.apache.freemarker.core.ast.StopException;
 import org.apache.freemarker.core.util._StringUtil;
 
 /**

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateFormatUtil.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateFormatUtil.java b/src/main/java/org/apache/freemarker/core/TemplateFormatUtil.java
new file mode 100644
index 0000000..c43d7f2
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateFormatUtil.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import java.util.Date;
+
+import org.apache.freemarker.core.model.ObjectWrapper;
+import org.apache.freemarker.core.model.TemplateDateModel;
+import org.apache.freemarker.core.model.TemplateModelException;
+import org.apache.freemarker.core.model.TemplateNumberModel;
+
+/**
+ * Utility classes for implementing {@link TemplateValueFormat}-s.
+ * 
+ * @since 2.3.24 
+ */
+public final class TemplateFormatUtil {
+    
+    private TemplateFormatUtil() {
+        // Not meant to be instantiated
+    }
+
+    public static void checkHasNoParameters(String params) throws InvalidFormatParametersException
+             {
+        if (params.length() != 0) {
+            throw new InvalidFormatParametersException(
+                    "This number format doesn't support any parameters.");
+        }
+    }
+
+    /**
+     * Utility method to extract the {@link Number} from an {@link TemplateNumberModel}, and throws
+     * {@link TemplateModelException} with a standard error message if that's {@code null}. {@link TemplateNumberModel}
+     * that store {@code null} are in principle not allowed, and so are considered to be bugs in the
+     * {@link ObjectWrapper} or {@link TemplateNumberModel} implementation.
+     */
+    public static Number getNonNullNumber(TemplateNumberModel numberModel)
+            throws TemplateModelException, UnformattableValueException {
+        Number number = numberModel.getAsNumber();
+        if (number == null) {
+            throw EvalUtil.newModelHasStoredNullException(Number.class, numberModel, null);
+        }
+        return number;
+    }
+
+    /**
+     * Utility method to extract the {@link Date} from an {@link TemplateDateModel}, and throw
+     * {@link TemplateModelException} with a standard error message if that's {@code null}. {@link TemplateDateModel}
+     * that store {@code null} are in principle not allowed, and so are considered to be bugs in the
+     * {@link ObjectWrapper} or {@link TemplateNumberModel} implementation.
+     */
+    public static Date getNonNullDate(TemplateDateModel dateModel) throws TemplateModelException {
+        Date date = dateModel.getAsDate();
+        if (date == null) {
+            throw EvalUtil.newModelHasStoredNullException(Date.class, dateModel, null);
+        }
+        return date;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateHTMLOutputModel.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateHTMLOutputModel.java b/src/main/java/org/apache/freemarker/core/TemplateHTMLOutputModel.java
new file mode 100644
index 0000000..f4acd01
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateHTMLOutputModel.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+/**
+ * Stores HTML markup to be printed; used with {@link HTMLOutputFormat}.
+ * 
+ * @since 2.3.24
+ */
+public final class TemplateHTMLOutputModel extends CommonTemplateMarkupOutputModel<TemplateHTMLOutputModel> {
+    
+    /**
+     * See {@link CommonTemplateMarkupOutputModel#CommonTemplateMarkupOutputModel(String, String)}.
+     */
+    TemplateHTMLOutputModel(String plainTextContent, String markupContent) {
+        super(plainTextContent, markupContent);
+    }
+
+    @Override
+    public HTMLOutputFormat getOutputFormat() {
+        return HTMLOutputFormat.INSTANCE;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateMarkupOutputModel.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateMarkupOutputModel.java b/src/main/java/org/apache/freemarker/core/TemplateMarkupOutputModel.java
new file mode 100644
index 0000000..1d4c5af
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateMarkupOutputModel.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import org.apache.freemarker.core.model.TemplateModel;
+import org.apache.freemarker.core.model.TemplateScalarModel;
+
+/**
+ * "markup output" template language data-type; stores markup (some kind of "rich text" / structured format, as opposed
+ * to plain text) that meant to be printed as template output. This type is related to the {@link OutputFormat}
+ * mechanism. Values of this kind are exempt from {@link OutputFormat}-based automatic escaping.
+ * 
+ * <p>
+ * Each implementation of this type has a {@link OutputFormat} subclass pair, whose singleton instance is returned by
+ * {@link #getOutputFormat()}. See more about how markup output values work at {@link OutputFormat}.
+ * 
+ * <p>
+ * Note that {@link TemplateMarkupOutputModel}-s are by design not treated like {@link TemplateScalarModel}-s, and so
+ * the implementations of this interface usually shouldn't implement {@link TemplateScalarModel}. (Because, operations
+ * applicable on plain strings, like converting to upper case, substringing, etc., can corrupt markup.) If the template
+ * author wants to pass in the "source" of the markup as string somewhere, he should use {@code ?markup_string}.
+ * 
+ * @param <MO>
+ *            Refers to the interface's own type, which is useful in interfaces that extend
+ *            {@link TemplateMarkupOutputModel} (Java Generics trick).
+ * 
+ * @since 2.3.24
+ */
+public interface TemplateMarkupOutputModel<MO extends TemplateMarkupOutputModel<MO>> extends TemplateModel {
+
+    /**
+     * Returns the singleton {@link OutputFormat} object that implements the operations for the "markup output" value.
+     */
+    MarkupOutputFormat<MO> getOutputFormat();
+    
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateNumberFormat.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateNumberFormat.java b/src/main/java/org/apache/freemarker/core/TemplateNumberFormat.java
new file mode 100644
index 0000000..f4f4e70
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateNumberFormat.java
@@ -0,0 +1,90 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import java.text.NumberFormat;
+
+import org.apache.freemarker.core.model.TemplateDateModel;
+import org.apache.freemarker.core.model.TemplateModelException;
+import org.apache.freemarker.core.model.TemplateNumberModel;
+
+/**
+ * Represents a number format; used in templates for formatting and parsing with that format. This is similar to Java's
+ * {@link NumberFormat}, but made to fit the requirements of FreeMarker. Also, it makes easier to define formats that
+ * can't be represented with Java's existing {@link NumberFormat} implementations.
+ * 
+ * <p>
+ * Implementations need not be thread-safe if the {@link TemplateNumberFormatFactory} doesn't recycle them among
+ * different {@link Environment}-s. As far as FreeMarker's concerned, instances are bound to a single
+ * {@link Environment}, and {@link Environment}-s are thread-local objects.
+ * 
+ * @since 2.3.24
+ */
+public abstract class TemplateNumberFormat extends TemplateValueFormat {
+
+    /**
+     * @param numberModel
+     *            The number to format; not {@code null}. Most implementations will just work with the return value of
+     *            {@link TemplateDateModel#getAsDate()}, but some may format differently depending on the properties of
+     *            a custom {@link TemplateDateModel} implementation.
+     *            
+     * @return The number as text, with no escaping (like no HTML escaping); can't be {@code null}.
+     * 
+     * @throws TemplateValueFormatException
+     *             If any problem occurs while parsing/getting the format. Notable subclass:
+     *             {@link UnformattableValueException}.
+     * @throws TemplateModelException
+     *             Exception thrown by the {@code dateModel} object when calling its methods.
+     */
+    public abstract String formatToPlainText(TemplateNumberModel numberModel)
+            throws TemplateValueFormatException, TemplateModelException;
+
+    /**
+     * Formats the model to markup instead of to plain text if the result markup will be more than just plain text
+     * escaped, otherwise falls back to formatting to plain text. If the markup result would be just the result of
+     * {@link #formatToPlainText(TemplateNumberModel)} escaped, it must return the {@link String} that
+     * {@link #formatToPlainText(TemplateNumberModel)} does.
+     * 
+     * <p>
+     * The implementation in {@link TemplateNumberFormat} simply calls {@link #formatToPlainText(TemplateNumberModel)}.
+     * 
+     * @return A {@link String} or a {@link TemplateMarkupOutputModel}; not {@code null}.
+     */
+    public Object format(TemplateNumberModel numberModel)
+            throws TemplateValueFormatException, TemplateModelException {
+        return formatToPlainText(numberModel);
+    }
+    
+    /**
+     * Tells if this formatter should be re-created if the locale changes.
+     */
+    public abstract boolean isLocaleBound();
+
+    /**
+     * This method is reserved for future purposes; currently it always throws {@link ParsingNotSupportedException}. We
+     * don't yet support number parsing with {@link TemplateNumberFormat}-s, because currently FTL parses strings to
+     * number with the {@link ArithmeticEngine} ({@link TemplateNumberFormat} were only introduced in 2.3.24). If it
+     * will be support, it will be similar to {@link TemplateDateFormat#parse(String, int)}.
+     */
+    public final Object parse(String s) throws TemplateValueFormatException {
+        throw new ParsingNotSupportedException("Number formats currenly don't support parsing");
+    }
+    
+    
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateNumberFormatFactory.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateNumberFormatFactory.java b/src/main/java/org/apache/freemarker/core/TemplateNumberFormatFactory.java
new file mode 100644
index 0000000..4decb91
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateNumberFormatFactory.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+import java.util.Locale;
+
+/**
+ * Factory for a certain kind of number formatting ({@link TemplateNumberFormat}). Usually a singleton (one-per-VM or
+ * one-per-{@link Configuration}), and so must be thread-safe.
+ * 
+ * @see Configurable#setCustomNumberFormats(java.util.Map)
+ * 
+ * @since 2.3.24
+ */
+public abstract class TemplateNumberFormatFactory extends TemplateValueFormatFactory {
+
+    /**
+     * Returns a formatter for the given parameters.
+     * 
+     * <p>
+     * The returned formatter can be a new instance or a reused (cached) instance. Note that {@link Environment} itself
+     * caches the returned instances, though that cache is lost with the {@link Environment} (i.e., when the top-level
+     * template execution ends), also it might flushes lot of entries if the locale or time zone is changed during
+     * template execution. So caching on the factory level is still useful, unless creating the formatters is
+     * sufficiently cheap.
+     * 
+     * @param params
+     *            The string that further describes how the format should look. For example, when the
+     *            {@link Configurable#getNumberFormat() numberFormat} is {@code "@fooBar 1, 2"}, then it will be
+     *            {@code "1, 2"} (and {@code "@fooBar"} selects the factory). The format of this string is up to the
+     *            {@link TemplateNumberFormatFactory} implementation. Not {@code null}, often an empty string.
+     * @param locale
+     *            The locale to format for. Not {@code null}. The resulting format must be bound to this locale
+     *            forever (i.e. locale changes in the {@link Environment} must not be followed).
+     * @param env
+     *            The runtime environment from which the formatting was called. This is mostly meant to be used for
+     *            {@link Environment#setCustomState(Object, Object)}/{@link Environment#getCustomState(Object)}.
+     *            
+     * @throws TemplateValueFormatException
+     *             if any problem occurs while parsing/getting the format. Notable subclasses:
+     *             {@link InvalidFormatParametersException} if the {@code params} is malformed.
+     */
+    public abstract TemplateNumberFormat get(String params, Locale locale, Environment env)
+            throws TemplateValueFormatException;
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplatePostProcessor.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplatePostProcessor.java b/src/main/java/org/apache/freemarker/core/TemplatePostProcessor.java
new file mode 100644
index 0000000..f49a7b5
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplatePostProcessor.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+/**
+ * Note yet public; will change in 2.4 (as it has to process {@code UnboundTemplate}-s).
+ */
+abstract class TemplatePostProcessor {
+
+    public abstract void postProcess(Template e) throws TemplatePostProcessorException;
+    
+    // TODO: getPriority, getPhase, getMustBeBefore, getMustBeAfter
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplatePostProcessorException.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplatePostProcessorException.java b/src/main/java/org/apache/freemarker/core/TemplatePostProcessorException.java
new file mode 100644
index 0000000..1904aa5
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplatePostProcessorException.java
@@ -0,0 +1,35 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+/**
+ * Not yet public; subject to change.
+ */
+class TemplatePostProcessorException extends Exception {
+
+    public TemplatePostProcessorException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public TemplatePostProcessorException(String message) {
+        super(message);
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-freemarker/blob/7d784b2b/src/main/java/org/apache/freemarker/core/TemplateRTFOutputModel.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/freemarker/core/TemplateRTFOutputModel.java b/src/main/java/org/apache/freemarker/core/TemplateRTFOutputModel.java
new file mode 100644
index 0000000..008737a
--- /dev/null
+++ b/src/main/java/org/apache/freemarker/core/TemplateRTFOutputModel.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you 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.apache.freemarker.core;
+
+/**
+ * Stores RTF markup to be printed; used with {@link RTFOutputFormat}.
+ * 
+ * @since 2.3.24
+ */
+public final class TemplateRTFOutputModel extends CommonTemplateMarkupOutputModel<TemplateRTFOutputModel> {
+    
+    /**
+     * See {@link CommonTemplateMarkupOutputModel#CommonTemplateMarkupOutputModel(String, String)}.
+     */
+    TemplateRTFOutputModel(String plainTextContent, String markupContent) {
+        super(plainTextContent, markupContent);
+    }
+
+    @Override
+    public RTFOutputFormat getOutputFormat() {
+        return RTFOutputFormat.INSTANCE;
+    }
+
+}


Mime
View raw message