◆ PrecompileProtoTemplatesHeaders()

void System.Xml.Xsl.Xslt.QilGenerator.PrecompileProtoTemplatesHeaders ( )
inlineprivate
Definition at line 454 of file QilGenerator.cs.
    {
        List<VarPar> list = null;
        Dictionary<VarPar, Template> dictionary = null;
        Dictionary<VarPar, QilFunction> dictionary2 = null;
        foreach (ProtoTemplate allTemplate in _compiler.AllTemplates)
        {
            QilList qilList = _f.FormalParameterList();
            XslFlags xslFlags = ((!IsDebug) ? allTemplate.Flags : XslFlags.FocusFilter);
            QilList qilList2 = EnterScope(allTemplate);
            if ((xslFlags & XslFlags.Current) != 0)
            {
                qilList.Add(CreateXslParam(CloneName(_nameCurrent), XmlQueryTypeFactory.NodeNotRtf));
            }
            if ((xslFlags & XslFlags.Position) != 0)
            {
                qilList.Add(CreateXslParam(CloneName(_namePosition), XmlQueryTypeFactory.DoubleX));
            }
            if ((xslFlags & XslFlags.Last) != 0)
            {
                qilList.Add(CreateXslParam(CloneName(_nameLast), XmlQueryTypeFactory.DoubleX));
            }
            if (IsDebug && qilList2 != null)
            {
                QilParameter qilParameter = CreateXslParam(CloneName(_nameNamespaces), XmlQueryTypeFactory.NamespaceS);
                qilParameter.DefaultValue = GetNsVar(qilList2);
                qilList.Add(qilParameter);
            }
            if (allTemplate is Template template)
            {
                _funcFocus.StartFocus(qilList, xslFlags);
                for (int i = 0; i < allTemplate.Content.Count; i++)
                {
                    XslNode xslNode = allTemplate.Content[i];
                    if (xslNode.NodeType == XslNodeType.Text)
                    {
                        continue;
                    }
                    if (xslNode.NodeType != XslNodeType.Param)
                    {
                        break;
                    }
                    VarPar varPar = (VarPar)xslNode;
                    EnterScope(varPar);
                    if (_scope.IsLocalVariable(varPar.Name.LocalName, varPar.Name.NamespaceUri))
                    {
                        ReportError(System.SR.Xslt_DupLocalVariable, varPar.Name.QualifiedName);
                    }
                    QilParameter qilParameter2 = CreateXslParam(varPar.Name, ChooseBestType(varPar));
                    if (IsDebug)
                    {
                        qilParameter2.Annotation = varPar;
                    }
                    else if ((varPar.DefValueFlags & XslFlags.HasCalls) == 0)
                    {
                        qilParameter2.DefaultValue = CompileVarParValue(varPar);
                    }
                    else
                    {
                        QilList qilList3 = _f.FormalParameterList();
                        QilList qilList4 = _f.ActualParameterList();
                        for (int j = 0; j < qilList.Count; j++)
                        {
                            QilParameter qilParameter3 = _f.Parameter(qilList[j].XmlType);
                            qilParameter3.DebugName = ((QilParameter)qilList[j]).DebugName;
                            qilParameter3.Name = CloneName(((QilParameter)qilList[j]).Name);
                            SetLineInfo(qilParameter3, qilList[j].SourceLine);
                            qilList3.Add(qilParameter3);
                            qilList4.Add(qilList[j]);
                        }
                        varPar.Flags |= template.Flags & XslFlags.FocusFilter;
                        QilFunction qilFunction = _f.Function(qilList3, _f.Boolean((varPar.DefValueFlags & XslFlags.SideEffects) != 0), ChooseBestType(varPar));
                        qilFunction.SourceLine = SourceLineInfo.NoSource;
                        qilFunction.DebugName = "<xsl:param name=\"" + varPar.Name.QualifiedName + "\">";
                        qilParameter2.DefaultValue = _f.Invoke(qilFunction, qilList4);
                        if (list == null)
                        {
                            list = new List<VarPar>();
                            dictionary = new Dictionary<VarPar, Template>();
                            dictionary2 = new Dictionary<VarPar, QilFunction>();
                        }
                        list.Add(varPar);
                        dictionary.Add(varPar, template);
                        dictionary2.Add(varPar, qilFunction);
                    }
                    SetLineInfo(qilParameter2, varPar.SourceLine);
                    ExitScope();
                    _scope.AddVariable(varPar.Name, qilParameter2);
                    qilList.Add(qilParameter2);
                }
                _funcFocus.StopFocus();
            }
            ExitScope();
            allTemplate.Function = _f.Function(qilList, _f.Boolean((allTemplate.Flags & XslFlags.SideEffects) != 0), (allTemplate is AttributeSet) ? XmlQueryTypeFactory.AttributeS : XmlQueryTypeFactory.NodeNotRtfS);
            allTemplate.Function.DebugName = allTemplate.GetDebugName();
            SetLineInfo(allTemplate.Function, allTemplate.SourceLine ?? SourceLineInfo.NoSource);
            _functions.Add(allTemplate.Function);
        }
        if (list == null)
        {
            return;
        }
        foreach (VarPar item in list)
        {
            Template node = dictionary[item];
            QilFunction qilFunction2 = dictionary2[item];
            _funcFocus.StartFocus(qilFunction2.Arguments, item.Flags);
            EnterScope(node);
            EnterScope(item);
            foreach (QilParameter argument in qilFunction2.Arguments)
            {
                _scope.AddVariable(argument.Name, argument);
            }
            qilFunction2.Definition = CompileVarParValue(item);
            SetLineInfo(qilFunction2.Definition, item.SourceLine);
            ExitScope();
            ExitScope();
            _funcFocus.StopFocus();
            _functions.Add(qilFunction2);
        }
    }
Referenced by System.Xml.Xsl.Xslt.QilGenerator.Compile().