//--- Constructor ---
public DekiScriptExpressionEvaluationState(DekiScriptEvalMode mode, DekiScriptEnv env, DekiScriptRuntime runtime) {
this.Mode = mode;
this.Env = env;
this.Namespaces = new XmlNamespaceManager(XDoc.XmlNameTable);
this.Buffer = new DekiScriptOutputBuffer();
this.Runtime = runtime;
_safe = (mode == DekiScriptEvalMode.EvaluateSafeMode);
}
public DekiScriptExpressionEvaluationState(DekiScriptEvalMode mode, DekiScriptEnv env, DekiScriptRuntime runtime, XmlNamespaceManager namespaces, DekiScriptOutputBuffer buffer) {
this.Mode = mode;
this.Env = env;
this.Namespaces = namespaces;
this.Buffer = buffer;
this.Runtime = runtime;
_safe = (mode == DekiScriptEvalMode.EvaluateSafeMode);
}
public virtual DekiScriptLiteral Evaluate(DekiScriptExpression expr, DekiScriptEvalMode mode, DekiScriptEnv env)
{
DekiScriptExpressionEvaluationState state = new DekiScriptExpressionEvaluationState(mode, env, this, EvaluationTimeout, GetMaxOutputSize(mode));
try {
return(state.Pop(expr.VisitWith(DekiScriptExpressionEvaluation.Instance, state)));
} catch (DekiScriptReturnException e) {
state.Push(e.Value);
return(state.PopAll());
}
}
public XDoc Evaluate(DekiScriptDom expr, DekiScriptEvalMode mode, bool fallthrough, DekiScriptEnv env)
{
DekiScriptEvalContext context = new DekiScriptEvalContext(mode, fallthrough);
try {
expr.VisitWith(this, new DekiScriptDomEvaluationState(context, context.Document, env));
} catch (DekiScriptDocumentTooLargeException) {
// this exception is thrown to unwind the DOM stack; we can safely ignore it
}
context.MergeContextIntoDocument(context.Document);
return(new XDoc(context.Document));
}
//--- Constructors ---
public DekiScriptEvalContext(XDoc document, DekiScriptEvalMode mode, bool fallthrough, int maxNodeCount) {
this.Document = document.AsXmlNode.OwnerDocument;
this.Mode = mode;
this.Fallthrough = fallthrough;
this.MaxNodeCount = maxNodeCount;
// verify that document is below the limit
_nodeCount = 2*document["body//*"].ListLength + document["body//text()"].ListLength;
if(_nodeCount >= this.MaxNodeCount) {
throw new DekiScriptDocumentTooLargeException(MaxNodeCount);
}
}
//--- Constructor ---
public DekiScriptExpressionEvaluationState(DekiScriptEvalMode mode, DekiScriptEnv env, DekiScriptRuntime runtime, TimeSpan evaluationTimeout, int maxOutputBufferSize) {
this.Env = env;
this.Namespaces = new XmlNamespaceManager(XDoc.XmlNameTable);
this.Buffer = new DekiScriptOutputBuffer(maxOutputBufferSize);
this.Runtime = runtime;
_sharedState = new SharedState();
_sharedState.Safe = (mode == DekiScriptEvalMode.EvaluateSafeMode);
if(evaluationTimeout == TimeSpan.MaxValue) {
return;
}
_sharedState.EvaluationTimeout = evaluationTimeout;
_sharedState.EvaluationTimer = Stopwatch.StartNew();
}
//--- Constructors ---
public DekiScriptEvalContext(XDoc document, DekiScriptEvalMode mode, bool fallthrough, int maxNodeCount)
{
this.Document = document.AsXmlNode.OwnerDocument;
this.Mode = mode;
this.Fallthrough = fallthrough;
this.MaxNodeCount = maxNodeCount;
// verify that document is below the limit
_nodeCount = 2 * document["body//*"].ListLength + document["body//text()"].ListLength;
if (_nodeCount >= this.MaxNodeCount)
{
throw new DekiScriptDocumentTooLargeException(MaxNodeCount);
}
}
//--- Constructor ---
public DekiScriptExpressionEvaluationState(DekiScriptEvalMode mode, DekiScriptEnv env, DekiScriptRuntime runtime, TimeSpan evaluationTimeout, int maxOutputBufferSize)
{
this.Env = env;
this.Namespaces = new XmlNamespaceManager(XDoc.XmlNameTable);
this.Buffer = new DekiScriptOutputBuffer(maxOutputBufferSize);
this.Runtime = runtime;
_sharedState = new SharedState();
_sharedState.Safe = (mode == DekiScriptEvalMode.EvaluateSafeMode);
if (evaluationTimeout == TimeSpan.MaxValue)
{
return;
}
_sharedState.EvaluationTimeout = evaluationTimeout;
_sharedState.EvaluationTimer = Stopwatch.StartNew();
}
public override int GetMaxOutputSize(DekiScriptEvalMode mode)
{
switch (mode)
{
case DekiScriptEvalMode.EvaluateEditOnly:
return(int.MaxValue);
case DekiScriptEvalMode.Evaluate:
case DekiScriptEvalMode.EvaluateSafeMode:
case DekiScriptEvalMode.EvaluateSaveOnly:
case DekiScriptEvalMode.None:
case DekiScriptEvalMode.Verify:
default:
return(_settings.GetValue("pages/max-page-size", MAX_OUTPUT_SIZE));
}
}
//--- Extension Methods ---
public static DekiScriptExpression Optimize(this DekiScriptRuntime runtime, DekiScriptExpression expr, DekiScriptEvalMode mode, DekiScriptEnv env)
{
return(expr.VisitWith(DekiScriptExpressionOptimizer.Instance, new DekiScriptExpressionEvaluationState(mode, env, runtime, TimeSpan.MaxValue, int.MaxValue)));
}
public override int GetMaxOutputSize(DekiScriptEvalMode mode) {
switch(mode) {
case DekiScriptEvalMode.EvaluateEditOnly:
return int.MaxValue;
case DekiScriptEvalMode.Evaluate:
case DekiScriptEvalMode.EvaluateSafeMode:
case DekiScriptEvalMode.EvaluateSaveOnly:
case DekiScriptEvalMode.None:
case DekiScriptEvalMode.Verify:
default:
return _settings.GetValue("pages/max-page-size", MAX_OUTPUT_SIZE);
}
}
public virtual DekiScriptLiteral Evaluate(DekiScriptExpression expr, DekiScriptEvalMode mode, DekiScriptEnv env) {
DekiScriptExpressionEvaluationState state = new DekiScriptExpressionEvaluationState(mode, env, this);
try {
return state.Pop(expr.VisitWith(DekiScriptExpressionEvaluation.Instance, state));
} catch(DekiScriptReturnException e) {
state.Push(e.Value);
return state.PopAll();
}
}
//--- Constructors ---
public DekiScriptOptimizerState(DekiScriptEvalMode mode, DekiScriptEnv env)
{
this.Mode = mode;
this.Env = env;
}
public virtual int GetMaxOutputSize(DekiScriptEvalMode mode)
{
return(MAX_OUTPUT_SIZE);
}
public DekiScriptEvalContext(XDoc document, DekiScriptEvalMode mode, bool fallthrough) {
this.Document = document.AsXmlNode.OwnerDocument;
this.Mode = mode;
this.Fallthrough = fallthrough;
}
//--- Constructors ---
public DekiScriptEvalContext(DekiScriptEvalMode mode, bool fallthrough) {
this.Document = new XmlDocument(XDoc.XmlNameTable);
this.Mode = mode;
this.Fallthrough = fallthrough;
}
public void EvaluateContent(XDoc script, DekiScriptEnv env, DekiScriptEvalMode mode, out bool scripted) {
scripted = false;
switch(mode) {
case DekiScriptEvalMode.None:
break;
case DekiScriptEvalMode.Evaluate:
case DekiScriptEvalMode.EvaluateSafeMode: {
var expr = DekiScriptParser.Parse(script);
try {
expr = DekiContext.Current.Instance.ScriptRuntime.Evaluate(expr, mode, env);
} catch(Exception e) {
var error = DekiScriptLibrary.MakeErrorObject(e, env);
DekiContext.Current.Instance.ScriptRuntime.LogExceptionInOutput(error);
expr = DekiScriptExpression.Constant(DekiScriptLibrary.WebShowError((Hashtable)error.NativeValue));
}
// check if outcome is an XML document
var xml = expr as DekiScriptXml;
if(xml != null) {
// check if outcome is the expected content document
if(xml.Value.HasName("content")) {
script.Replace(((DekiScriptXml)expr).Value);
} else {
// remove all contents from existing document and append new document
script.RemoveNodes();
script.Start("body").Add(xml.Value).End();
}
} else if(expr is DekiScriptString) {
// remove all contents from existing document and append new document
script.RemoveNodes();
script.Start("body").Value(((DekiScriptString)expr).Value).End();
} else {
// remove all contents from existing document and append new document
script.RemoveNodes();
script.Start("body").Value(expr.ToString()).End();
}
}
break;
case DekiScriptEvalMode.EvaluateEditOnly:
case DekiScriptEvalMode.EvaluateSaveOnly:
case DekiScriptEvalMode.Verify: {
DekiScriptEvalContext context = new DekiScriptEvalContext(script, mode, false, DekiContext.Current.Instance.ScriptRuntime.GetMaxOutputSize(mode));
// add <head> and <tail> sections
context.AddHeadElements(script);
context.AddTailElements(script);
script["head"].RemoveNodes();
script["tail"].RemoveNodes();
// evaluate the script
bool error = false;
DekiScriptInterpreter.Evaluate(script, (XmlElement)script.Root.AsXmlNode, context, env, DekiContext.Current.Instance.ScriptRuntime, out scripted, ref error);
if((mode == DekiScriptEvalMode.Verify) || !error) {
context.MergeContextIntoDocument(script.AsXmlNode.OwnerDocument);
}
}
break;
default:
throw new InvalidOperationException(string.Format("unrecognized evaluation mode '{0}'", mode));
}
}
private object Optimize(DekiScriptCaseBlock expr, DekiScriptExpression value, DekiScriptEvalMode mode, DekiScriptEnv env, out bool isDefaultCase)
{
List <DekiScriptExpression> conditions = new List <DekiScriptExpression>();
isDefaultCase = false;
for (int i = 0; i < expr.Conditions.Length; i++)
{
if (expr.Conditions[i] != null)
{
DekiScriptExpression condition = expr.Conditions[i].VisitWith(this, new DekiScriptOptimizerState(mode, env));
// check if condition always succeeds or always fails
if ((value is DekiScriptLiteral) && (condition is DekiScriptLiteral))
{
DekiScriptBinary test = new DekiScriptBinary(0, 0, DekiScriptBinary.Op.Equal, value, condition);
if (!test.Evaluate(env).IsNilFalseZero)
{
// NOTE (steveb): we wrap the outcome into a sequence to ensure proper handling of break/continue statements
// condition succeeded, return it
return(DekiScriptSequence.New(DekiScriptSequence.ScopeKind.ScopeCatchBreakAndContinue, expr.Body.VisitWith(this, new DekiScriptOptimizerState(mode, env))));
}
}
else
{
conditions.Add(condition);
}
}
else
{
isDefaultCase = true;
conditions.Add(null);
}
}
// check if any conditions were true or unknown
if (conditions.Count == 0)
{
return(null);
}
DekiScriptExpression body = expr.Body.VisitWith(this, new DekiScriptOptimizerState(mode, env));
return(new DekiScriptCaseBlock(conditions.ToArray(), body, expr.IsBlock));
}
//--- Extension Methods ---
public static DekiScriptExpression Optimize(this DekiScriptRuntime runtime, DekiScriptExpression expr, DekiScriptEvalMode mode, DekiScriptEnv env) {
return expr.VisitWith(DekiScriptExpressionOptimizer.Instance, new DekiScriptExpressionEvaluationState(mode, env, runtime));
}
public virtual int GetMaxOutputSize(DekiScriptEvalMode mode) {
return MAX_OUTPUT_SIZE;
}
