CompileTopLevelElements()

void System.Xml.Xsl.XsltOld.ContainerAction.CompileTopLevelElements ( Compiler compiler )

inlineprotectedinherited

Definition at line 412 of file ContainerAction.cs.

    {
        if (!compiler.Recurse())
        {
            return;
        }
        NavigatorInput input = compiler.Input;
        bool flag = false;
        do
        {
            switch (input.NodeType)
            {
            case XPathNodeType.Element:
            {
                string localName = input.LocalName;
                string namespaceURI = input.NamespaceURI;
                if (Ref.Equal(namespaceURI, input.Atoms.UriXsl))
                {
                    if (Ref.Equal(localName, input.Atoms.Import))
                    {
                        if (flag)
                        {
                            throw XsltException.Create(System.SR.Xslt_NotFirstImport);
                        }
                        Uri uri = compiler.ResolveUri(compiler.GetSingleAttribute(compiler.Input.Atoms.Href));
                        string text = uri.ToString();
                        if (compiler.IsCircularReference(text))
                        {
                            throw XsltException.Create(System.SR.Xslt_CircularInclude, text);
                        }
                        compiler.CompiledStylesheet.Imports.Add(uri);
                        CheckEmpty(compiler);
                        break;
                    }
                    if (Ref.Equal(localName, input.Atoms.Include))
                    {
                        flag = true;
                        CompileInclude(compiler);
                        break;
                    }
                    flag = true;
                    compiler.PushNamespaceScope();
                    if (Ref.Equal(localName, input.Atoms.StripSpace))
                    {
                        CompileSpace(compiler, preserve: false);
                    }
                    else if (Ref.Equal(localName, input.Atoms.PreserveSpace))
                    {
                        CompileSpace(compiler, preserve: true);
                    }
                    else if (Ref.Equal(localName, input.Atoms.Output))
                    {
                        CompileOutput(compiler);
                    }
                    else if (Ref.Equal(localName, input.Atoms.Key))
                    {
                        CompileKey(compiler);
                    }
                    else if (Ref.Equal(localName, input.Atoms.DecimalFormat))
                    {
                        CompileDecimalFormat(compiler);
                    }
                    else if (Ref.Equal(localName, input.Atoms.NamespaceAlias))
                    {
                        CompileNamespaceAlias(compiler);
                    }
                    else if (Ref.Equal(localName, input.Atoms.AttributeSet))
                    {
                        compiler.AddAttributeSet(compiler.CreateAttributeSetAction());
                    }
                    else if (Ref.Equal(localName, input.Atoms.Variable))
                    {
                        VariableAction variableAction = compiler.CreateVariableAction(VariableType.GlobalVariable);
                        if (variableAction != null)
                        {
                            AddAction(variableAction);
                        }
                    }
                    else if (Ref.Equal(localName, input.Atoms.Param))
                    {
                        VariableAction variableAction2 = compiler.CreateVariableAction(VariableType.GlobalParameter);
                        if (variableAction2 != null)
                        {
                            AddAction(variableAction2);
                        }
                    }
                    else if (Ref.Equal(localName, input.Atoms.Template))
                    {
                        compiler.AddTemplate(compiler.CreateTemplateAction());
                    }
                    else if (!compiler.ForwardCompatibility)
                    {
                        throw compiler.UnexpectedKeyword();
                    }
                    compiler.PopScope();
                }
                else if (namespaceURI == input.Atoms.UrnMsxsl && localName == input.Atoms.Script)
                {
                    AddScript(compiler);
                }
                else if (namespaceURI.Length == 0)
                {
                    throw XsltException.Create(System.SR.Xslt_NullNsAtTopLevel, input.Name);
                }
                break;
            }
            default:
                throw XsltException.Create(System.SR.Xslt_InvalidContents, "stylesheet");
            case XPathNodeType.SignificantWhitespace:
            case XPathNodeType.Whitespace:
            case XPathNodeType.ProcessingInstruction:
            case XPathNodeType.Comment:
                break;
            }
        }
        while (compiler.Advance());
        compiler.ToParent();
    }

References System.Xml.Xsl.XsltOld.ContainerAction.AddAction(), System.Xml.Xsl.XsltOld.ContainerAction.AddScript(), System.Xml.Xsl.XsltOld.CompiledAction.CheckEmpty(), System.Xml.Xsl.XsltOld.ContainerAction.CompileDecimalFormat(), System.Xml.Xsl.XsltOld.ContainerAction.CompileInclude(), System.Xml.Xsl.XsltOld.ContainerAction.CompileKey(), System.Xml.Xsl.XsltOld.ContainerAction.CompileNamespaceAlias(), System.Xml.Xsl.XsltOld.ContainerAction.CompileOutput(), System.Xml.Xsl.XsltOld.ContainerAction.CompileSpace(), System.Xml.Xsl.XsltException.Create(), System.Xml.Dictionary, System.Xml.Ref.Equal(), System.input, System.Xml.Xsl.XsltOld.NavigatorInput.LocalName, System.text, System.Uri.ToString(), System.SR.Xslt_CircularInclude, System.SR.Xslt_InvalidContents, System.SR.Xslt_NotFirstImport, and System.SR.Xslt_NullNsAtTopLevel.

Referenced by System.Xml.Xsl.XsltOld.ContainerAction.CompileDocument().