public void Init(MemoryPool pool) { SymbolLink self = new SymbolLink(typeof(IContextProvider)); pool.Bind(self); pool.SetData(self, this); SetValue(ID.Context, self); }
public MemoryPool(MemoryPool src) { _id = src._id; _values = new object[src._values.Length]; Array.Copy(src._values, 0, _values, 0, src._values.Length); _protected = true; src._protected = true; }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { HashSet<SymbolLink> outerValues = new HashSet<SymbolLink>(QueryContext.Resolver.List()); m_body.Bind(parameters, pool); m_params = new List<SymbolLink>(); m_body.GetValueDependences(null, parameters, false, (SymbolLink value) => { if (!value.IsStatic && outerValues.Contains(value)) m_params.Add(value); }); }
public override object Execute(IContextProvider provider, object[] args, MemoryPool pool) { XPathItem item = provider.Context; if (item == null) throw new XQueryException(Properties.Resources.XPDY0002); if (!item.IsNode) throw new XQueryException(Properties.Resources.XPTY0019, provider.Context.Value); XQueryNavigator nav = item as XQueryNavigator; if (nav == null || (nav.NodeType != XPathNodeType.Root && nav.NodeType != XPathNodeType.Element)) return _shadowXPath.Execute(provider, args, pool); return new NodeIterator(Iterator((XQueryNavigator)nav.Clone())); }
public override object Execute(IContextProvider provider, object[] args, MemoryPool pool) { XQueryNodeIterator iter = XQueryNodeIterator.Create( QueryContext.Engine.Apply(null, null, m_expr, args, m_compiledExpr, pool)); if (m_root) return new XQueryMappingIterator(args, pool, iter, m_bodyExpr); else { ContextProvider contextProvider = new ContextProvider(iter); object res = Undefined.Value; while (iter.MoveNext()) res = m_bodyExpr.Execute(contextProvider, args, pool); return res; } }
public override object Execute(IContextProvider provider, object[] args, MemoryPool pool) { object value = QueryContext.Engine.Apply(null, null, m_expr, args, m_valueExpr, pool); if (value == null) value = DataEngine.CoreServices.Generation.RuntimeOps.False; if (m_varType != XQuerySequenceType.Item && m_convert) value = Core.TreatAs(QueryContext.Engine, value, m_varType); XQueryNodeIterator iter = value as XQueryNodeIterator; if (iter != null && !(iter is BufferedNodeIterator)) value = iter.CreateBufferedIterator(); pool.SetData(m_value, value); if (m_conditionExpr != null && !Core.BooleanValue(QueryContext.Engine.Apply(null, null, ConditionExpr, args, m_conditionExpr, pool))) return EmptyIterator.Shared; return m_bodyExpr.Execute(provider, args, pool); }
public object Invoke(MemoryPool pool, object[] args) { if (invoke == null) invoke = (InvokeLambda)dynamicMethod.CreateDelegate(typeof(InvokeLambda)); if ((args == null && Arity == 0) || args.Length == Arity) { try { return invoke(this, Consts, args, pool); } catch (Exception ex) { Engine.HandleRuntimeException(ex); } } throw new InvalidOperationException("Invoke"); }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { value = QueryContext.Engine.TryGet(name, false, true); if (value == null) { if (parameters != null) { arg_index = 0; foreach (Executive.Parameter p in parameters) { if (p.ID == name) return; arg_index++; } } value = QueryContext.Engine.TryGet(name, true, false); if (value == null) throw new ValueNotDefined(name.ToString()); } }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { m_context = new SymbolLink(typeof(IContextProvider)); pool.Bind(m_context); object data = QueryContext.Resolver.GetCurrentStack(); QueryContext.Resolver.SetValue(ID.Context, m_context); m_compiledBody = new FunctionLink[m_expr.Length]; for (int k = 0; k < m_expr.Length; k++) { m_compiledBody[k] = new FunctionLink(); QueryContext.Engine.Compile(parameters, m_expr[k], m_compiledBody[k]); } if (Annotation != null) { m_compiledAnnotation = new FunctionLink[Annotation.Length]; for (int k = 0; k < Annotation.Length; k++) { m_compiledAnnotation[k] = new FunctionLink(); QueryContext.Engine.Compile(parameters, Annotation[k], m_compiledAnnotation[k]); } } QueryContext.Resolver.RevertToStack(data); }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { m_valueExpr = new FunctionLink(); QueryContext.Engine.Compile(parameters, m_expr, m_valueExpr); m_value.IsStatic = true; SymbolLink[] depends = QueryContext.Engine.GetValueDependences(null, parameters, m_expr, m_valueExpr, false); foreach (SymbolLink s in depends) if (!s.IsStatic) { m_value.IsStatic = false; break; } object data = QueryContext.Resolver.GetCurrentStack(); pool.Bind(m_value); QueryContext.Resolver.SetValue(m_var, m_value); if (ConditionExpr != null) { m_conditionExpr = new FunctionLink(); QueryContext.Engine.Compile(parameters, ConditionExpr, m_conditionExpr); } m_bodyExpr.Bind(parameters, pool); QueryContext.Resolver.RevertToStack(data); }
public override object Execute(IContextProvider provider, object[] args, MemoryPool pool) { object[] keys = new object[m_params.Count + 1]; keys[0] = provider.Context; for (int k = 0; k < m_params.Count; k++) keys[k + 1] = pool.GetData(m_params[k]); Key key = new Key(QueryContext.Engine, keys); object res; lock (m_cache) { if (m_cache.TryGetValue(key, out res)) return res.CloneObject(); } res = m_body.Execute(provider, args, pool); lock (m_cache) { if (!m_cache.ContainsKey(key)) { key.CloneKeys(); m_cache.Add(key, res); } } return res.CloneObject(); }
public void Init(MemoryPool pool) { return; }
public abstract object Execute(IContextProvider provider, object[] args, MemoryPool pool);
public virtual void Prepare() { m_defaultPool = new MemoryPool(); m_value.Clear(); Set(Lisp.T, Generation.RuntimeOps.True); Set(Lisp.NIL, null); Set(Lisp.UNKNOWN, Undefined.Value); }
public object Apply(object id, Parameter[] parameters, object lval, object[] args, FunctionLink dynamicFunc, MemoryPool pool) { object res = Undefined.Value; if (dynamicFunc != null && dynamicFunc.Value != null) { CompiledLambda lambda = dynamicFunc.Value; res = lambda.Invoke(pool, args); return res; } else { CompiledLambda lambda = Compile(parameters, lval); if (dynamicFunc != null) dynamicFunc.Value = lambda; res = lambda.Invoke(pool, args); } return res; }
public XQueryMappingIterator(object[] args, MemoryPool pool, XQueryNodeIterator iter, XQueryExprBase bodyExpr) { this.args = args; this.pool = pool; this.baseIter = iter.Clone(); this.bodyExpr = bodyExpr; provider = new ContextProvider(baseIter); }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { m_valueExpr = new FunctionLink(); QueryContext.Engine.Compile(parameters, m_expr, m_valueExpr); object data = QueryContext.Resolver.GetCurrentStack(); pool.Bind(m_value); QueryContext.Resolver.SetValue(m_var, m_value); if (m_pos != null) { pool.Bind(m_posValue); QueryContext.Resolver.SetValue(m_pos, m_posValue); } if (ConditionExpr != null) { m_conditionExpr = new FunctionLink(); QueryContext.Engine.Compile(parameters, ConditionExpr, m_conditionExpr); } m_bodyExpr.Bind(parameters, pool); QueryContext.Resolver.RevertToStack(data); }
public XQueryExprIterator(XQueryExpr owner, object[] args, object[] annotation, MemoryPool pool) { this.owner = owner; this.args = args; this.annotation = annotation; this.pool = pool; }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { _shadowXPath.Bind(parameters, pool); }
public abstract void Bind(Executive.Parameter[] parameters, MemoryPool pool);
public XQueryFLWORIteratorHPC(XQueryFLWOR owner, IContextProvider provider, object[] args, MemoryPool pool, XQueryNodeIterator baseIter) : base(owner, provider, args, pool, baseIter) { tasks = new ConcurrentQueue<Task<object>>(); }
public XQueryFLWORIterator(XQueryFLWOR owner, IContextProvider provider, object[] args, MemoryPool pool, XQueryNodeIterator baseIter) : base(owner, provider, args, pool, baseIter) { }
public override object Execute(IContextProvider provider, object[] args, MemoryPool pool) { if (provider.Context == null) throw new XQueryException(Properties.Resources.XPDY0002); if (!provider.Context.IsNode) throw new XQueryException(Properties.Resources.XPTY0019, provider.Context.Value); return new NodeIterator(m_iter(provider.Context)); }
private IEnumerable<XPathItem> CreateEnumerator(object[] args, MemoryPool pool, XQueryExprBase expr, XQueryNodeIterator baseIter) { XQueryNodeIterator iter = baseIter.Clone(); XQueryExpr numexpr = expr as XQueryExpr; if (numexpr != null && numexpr.m_expr.Length == 1 && numexpr.m_expr[0] is Integer) { Integer pos = (Integer)numexpr.m_expr[0]; foreach (XPathItem item in iter) { if (pos == 1) { yield return item; break; } else pos--; } } else { ContextProvider provider = new ContextProvider(iter); object res = Undefined.Value; while (iter.MoveNext()) { if (m_contextSensitive || res == Undefined.Value) res = expr.Execute(provider, args, pool); if (res == Undefined.Value) { if (!m_contextSensitive) break; continue; } XQueryNodeIterator iter2 = res as XQueryNodeIterator; XPathItem item; if (iter2 != null) { iter2 = iter2.Clone(); if (!iter2.MoveNext()) continue; item = iter2.Current.Clone(); if (!item.IsNode && iter2.MoveNext()) throw new XQueryException(Properties.Resources.FORG0006, "fn:boolean()", new XQuerySequenceType(XmlTypeCode.AnyAtomicType, XmlTypeCardinality.OneOrMore)); } else { item = res as XPathItem; if (item == null) item = new XQueryItem(res); } if (item.IsNode) yield return iter.Current; else { if (ValueProxy.IsNumeric(item.ValueType)) { if (QueryContext.Engine.OperatorEq(iter.CurrentPosition + 1, item.TypedValue) != null) { yield return iter.Current; if (!m_contextSensitive) break; } } else if (Core.BooleanValue(item)) yield return iter.Current; } } } }
public override object Execute(IContextProvider provider, object[] args, MemoryPool pool) { if (Source == null) return EmptyIterator.Shared; XQueryNodeIterator iter = XQueryNodeIterator.Create(Source.Execute(provider, args, pool)); for (int k = 0; k < m_filter.Length; k++) iter = new NodeIterator(CreateEnumerator(args, pool, m_filter[k], iter)); return iter; }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { Source.Bind(parameters, pool); m_contextSensitive = false; foreach (XQueryExprBase expr in m_filter) { expr.Bind(parameters, pool); if (!m_contextSensitive) m_contextSensitive = expr.IsContextSensitive(parameters); } }
public override object Execute(IContextProvider provider, object[] args, MemoryPool pool) { pool.SetData(m_context, provider); if (Annotation != null) { object[] annotation = new object[Annotation.Length]; for (int k = 0; k < Annotation.Length; k++) { object res = QueryContext.Engine.Apply(null, null, Annotation[k], args, m_compiledAnnotation[k], pool); if (res != Undefined.Value) if (res == null) annotation[k] = false; else annotation[k] = Core.Atomize(res); } return new XQueryExprIterator(this, args, annotation, pool); } if (m_expr.Length == 1) return QueryContext.Engine.Apply(null, null, m_expr[0], args, m_compiledBody[0], pool); return new XQueryExprIterator(this, args, null, pool); }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { m_compiledExpr = new FunctionLink(); QueryContext.Engine.Compile(parameters, m_expr, m_compiledExpr); m_bodyExpr.Bind(parameters, pool); }
public static object DynExecuteExpr(object obj, IContextProvider provider, object[] args, MemoryPool pool) { XQueryExprBase expr = (XQueryExprBase)obj; return expr.Execute(provider, args, pool); }
public override void Bind(Executive.Parameter[] parameters, MemoryPool pool) { }