public XQueryFLWORBase(XQueryContext context, object var, XQuerySequenceType varType, object expr, XQueryExprBase bodyExpr) : base(context) { m_var = var; m_varType = varType; m_expr = expr; m_bodyExpr = bodyExpr; }
public void PushVar(object id, XQuerySequenceType type, bool external) { Record node = new Record(); node.id = id; node.type = type; node.external = external; st.Push(node); }
public XQueryStepExpr(object nodeTest, XQueryPathExprType type, XQueryContext queryContext) : this(type, queryContext) { if (nodeTest is XmlQualifiedNameTest) m_nameTest = (XmlQualifiedNameTest)nodeTest; else if (nodeTest is XQuerySequenceType) m_typeTest = (XQuerySequenceType)nodeTest; else throw new ArgumentException("nodeTest"); }
public XQueryFLWOR(XQueryContext context, object var, XQuerySequenceType varType, object pos, object expr, XQueryExprBase bodyExpr, bool convert) : base(context, var, varType, expr, bodyExpr) { m_var = var; m_varType = varType; m_pos = pos; m_value = new SymbolLink(varType.ValueType); m_itemType = varType.ItemType; if (m_pos != null) m_posValue = new SymbolLink(typeof(Integer)); m_convert = convert; }
public bool GetType(object id, out XQuerySequenceType type, out bool external) { Record[] nodes = st.ToArray(); for (int k = nodes.Length - 1; k >= 0; k--) if (nodes[k].id == id) { type = nodes[k].type; external = nodes[k].external; return true; } type = null; external = false; return false; }
private XQuerySequenceType ProcessTypeDecl(Notation notation, Symbol sym) { if (sym.Tag == Tag.TokenWrapper && ((TokenWrapper)sym).Data == Token.EMPTY_SEQUENCE) return XQuerySequenceType.Void; else { XQuerySequenceType type = ProcessItemType(notation, sym); Notation.Record[] recs = notation.Select(sym, Descriptor.Occurrence, 1); if (recs.Length > 0) { type = new XQuerySequenceType(type); TokenWrapper w = (TokenWrapper)recs[0].Arg0; switch (w.Data) { case Token.Indicator1: // (*) type.Cardinality = XmlTypeCardinality.ZeroOrMore; break; case Token.Indicator2: // (+) type.Cardinality = XmlTypeCardinality.OneOrMore; break; case Token.Indicator3: // (?) type.Cardinality = XmlTypeCardinality.ZeroOrOne; break; } } return type; } }
private object ProcessFuncallExpr(Notation notation, Notation.Record rec) { Qname qname = (Qname)rec.Arg0; XmlQualifiedName identity = QNameParser.Parse(qname.Name, _context.NamespaceManager, _context.nameTable); string ns = identity.Namespace; if (identity.Namespace == String.Empty) { if (_context.DefaultFunctionNS == null) ns = XmlReservedNs.NsXQueryFunc; else ns = _context.DefaultFunctionNS; } object f = ATOM.Create(ns, new string[] { identity.Name }, false); object[] arg; if (rec.args[1] == null) arg = new object[1]; else { Symbol[] arr = Lisp.ToArray<Symbol>(rec.args[1]); arg = new object[arr.Length + 1]; for (int k = 0; k < arr.Length; k++) arg[k + 1] = ProcessExprSingle(notation, arr[k]); } if (arg.Length == 2) { XmlSchemaObject schemaType; if (TryProcessTypeName(notation, qname, false, out schemaType)) { XQuerySequenceType seqtype = new XQuerySequenceType((XmlSchemaSimpleType)schemaType, XmlTypeCardinality.One, null); if (seqtype == null) throw new XQueryException(Properties.Resources.XPST0051, "untyped"); if (seqtype.TypeCode == XmlTypeCode.Notation) throw new XQueryException(Properties.Resources.XPST0051, "NOTATION"); return Lisp.List(ID.CastToItem, arg[1], seqtype); } } arg[0] = f; XQueryFunctionRecord fr = _context.FunctionTable.GetRecord(f, arg.Length - 1); if (fr == null) throw new XQueryException(Properties.Resources.XPST0017, identity.Name, arg.Length - 1, ns); if (fr.validationReader) _context.NeedValidatedParser = true; for (int s = 1; s < arg.Length; s++) { XQuerySequenceType seqtype; if (fr.variableParams) seqtype = fr.parameters[0]; else seqtype = fr.parameters[s - 1]; arg[s] = CompileConversion(arg[s], seqtype); } return Lisp.List(arg); }
public void PushVar(object id, XQuerySequenceType type) { PushVar(id, type, false); }
public static object ValueAs(object value, XQuerySequenceType type, XmlNameTable nameTable, XmlNamespaceManager nsmgr) { if (value == Undefined.Value) return value; if (value == null) value = CoreServices.Generation.RuntimeOps.False; if (type.TypeCode == XmlTypeCode.None) throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(value.GetType(), XmlTypeCardinality.One), "empty-sequence()"); if (value.GetType() != type.ItemType) { UntypedAtomic untypedAtomic = value as UntypedAtomic; if (untypedAtomic != null) return ChangeType(XQuerySequenceType.XmlSchema.UntypedAtomic, value, type, nameTable, nsmgr); switch (type.TypeCode) { case XmlTypeCode.Double: if (value is System.Single) return Convert.ToDouble((float)value); if (value is System.Int32) return Convert.ToDouble((int)value); if (value is System.Int64) return Convert.ToDouble((long)value); if (value is Decimal) return Convert.ToDouble((decimal)value); if (value is Integer) return Convert.ToDouble((decimal)(Integer)value); if (value is System.Int16) return Convert.ToDouble((short)value); if (value is System.SByte) return Convert.ToDouble((sbyte)value); break; case XmlTypeCode.Float: if (value is System.Double) return Convert.ToSingle((double)value); if (value is System.Int32) return Convert.ToSingle((int)value); if (value is System.Int64) return Convert.ToSingle((long)value); if (value is Decimal) return Convert.ToSingle((decimal)value); if (value is Integer) return Convert.ToSingle((decimal)(Integer)value); if (value is System.Int16) return Convert.ToSingle((short)value); if (value is System.SByte) return Convert.ToSingle((sbyte)value); break; case XmlTypeCode.Integer: if (Integer.IsDerivedSubtype(value)) return Integer.ToInteger(value); break; case XmlTypeCode.Decimal: if (value is Integer) return (decimal)(Integer)value; if (Integer.IsDerivedSubtype(value)) return (decimal)Integer.ToInteger(value); break; case XmlTypeCode.Int: if (value is System.Int16) return (int)(short)value; if (value is System.UInt16) return (int)(ushort)value; if (value is System.SByte) return (int)(sbyte)value; if (value is System.Byte) return (int)(byte)value; if (value is Integer) return (int)(Integer)value; break; case XmlTypeCode.Long: if (value is System.Int32) return (long)(int)value; if (value is System.Int16) return (long)(short)value; if (value is System.SByte) return (long)(sbyte)value; if (value is Integer) return (long)(Integer)value; break; } if (type.TypeCode == XmlTypeCode.AnyUri && value is String) return new AnyUriValue((string)value); if (type.TypeCode == XmlTypeCode.String && value is AnyUriValue) return value.ToString(); if (type.TypeCode == XmlTypeCode.Duration && (value is YearMonthDurationValue || value is DayTimeDurationValue)) return value; throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(value.GetType(), XmlTypeCardinality.One), type); } return value; }
public XQueryLET(XQueryContext context, object var, XQuerySequenceType varType, object expr, XQueryExprBase bodyExpr, bool convert) : base(context, var, varType, expr, bodyExpr) { m_value = new SymbolLink(varType.ValueType); m_convert = convert; }
private void PreProcessFuncDecl(Notation notation, Notation.Record rec) { Qname qname = (Qname)rec.Arg0; XmlQualifiedName identity = QNameParser.Parse(qname.Name, _context.NamespaceManager, _context.nameTable); string ns = identity.Namespace; if (ns == String.Empty) { if (_context.DefaultFunctionNS == null) ns = XmlReservedNs.NsXQueryFunc; else ns = _context.DefaultFunctionNS; } if (ns == String.Empty || ns == XmlReservedNs.NsXml || ns == XmlReservedNs.NsXQueryFunc || ns == XmlReservedNs.NsXs || ns == XmlReservedNs.NsXsi) throw new XQueryException(Properties.Resources.XQST0045, identity.Name, identity.Namespace); object f = ATOM.Create(ns, new string[] { identity.Name }, false); FunctionParameter[] parameters = ProcessParamList(notation, rec.args[1]); if (_context.FunctionTable.IsRegistered(f, parameters.Length)) throw new XQueryException(Properties.Resources.XQST0034, identity.Name, identity.Namespace); XQuerySequenceType[] parameterTypes = new XQuerySequenceType[parameters.Length]; for (int k = 0; k < parameters.Length; k++) parameterTypes[k] = parameters[k].type; FunctionDecl decl = new FunctionDecl(f, identity, parameters); if (rec.args.Length > 3) { decl.returnType = new XQuerySequenceType(ProcessTypeDecl(notation, rec.Arg2)); if (rec.args[3] == null) // external throw new NotImplementedException(); else _context.FunctionTable.Register(f, _context, parameterTypes, decl.returnType); } else { if (rec.args[2] == null) // external throw new NotImplementedException(); else decl.returnType = XQuerySequenceType.Item; _context.FunctionTable.Register(f, _context, parameterTypes, decl.returnType); } _fdecl.Add(rec.sym, decl); }
private XQuerySequenceType EvalExprType(object expr) { if (Lisp.IsFunctor(expr)) { if (IsBooleanFunctor(expr)) return new XQuerySequenceType(XmlTypeCode.Boolean, XmlTypeCardinality.ZeroOrOne); else if (Lisp.IsFunctor(expr, Funcs.Neg)) return EvalExprType(Lisp.Arg1(expr)); else if (IsNumberFunctor(expr)) { XQuerySequenceType typ1 = EvalExprType(Lisp.Arg1(expr)); XQuerySequenceType typ2 = EvalExprType(Lisp.Arg2(expr)); if (typ1.IsUntypedAtomic) typ1 = new XQuerySequenceType(XmlTypeCode.Double, typ1.Cardinality); if (typ2.IsUntypedAtomic) typ2 = new XQuerySequenceType(XmlTypeCode.Double, typ2.Cardinality); XmlTypeCardinality cardinality; if (typ1.Cardinality == XmlTypeCardinality.ZeroOrOne || typ2.Cardinality == XmlTypeCardinality.ZeroOrOne) cardinality = XmlTypeCardinality.ZeroOrOne; else cardinality = XmlTypeCardinality.One; if (Lisp.IsFunctor(expr, Funcs.IDiv)) return new XQuerySequenceType(typeof(CoreServices.Integer), cardinality); else if (Lisp.IsFunctor(expr, Funcs.Div)) { if (typ1.ItemType == typeof(System.Double) || typ2.ItemType == typeof(System.Double)) return new XQuerySequenceType(XmlTypeCode.Double, cardinality); if (typ1.ItemType == typeof(System.Single) || typ2.ItemType == typeof(System.Single)) return new XQuerySequenceType(XmlTypeCode.Float, cardinality); return new XQuerySequenceType(XmlTypeCode.Decimal, cardinality); } else { Type typ3 = ValueProxy.GetType(typ1.ItemType, typ2.ItemType); return new XQuerySequenceType(typ3, cardinality); } } else if (Lisp.IsFunctor(expr, ID.CastToItem)) { XQuerySequenceType type = (XQuerySequenceType)Lisp.Arg2(expr); if (type.Cardinality == XmlTypeCardinality.One) return new XQuerySequenceType(type.SchemaType, XmlTypeCardinality.ZeroOrOne, type.ParameterType); return new XQuerySequenceType(type); } else if (Lisp.IsFunctor(expr, Funcs.Cast)) { object arg = Lisp.Arg2(expr); if ((Type)arg == typeof(XQuerySequenceType)) return new XQuerySequenceType(XQuerySequenceType.ItemS); else return new XQuerySequenceType((Type)arg, XmlTypeCardinality.One); } else if (Lisp.IsFunctor(expr, ID.Number) || Lisp.IsFunctor(expr, ID.CastToNumber2) || Lisp.IsFunctor(expr, ID.CastToNumber3)) return new XQuerySequenceType(XmlTypeCode.Double); else if (Lisp.IsFunctor(expr, ID.CastToNumber1)) return EvalExprType(Lisp.Second(expr)); else if (Lisp.IsFunctor(expr, Funcs.Cast)) return EvalExprType(Lisp.Second(expr)); else if (Lisp.IsFunctor(expr, ID.Atomize) || Lisp.IsFunctor(expr, ID.AtomizeBody)) { XQuerySequenceType typ = EvalExprType(Lisp.Second(expr)); XmlTypeCardinality cardinality; if (typ.Cardinality == XmlTypeCardinality.One || typ.Cardinality == XmlTypeCardinality.OneOrMore) cardinality = XmlTypeCardinality.One; else cardinality = XmlTypeCardinality.ZeroOrOne; if (typ.IsNode) { if (typ.SchemaType != null) return new XQuerySequenceType(typ.SchemaType, cardinality, typeof(System.Object)); else return new XQuerySequenceType(XmlTypeCode.AnyAtomicType, cardinality); } else return new XQuerySequenceType(typ.TypeCode, cardinality); } else if (Lisp.IsFunctor(expr, ID.CastTo)) return (XQuerySequenceType)Lisp.Arg2(expr); else if (Lisp.IsFunctor(expr, ID.Par)) return EvalExprType(Lisp.Second(expr)); else if (Lisp.IsFunctor(expr, ID.Range)) return new XQuerySequenceType(XmlTypeCode.Integer, XmlTypeCardinality.ZeroOrMore); else if (IsXPathFunctor(expr)) return XQuerySequenceType.ItemS; else if (Lisp.IsFunctor(expr, Funcs.If)) { XQuerySequenceType typ1 = EvalExprType(Lisp.Arg2(expr)); XQuerySequenceType typ2 = EvalExprType(Lisp.Arg3(expr)); if (typ1.Equals(typ2)) return typ1; } else { XQueryFunctionRecord rec = _context.FunctionTable.GetRecord(expr); if (rec != null) return rec.returnType; } } else if (expr is XQueryExpr) { XQueryExpr dynExpr = (XQueryExpr)expr; XQuerySequenceType typ = new XQuerySequenceType(EvalExprType(dynExpr.m_expr[0])); for (int k = 1; k < dynExpr.m_expr.Length; k++) { XQuerySequenceType typ2 = EvalExprType(dynExpr.m_expr[k]); if (typ.TypeCode != typ2.TypeCode) return XQuerySequenceType.ItemS; if (typ.Cardinality == XmlTypeCardinality.One) typ.Cardinality = XmlTypeCardinality.OneOrMore; else if (typ.Cardinality == XmlTypeCardinality.ZeroOrOne) { if (typ2.Cardinality == XmlTypeCardinality.One || typ2.Cardinality == XmlTypeCardinality.OneOrMore) typ.Cardinality = XmlTypeCardinality.OneOrMore; else typ.Cardinality = XmlTypeCardinality.ZeroOrMore; } else if (typ.Cardinality == XmlTypeCardinality.ZeroOrMore) { if (typ2.Cardinality == XmlTypeCardinality.One || typ2.Cardinality == XmlTypeCardinality.OneOrMore) typ.Cardinality = XmlTypeCardinality.OneOrMore; } } return typ; } else { if (Lisp.IsAtom(expr)) { XQuerySequenceType type = _varTable.GetType(expr); if (type != null) return type; } else return new XQuerySequenceType(expr.GetType(), XmlTypeCardinality.One); } return XQuerySequenceType.Item; }
public static bool InstanceOf([Implict] Executive engine, object value, XQuerySequenceType destType) { XQueryContext context = (XQueryContext)engine.Owner; if (value == Undefined.Value) return destType.Cardinality == XmlTypeCardinality.ZeroOrOne || destType.Cardinality == XmlTypeCardinality.ZeroOrMore; if (value == null) value = CoreServices.Generation.RuntimeOps.False; XQueryNodeIterator iter = value as XQueryNodeIterator; if (iter != null) { int num = 0; foreach (XPathItem item in iter) { if (num == 1) { if (destType.Cardinality == XmlTypeCardinality.ZeroOrOne || destType.Cardinality == XmlTypeCardinality.One) return false; } if (!destType.Match(item, context)) return false; num++; } if (num == 0) { if (destType.TypeCode != XmlTypeCode.None && (destType.Cardinality == XmlTypeCardinality.One || destType.Cardinality == XmlTypeCardinality.OneOrMore)) return false; } return true; } else { if (destType.ItemType == value.GetType()) return true; XPathItem item = value as XPathItem; if (item == null) item = new XQueryItem(value); return destType.Match(item, context); } }
public static object CastToItem([Implict] Executive executive, object value, XQuerySequenceType destType) { XQueryContext context = (XQueryContext)executive.Owner; if (value == null) value = CoreServices.Generation.RuntimeOps.False; else { value = Atomize(value); if (value == Undefined.Value) { if (destType.TypeCode == XmlTypeCode.String) return String.Empty; return value; } } XmlTypeCode typeCode = XQuerySequenceType.GetXmlTypeCode(value.GetType()); XmlSchemaType xmlType = XmlSchemaSimpleType.GetBuiltInSimpleType(typeCode); return XQueryConvert.ChangeType(xmlType, value, destType, context.nameTable, context.NamespaceManager); }
private object CompileAtomizeNumberExpr(object expr, XQuerySequenceType type) { if (type.Equals(XQuerySequenceType.Item)) return Lisp.List(ID.CastToNumber1, Lisp.List(ID.Atomize, expr)); else if (type.IsNode || type.Cardinality != XmlTypeCardinality.One) { Type resType = type.AtomizedValueType; if (resType == typeof(UntypedAtomic) && (_context.SchemaProcessing == SchemaProcessingMode.Force || _context.NeedValidatedParser)) resType = typeof(System.Object); if (type.Cardinality == XmlTypeCardinality.One || type.Cardinality == XmlTypeCardinality.OneOrMore) { if (ValueProxy.IsNumeric(resType)) return Lisp.List(Funcs.Cast, Lisp.List(ID.AtomizeX, expr), resType); else if (resType == typeof(UntypedAtomic)) return Lisp.List(ID.CastToNumber2, Lisp.List(ID.AtomizeX, expr)); else return Lisp.List(ID.CastToNumber1, Lisp.List(ID.AtomizeX, expr)); } else { if (ValueProxy.IsNumeric(resType)) return Lisp.List(Funcs.Cast, Lisp.List(ID.Atomize, expr), resType); else if (resType == typeof(UntypedAtomic)) return Lisp.List(ID.CastToNumber2, Lisp.List(ID.Atomize, expr)); else return Lisp.List(ID.CastToNumber1, Lisp.List(ID.Atomize, expr)); } } else { if (type.IsNumeric) return Lisp.List(Funcs.Cast, expr, type.ItemType); else if (type.IsUntypedAtomic) return Lisp.List(ID.CastToNumber2, expr); else return Lisp.List(ID.CastToNumber1, expr); } }
public static bool Castable([Implict] Executive engine, object value, XQuerySequenceType destType, Type exprType) { try { CastTo(engine, value, destType, exprType); return true; } catch(XQueryException) { return false; } }
private object CompileAtomizeValueExpr(object expr, XQuerySequenceType type) { if (type.Equals(XQuerySequenceType.Item)) return Lisp.List(ID.Atomize, expr); else if (type.IsNode || type.Cardinality != XmlTypeCardinality.One) { Type resType = type.AtomizedValueType; if (type.Cardinality == XmlTypeCardinality.One || type.Cardinality == XmlTypeCardinality.OneOrMore) { if (resType != typeof(System.Object)) return Lisp.List(Funcs.Cast, Lisp.List(ID.AtomizeX, expr), resType); else return Lisp.List(ID.AtomizeX, expr); } else { if (resType != typeof(System.Object)) return Lisp.List(Funcs.Cast, Lisp.List(ID.Atomize, expr), resType); else return Lisp.List(ID.Atomize, expr); } } else { if (type.ItemType != typeof(System.Object)) return Lisp.List(Funcs.Cast, expr, type.ItemType); else return expr; } }
public static object CastTo([Implict] Executive engine, object value, XQuerySequenceType destType, Type exprType) { XQueryContext context = (XQueryContext)engine.Owner; if (destType == XQuerySequenceType.Item) return value; if (value == Undefined.Value) { if (destType.Cardinality == XmlTypeCardinality.ZeroOrMore) return EmptyIterator.Shared; if (destType.TypeCode != XmlTypeCode.None && destType.Cardinality != XmlTypeCardinality.ZeroOrOne) throw new XQueryException(Properties.Resources.XPTY0004, "empty-sequence()", destType); return Undefined.Value; } if (destType.Cardinality == XmlTypeCardinality.One || destType.Cardinality == XmlTypeCardinality.ZeroOrOne) { XPathItem res; XQueryNodeIterator iter = value as XQueryNodeIterator; if (iter != null) { iter = iter.Clone(); if (!iter.MoveNext()) { if (destType.TypeCode != XmlTypeCode.None && (destType.Cardinality == XmlTypeCardinality.One || destType.Cardinality == XmlTypeCardinality.OneOrMore)) throw new XQueryException(Properties.Resources.XPTY0004, "empty-sequence()", destType); return Undefined.Value; } if (exprType != null && exprType != typeof(System.String)) { if ((destType.TypeCode == XmlTypeCode.QName && iter.Current.XmlType.TypeCode != XmlTypeCode.QName) || (destType.TypeCode == XmlTypeCode.Notation && iter.Current.XmlType.TypeCode != XmlTypeCode.Notation)) throw new XQueryException(Properties.Resources.XPTY0004_CAST, destType); } res = iter.Current.ChangeType(destType, context); if (iter.MoveNext()) throw new XQueryException(Properties.Resources.MoreThanOneItem); if (destType.IsNode) return res; return res.TypedValue; } XPathItem item = value as XPathItem; if (item == null) item = new XQueryItem(value); if (exprType != null && exprType != typeof(System.String)) { if ((destType.TypeCode == XmlTypeCode.QName && item.XmlType.TypeCode != XmlTypeCode.QName) || (destType.TypeCode == XmlTypeCode.Notation && item.XmlType.TypeCode != XmlTypeCode.Notation)) throw new XQueryException(Properties.Resources.XPTY0004_CAST, destType); } res = item.ChangeType(destType, context); if (destType.IsNode) return res; return res.TypedValue; } else return new NodeIterator(XPathFactory.ConvertIterator(XQueryNodeIterator.Create(value), destType, context)); }
private object CompileConversion(object expr, XQuerySequenceType destType) { if (destType == XQuerySequenceType.Item) return expr; XQuerySequenceType type = EvalExprType(expr); if (destType.TypeCode == XmlTypeCode.None) { if (type != XQuerySequenceType.Item && (type.Cardinality == XmlTypeCardinality.One || type.Cardinality == XmlTypeCardinality.OneOrMore)) throw new XQueryException(Properties.Resources.XPTY0004, type, destType); return Lisp.List(ID.CastArg, expr, destType); } if ((destType.Cardinality == XmlTypeCardinality.ZeroOrMore || destType.Cardinality == XmlTypeCardinality.OneOrMore) && (type.Cardinality == XmlTypeCardinality.One || type.Cardinality == XmlTypeCardinality.ZeroOrOne || Lisp.IsFunctor(expr, Funcs.Let1) || Lisp.IsFunctor(expr, Funcs.Let2))) expr = Lisp.List(ID.Seq, Lisp.List(Funcs.LambdaQuote, expr)); // !! Type clrType = destType.ParameterType; if (clrType != null && clrType.IsArray) clrType = clrType.GetElementType(); if (clrType == null) clrType = destType.ValueType; if ((destType.Cardinality == XmlTypeCardinality.One || destType.Cardinality == XmlTypeCardinality.ZeroOrOne) && (type.Cardinality == XmlTypeCardinality.ZeroOrOne || type.Cardinality == XmlTypeCardinality.ZeroOrMore || type.Cardinality == XmlTypeCardinality.OneOrMore || type.Equals(XQuerySequenceType.Item))) { if (destType.IsNode) { if (clrType == typeof(XPathNavigator)) { if (destType.Cardinality == XmlTypeCardinality.One) return Lisp.List(ID.NodeValueX, expr); else return Lisp.List(ID.NodeValue, expr); } else return Lisp.List(ID.NodeValueBody, Lisp.List(Funcs.LambdaQuote, expr)); } else { if (destType.Cardinality == XmlTypeCardinality.One) { if (IsNumberFunctor(expr)) expr = Lisp.List(ID.ExactlyOne, Lisp.List(Funcs.LambdaQuote, expr)); else expr = Lisp.List(ID.AtomizeX, expr); } else { if (clrType == typeof(System.Object)) expr = Lisp.List(ID.AtomizeBody, expr); else expr = Lisp.List(ID.Atomize, expr); } } } if (clrType == typeof(XPathNavigator) && !type.IsNode) throw new XQueryException(Properties.Resources.XPTY0004, type, destType); if (destType.ItemType != typeof(System.Object) && type.ItemType != destType.ItemType) { if (destType.TypeCode != XmlTypeCode.AnyAtomicType) expr = Lisp.List(ID.CastArg, expr, destType); } if (clrType != typeof(System.Object)) expr = Lisp.List(Funcs.Cast, expr, clrType); return expr; }
public static object CastArg([Implict] Executive engine, object value, XQuerySequenceType destType) { XQueryContext context = (XQueryContext)engine.Owner; if (destType == XQuerySequenceType.Item) return value; if (value == Undefined.Value) { if (destType.Cardinality == XmlTypeCardinality.ZeroOrMore) return EmptyIterator.Shared; if (destType.TypeCode != XmlTypeCode.None && destType.Cardinality != XmlTypeCardinality.ZeroOrOne) throw new XQueryException(Properties.Resources.XPTY0004, "empty-sequence()", destType); return Undefined.Value; } if (destType.Cardinality == XmlTypeCardinality.One || destType.Cardinality == XmlTypeCardinality.ZeroOrOne) { object res; XQueryNodeIterator iter = value as XQueryNodeIterator; if (iter != null) { iter = iter.Clone(); if (!iter.MoveNext()) { if (destType.TypeCode != XmlTypeCode.None && (destType.Cardinality == XmlTypeCardinality.One || destType.Cardinality == XmlTypeCardinality.OneOrMore)) throw new XQueryException(Properties.Resources.XPTY0004, "empty-sequence()", destType); return Undefined.Value; } if (destType.IsNode) { if (!destType.Match(iter.Current, context)) throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(iter.Current.XmlType, XmlTypeCardinality.OneOrMore, null), destType); res = iter.Current.Clone(); } else res = XQueryConvert.ValueAs(iter.Current.TypedValue, destType, context.nameTable, context.NamespaceManager); if (iter.MoveNext()) throw new XQueryException(Properties.Resources.MoreThanOneItem); return res; } else { XPathItem item = value as XPathItem; if (item != null) { if (item.IsNode) { if (!destType.Match(item, context)) throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(item.XmlType, XmlTypeCardinality.OneOrMore, null), destType); return item; } else return XQueryConvert.ValueAs(item.TypedValue, destType, context.nameTable, context.NamespaceManager); } return XQueryConvert.ValueAs(value, destType, context.nameTable, context.NamespaceManager); } } else return new NodeIterator(XPathFactory.ValueIterator(XQueryNodeIterator.Create(value), destType, context)); }
public void Register(object id, XQueryContext module, XQuerySequenceType[] parameters, XQuerySequenceType resType) { XQueryFunctionRecord rec = new XQueryFunctionRecord(); rec.id = id; rec.module = module; rec.parameters = parameters; rec.returnType = resType; FunctionSocket sock = new FunctionSocket(rec); FunctionSocket next; if (m_table.TryGetValue(rec.id, out next)) sock.next = next; m_table[rec.id] = sock; }
public bool IsDerivedFrom(XQuerySequenceType src) { switch (src.TypeCode) { case XmlTypeCode.Node: if (!IsNode) return false; break; case XmlTypeCode.AnyAtomicType: case XmlTypeCode.UntypedAtomic: if (IsNode) return false; break; case XmlTypeCode.Document: if (TypeCode != XmlTypeCode.Document || SchemaElement != src.SchemaElement) return false; break; case XmlTypeCode.Element: if (TypeCode != XmlTypeCode.Element || SchemaElement != src.SchemaElement) return false; break; case XmlTypeCode.Attribute: if (TypeCode != XmlTypeCode.Attribute || SchemaAttribute != src.SchemaAttribute) return false; break; case XmlTypeCode.ProcessingInstruction: if (TypeCode != XmlTypeCode.ProcessingInstruction) return false; break; case XmlTypeCode.Comment: if (TypeCode != XmlTypeCode.Comment) return false; break; case XmlTypeCode.Text: if (TypeCode != XmlTypeCode.Text) return false; break; } if (SchemaType != null || src.SchemaType != null) { if (SchemaType != null && src.SchemaType != null) { if (!XmlSchemaType.IsDerivedFrom(SchemaType, src.SchemaType, XmlSchemaDerivationMethod.Empty)) return false; } else return false; } if (Cardinality != src.Cardinality) { if ((Cardinality == XmlTypeCardinality.ZeroOrOne || Cardinality == XmlTypeCardinality.ZeroOrMore) && (src.Cardinality == XmlTypeCardinality.One || src.Cardinality == XmlTypeCardinality.OneOrMore)) return false; if (Cardinality == XmlTypeCardinality.One && src.Cardinality == XmlTypeCardinality.OneOrMore) return false; } return true; }
public static object ChangeType(XmlSchemaType xmlType, object value, XQuerySequenceType type, XmlNameTable nameTable, XmlNamespaceManager nsmgr) { if (type.TypeCode == XmlTypeCode.AnyAtomicType || xmlType.TypeCode == type.TypeCode) return value; try { switch (xmlType.TypeCode) { case XmlTypeCode.String: case XmlTypeCode.UntypedAtomic: switch (type.TypeCode) { case XmlTypeCode.UntypedAtomic: return new UntypedAtomic(value.ToString()); case XmlTypeCode.String: return value.ToString(); case XmlTypeCode.DateTime: return DateTimeValue.Parse(value.ToString()); case XmlTypeCode.Date: return DateValue.Parse(value.ToString()); case XmlTypeCode.Time: return TimeValue.Parse(value.ToString()); case XmlTypeCode.GYearMonth: return GYearMonthValue.Parse(value.ToString()); case XmlTypeCode.GYear: return GYearValue.Parse(value.ToString()); case XmlTypeCode.GMonth: return GMonthValue.Parse(value.ToString()); case XmlTypeCode.GMonthDay: return GMonthDayValue.Parse(value.ToString()); case XmlTypeCode.GDay: return GDayValue.Parse(value.ToString()); case XmlTypeCode.Duration: return DurationValue.Parse(value.ToString()); case XmlTypeCode.QName: if (xmlType.TypeCode == XmlTypeCode.UntypedAtomic) throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(xmlType, XmlTypeCardinality.One, null), type); return QNameValue.Parse(value.ToString(), nsmgr); case XmlTypeCode.Notation: return NotationValue.Parse(value.ToString(), nsmgr); case XmlTypeCode.AnyUri: return new AnyUriValue(value.ToString()); default: { string text = value.ToString(); object res = type.SchemaType.Datatype.ParseValue(text, nameTable, nsmgr); switch (type.TypeCode) { case XmlTypeCode.Integer: case XmlTypeCode.PositiveInteger: case XmlTypeCode.NegativeInteger: case XmlTypeCode.NonPositiveInteger: case XmlTypeCode.NonNegativeInteger: return (Integer)Convert.ToDecimal(res); case XmlTypeCode.DayTimeDuration: return new DayTimeDurationValue((TimeSpan)res); case XmlTypeCode.YearMonthDuration: return new YearMonthDurationValue((TimeSpan)res); case XmlTypeCode.HexBinary: return new HexBinaryValue((byte[])res); case XmlTypeCode.Base64Binary: if (text.EndsWith("==") && (text.Length < 3 || "AQgw".IndexOf(text[text.Length - 3]) == -1)) throw new XQueryException(Properties.Resources.FORG0001, value); return new Base64BinaryValue((byte[])res); case XmlTypeCode.Idref: if (type.SchemaType == XQuerySequenceType.XmlSchema.IDREFS) return new IDREFSValue((string[])res); goto default; case XmlTypeCode.NmToken: if (type.SchemaType == XQuerySequenceType.XmlSchema.NMTOKENS) return new NMTOKENSValue((string[])res); goto default; case XmlTypeCode.Entity: if (type.SchemaType == XQuerySequenceType.XmlSchema.ENTITIES) return new ENTITIESValue((string[])res); goto default; default: return res; } } } case XmlTypeCode.Boolean: switch (type.TypeCode) { case XmlTypeCode.Decimal: case XmlTypeCode.Float: case XmlTypeCode.Double: case XmlTypeCode.Integer: case XmlTypeCode.NonPositiveInteger: case XmlTypeCode.NegativeInteger: case XmlTypeCode.Long: case XmlTypeCode.Int: case XmlTypeCode.Short: case XmlTypeCode.Byte: case XmlTypeCode.NonNegativeInteger: case XmlTypeCode.UnsignedLong: case XmlTypeCode.UnsignedInt: case XmlTypeCode.UnsignedShort: case XmlTypeCode.UnsignedByte: case XmlTypeCode.PositiveInteger: return ChangeType(value, type.ItemType); case XmlTypeCode.String: return XQueryConvert.ToString((bool)value); case XmlTypeCode.UntypedAtomic: return new UntypedAtomic(XQueryConvert.ToString((bool)value)); } break; case XmlTypeCode.Integer: case XmlTypeCode.NonPositiveInteger: case XmlTypeCode.NegativeInteger: case XmlTypeCode.Long: case XmlTypeCode.Int: case XmlTypeCode.Short: case XmlTypeCode.Byte: case XmlTypeCode.NonNegativeInteger: case XmlTypeCode.UnsignedLong: case XmlTypeCode.UnsignedInt: case XmlTypeCode.UnsignedShort: case XmlTypeCode.UnsignedByte: case XmlTypeCode.PositiveInteger: case XmlTypeCode.Decimal: case XmlTypeCode.Float: case XmlTypeCode.Double: switch (type.TypeCode) { case XmlTypeCode.String: return ToString(value); case XmlTypeCode.UntypedAtomic: return new UntypedAtomic(ToString(value)); case XmlTypeCode.Boolean: return Core.BooleanValue(value); case XmlTypeCode.AnyUri: throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(xmlType, XmlTypeCardinality.One, null), type); default: return ChangeType(value, type.ItemType); } default: { IXmlConvertable convert = value as IXmlConvertable; if (convert != null) return convert.ValueAs(type, nsmgr); if (type.TypeCode == XmlTypeCode.String) return ToString(value); if (type.TypeCode == XmlTypeCode.UntypedAtomic) return new UntypedAtomic(ToString(value)); return type.SchemaType.Datatype.ChangeType(value, type.ValueType); } } } catch (XmlSchemaException ex) { throw new XQueryException(ex.Message, ex); } catch (InvalidCastException) { throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(xmlType, XmlTypeCardinality.One, null), type); } catch (FormatException) { throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(xmlType, XmlTypeCardinality.One, null),type); } throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(xmlType, XmlTypeCardinality.One, null), type); }
public XQuerySequenceType(XQuerySequenceType src) { TypeCode = src.TypeCode; NameTest = src.NameTest; Cardinality = src.Cardinality; SchemaType = src.SchemaType; SchemaElement = src.SchemaElement; SchemaAttribute = src.SchemaAttribute; Nillable = src.Nillable; ParameterType = src.ParameterType; IsNode = src.IsNode; ItemType = src.ItemType; }
public static object TreatValueAs(object value, XQuerySequenceType type) { if (value == Undefined.Value) return value; if (value == null) value = CoreServices.Generation.RuntimeOps.False; if (type.TypeCode == XmlTypeCode.None) throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(value.GetType(), XmlTypeCardinality.One), "empty-sequence()"); if (value.GetType() != type.ItemType && type.ItemType != typeof(System.Object)) { if (type.ItemType == typeof(Integer)) { if (value is System.Int32) return (Integer)(int)value; else if (value is System.UInt32) return (Integer)(uint)value; else if (value is System.Int64) return (Integer)(long)value; else if (value is System.UInt64) return (Integer)(ulong)value; else if (value is System.Int16) return (Integer)(short)value; else if (value is System.UInt16) return (Integer)(ushort)value; else if (value is System.SByte) return (Integer)(sbyte)value; } else if (type.ItemType == typeof(Decimal)) { if (value is Integer) return (Decimal)(Integer)value; else if (value is System.Int32) return (Decimal)(int)value; if (value is System.UInt32) return (Decimal)(uint)value; else if (value is System.Int64) return (Decimal)(long)value; else if (value is System.UInt64) return (Decimal)(ulong)value; else if (value is System.Int16) return (Decimal)(short)value; else if (value is System.UInt16) return (Decimal)(ushort)value; else if (value is System.SByte) return (Decimal)(sbyte)value; } throw new XQueryException(Properties.Resources.XPTY0004, new XQuerySequenceType(value.GetType(), XmlTypeCardinality.One), type); } return value; }
object IXmlConvertable.ValueAs(XQuerySequenceType type, XmlNamespaceManager nsmgr) { switch (type.TypeCode) { case XmlTypeCode.AnyAtomicType: case XmlTypeCode.QName: return this; case XmlTypeCode.String: return ToString(); case XmlTypeCode.UntypedAtomic: return new UntypedAtomic(ToString()); default: throw new InvalidCastException(); } }