public QilList FormalParameterList(QilNode arg1, QilNode arg2) { QilList result = _f.FormalParameterList(); result.Add(arg1); result.Add(arg2); return(result); }
public QilList ActualParameterList(QilNode arg1, QilNode arg2) { QilList result = f.ActualParameterList(); result.Add(arg1); result.Add(arg2); return(result); }
public QilNode Sequence(QilNode child1, QilNode child2) { QilList res = _f.Sequence(); res.Add(child1); res.Add(child2); return(res); }
public QilList GlobalVariableList(IList <QilNode> values) { QilList seq = GlobalVariableList(); seq.Add(values); return(seq); }
public QilNode XsltInvokeLateBound(QilNode name, IList <QilNode> args) { QilList list = _f.ActualParameterList(); list.Add(args); return(_f.XsltInvokeLateBound(name, list)); }
public QilList BranchList(IList <QilNode> values) { QilList seq = BranchList(); seq.Add(values); return(seq); }
public QilNode XsltInvokeEarlyBound(QilNode name, MethodInfo d, XmlQueryType t, IList <QilNode> args) { QilList list = _f.ActualParameterList(); list.Add(args); return(_f.XsltInvokeEarlyBound(name, _f.LiteralObject(d), list, t)); }
public QilList FormalParameterList(IList <QilNode> values) { QilList seq = FormalParameterList(); seq.Add(values); return(seq); }
public QilList SortKeyList(IList <QilNode> values) { QilList seq = SortKeyList(); seq.Add(values); return(seq); }
public QilList FunctionList(IList <QilNode> values) { QilList seq = FunctionList(); seq.Add(values); return(seq); }
public QilList Sequence(IList <QilNode> values) { QilList seq = Sequence(); seq.Add(values); return(seq); }
public QilList SortKeyList(QilSortKey key) { QilList list = f.SortKeyList(); list.Add(key); return(list); }
public QilNode Sequence(QilNode child) { if (!_debug) { return(child); } QilList res = _f.Sequence(); res.Add(child); return(res); }
public QilNode GenerateInvoke(QilFunction func, IList<XslNode> actualArgs) { iterStack.Clear(); formalArgs = func.Arguments; invokeArgs = fac.ActualParameterList(); // curArg is an instance variable used in Clone() method for (curArg = 0; curArg < formalArgs.Count; curArg ++) { // Find actual value for a given formal arg QilParameter formalArg = (QilParameter)formalArgs[curArg]; QilNode invokeArg = FindActualArg(formalArg, actualArgs); // If actual value was not specified, use the default value and copy its debug comment if (invokeArg == null) { if (debug) { if (formalArg.Name.NamespaceUri == XmlReservedNs.NsXslDebug) { Debug.Assert(formalArg.Name.LocalName == "namespaces", "Cur,Pos,Last don't have default values and should be always added to by caller in AddImplicitArgs()"); Debug.Assert(formalArg.DefaultValue != null, "PrecompileProtoTemplatesHeaders() set it"); invokeArg = Clone(formalArg.DefaultValue); } else { invokeArg = fac.DefaultValueMarker(); } } else { Debug.Assert(formalArg.Name.NamespaceUri != XmlReservedNs.NsXslDebug, "Cur,Pos,Last don't have default values and should be always added to by caller in AddImplicitArgs(). We don't have $namespaces in !debug."); invokeArg = Clone(formalArg.DefaultValue); } } XmlQueryType formalType = formalArg.XmlType; XmlQueryType invokeType = invokeArg.XmlType; // Possible arg types: anyType, node-set, string, boolean, and number fac.CheckXsltType(formalArg); fac.CheckXsltType(invokeArg); if (!invokeType.IsSubtypeOf(formalType)) { // This may occur only if inferred type of invokeArg is XslFlags.None Debug.Assert(invokeType == T.ItemS, "Actual argument type is not a subtype of formal argument type"); invokeArg = fac.TypeAssert(invokeArg, formalType); } invokeArgs.Add(invokeArg); } // Create Invoke node and wrap it with previous parameter declarations QilNode invoke = fac.Invoke(func, invokeArgs); while (iterStack.Count != 0) invoke = fac.Loop(iterStack.Pop(), invoke); return invoke; }
public QilNode Sequence(params QilNode[] args) { if (!_debug) { switch (args.Length) { case 0: return(_f.Sequence()); case 1: return(args[0]); } } QilList res = _f.Sequence(); foreach (QilNode n in args) { res.Add(n); } return(res); }
// Fills invokeArgs with values from actualArgs in order given by formalArgs // Returns true if formalArgs maps 1:1 with actual args. // Formaly this is n*n algorithm. We can optimize it by calculationg "signature" // of the function as sum of all hashes of its args names. private bool FillupInvokeArgs(IList<QilNode> formalArgs, IList<XslNode> actualArgs, QilList invokeArgs) { if (actualArgs.Count != formalArgs.Count) { return false; } invokeArgs.Clear(); for (int invArg = 0; invArg < formalArgs.Count; invArg++) { QilName formalArgName = ((QilParameter)formalArgs[invArg]).Name; XmlQueryType paramType = formalArgs[invArg].XmlType; QilNode arg = null; { for (int actArg = 0; actArg < actualArgs.Count; actArg++) { Debug.Assert(actualArgs[actArg].NodeType == XslNodeType.WithParam, "All Sorts was removed in CompileSorts()"); VarPar withParam = (VarPar)actualArgs[actArg]; if (formalArgName.Equals(withParam.Name)) { QilNode value = withParam.Value; XmlQueryType valueType = value.XmlType; if (valueType != paramType) { if (valueType.IsNode && paramType.IsNode && valueType.IsSubtypeOf(paramType)) { // We can pass it } else { // Formal argument has the same name but a different type return false; } } arg = value; break; } } } if (arg == null) { // Formal argument has not been found among actual arguments return false; } invokeArgs.Add(arg); } // All arguments have been found return true; }
private QilNode CompileInstructions(IList<XslNode> instructions, int from, QilList content) { Debug.Assert(instructions != null); for (int i = from; i < instructions.Count; i++) { XslNode node = instructions[i]; XslNodeType nodeType = node.NodeType; if (nodeType == XslNodeType.Param) { continue; // already compiled by CompileProtoTemplate() } QilList nsList = EnterScope(node); QilNode result; switch (nodeType) { case XslNodeType.ApplyImports: result = CompileApplyImports(node); break; case XslNodeType.ApplyTemplates: result = CompileApplyTemplates((XslNodeEx)node); break; case XslNodeType.Attribute: result = CompileAttribute((NodeCtor)node); break; case XslNodeType.CallTemplate: result = CompileCallTemplate((XslNodeEx)node); break; case XslNodeType.Choose: result = CompileChoose(node); break; case XslNodeType.Comment: result = CompileComment(node); break; case XslNodeType.Copy: result = CompileCopy(node); break; case XslNodeType.CopyOf: result = CompileCopyOf(node); break; case XslNodeType.Element: result = CompileElement((NodeCtor)node); break; case XslNodeType.Error: result = CompileError(node); break; case XslNodeType.ForEach: result = CompileForEach((XslNodeEx)node); break; case XslNodeType.If: result = CompileIf(node); break; case XslNodeType.List: result = CompileList(node); break; case XslNodeType.LiteralAttribute: result = CompileLiteralAttribute(node); break; case XslNodeType.LiteralElement: result = CompileLiteralElement(node); break; case XslNodeType.Message: result = CompileMessage(node); break; case XslNodeType.Nop: result = CompileNop(node); break; case XslNodeType.Number: result = CompileNumber((Number)node); break; // case XslNodeType.Otherwise: wrapped by Choose // case XslNodeType.Param: already compiled by CompileProtoTemplate() case XslNodeType.PI: result = CompilePI(node); break; // case XslNodeType.Sort: wrapped by ForEach or ApplyTemplates, see CompileSorts() // case XslNodeType.Template: global level element case XslNodeType.Text: result = CompileText((Text)node); break; case XslNodeType.UseAttributeSet: result = CompileUseAttributeSet(node); break; case XslNodeType.ValueOf: result = CompileValueOf(node); break; case XslNodeType.ValueOfDoe: result = CompileValueOfDoe(node); break; case XslNodeType.Variable: result = CompileVariable(node); break; // case XslNodeType.WithParam: wrapped by CallTemplate or ApplyTemplates, see CompileWithParam() default: Debug.Fail("Unexpected type of AST node: " + nodeType.ToString()); result = null; break; } ExitScope(); Debug.Assert(result != null, "Result of compilation should not be null"); if (result.NodeType == QilNodeType.Sequence && result.Count == 0) { continue; } // Do not create sequence points for literal attributes and use-attribute-sets if (nodeType != XslNodeType.LiteralAttribute && nodeType != XslNodeType.UseAttributeSet) { SetLineInfoCheck(result, node.SourceLine); } result = SetDebugNs(result, nsList); if (nodeType == XslNodeType.Variable) { QilIterator var = _f.Let(result); var.DebugName = node.Name.ToString(); _scope.AddVariable(node.Name, var); // Process all remaining instructions in the recursive call result = _f.Loop(var, CompileInstructions(instructions, i + 1)); i = instructions.Count; } content.Add(result); } if (!IsDebug && content.Count == 1) { return content[0]; } return content; }
private void CompileSort(Sort sort, QilList keyList, ref LoopFocus parentLoop) { Debug.Assert(sort.NodeType == XslNodeType.Sort); QilNode select, select2, lang, order, caseOrder; bool fwdCompat; EnterScope(sort); fwdCompat = sort.ForwardsCompatible; select = CompileXPathExpression(sort.Select); if (sort.Lang != null || sort.DataType != null || sort.Order != null || sort.CaseOrder != null) { // Calculate these attributes in the context of the parent loop LoopFocus curLoopSaved = _curLoop; _curLoop = parentLoop; lang = CompileLangAttribute(sort.Lang, fwdCompat); CompileDataTypeAttribute(sort.DataType, fwdCompat, ref select, out select2); order = CompileOrderAttribute( /*attName: */ "order", /*attValue: */ sort.Order, /*value0: */ "ascending", /*value1: */ "descending", /*fwdCompat:*/ fwdCompat ); caseOrder = CompileOrderAttribute( /*attName: */ "case-order", /*attValue: */ sort.CaseOrder, /*value0: */ "lower-first", /*value1: */ "upper-first", /*fwdCompat:*/ fwdCompat ); // Restore loop context _curLoop = curLoopSaved; } else { select = _f.ConvertToString(select); select2 = lang = order = caseOrder = null; } _strConcat.Reset(); _strConcat.Append(XmlReservedNs.NsCollationBase); _strConcat.Append('/'); _strConcat.Append(lang); char separator = '?'; if (order != null) { _strConcat.Append(separator); _strConcat.Append("descendingOrder="); _strConcat.Append(order); separator = '&'; } if (caseOrder != null) { _strConcat.Append(separator); _strConcat.Append("upperFirst="); _strConcat.Append(caseOrder); separator = '&'; } QilNode collation = _strConcat.ToQil(); QilSortKey result = _f.SortKey(select, collation); // Line information is not copied keyList.Add(result); if (select2 != null) { result = _f.SortKey(select2, collation.DeepClone(_f.BaseFactory)); // Line information is not copied keyList.Add(result); } ExitScope(); }
private void AddNsDecl(QilList content, string prefix, string nsUri) { if (_outputScope.LookupNamespace(prefix) == nsUri) { return; // This prefix is already bound to required namespace. Nothing to do. } _outputScope.AddNamespace(prefix, nsUri); content.Add(_f.NamespaceDecl(_f.String(prefix), _f.String(nsUri))); }