Exemple #1
0
        internal override void Compile(Compiler compiler)
        {
            CompileAttributes(compiler);
            CheckRequiredAttribute(compiler, this.nameAvt, Keywords.s_Name);

            this.name  = PrecalculateAvt(ref this.nameAvt);
            this.nsUri = PrecalculateAvt(ref this.nsAvt);

            // if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
            if (this.nameAvt == null && this.nsAvt == null)
            {
                if (this.name != Keywords.s_Xmlns)
                {
                    this.qname = CreateElementQName(this.name, this.nsUri, compiler.CloneScopeManager());
                }
            }
            else
            {
                this.manager = compiler.CloneScopeManager();
            }

            if (compiler.Recurse())
            {
                Debug.Assert(this.empty == false);
                CompileTemplate(compiler);
                compiler.ToParent();
            }
            this.empty = (this.containedActions == null);
        }
        private PrefixQName       qname; // When we not have AVTs at all we can do this. null otherwise.

        private static PrefixQName CreateAttributeQName(string name, string nsUri, InputScopeManager manager) {
            // if name == "xmlns" we don't need to generate this attribute.
            // to avoid i'ts generation we can return false and not add AtributeCation to it's parent container action
            // for now not creating this.qname will do the trick at execution time
            if (name  == "xmlns") return null;
            if (nsUri == XmlReservedNs.NsXmlNs) {
                throw XsltException.Create(Res.Xslt_ReservedNS, nsUri);
            }

            PrefixQName qname = new PrefixQName();
            qname.SetQName(name);

            qname.Namespace = nsUri != null ? nsUri : manager.ResolveXPathNamespace(qname.Prefix);

            if (qname.Prefix.StartsWith("xml", StringComparison.Ordinal)) {
                if (qname.Prefix.Length == 3) { // prefix == "xml"
                    if (qname.Namespace == XmlReservedNs.NsXml && (qname.Name == "lang" || qname.Name == "space")) {
                        // preserve prefix for xml:lang and xml:space
                    }
                    else {
                        qname.ClearPrefix();
                    }
                }
                else if (qname.Prefix == "xmlns") {
                    if (qname.Namespace == XmlReservedNs.NsXmlNs) {
                        // if NS wasn't specified we have to use prefix to find it and this is imposible for 'xmlns' 
                        throw XsltException.Create(Res.Xslt_InvalidPrefix, qname.Prefix);
                    }
                    else {
                        qname.ClearPrefix();
                    }
                }
            }
            return qname;
        }
Exemple #3
0
        internal override void Compile(Compiler compiler)
        {
            CompileAttributes(compiler);
            CheckRequiredAttribute(compiler, _nameAvt, "name");

            _name = PrecalculateAvt(ref _nameAvt);
            _nsUri = PrecalculateAvt(ref _nsAvt);

            // if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
            if (_nameAvt == null && _nsAvt == null)
            {
                if (_name != "xmlns")
                {
                    _qname = CreateAttributeQName(_name, _nsUri, compiler.CloneScopeManager());
                }
            }
            else
            {
                _manager = compiler.CloneScopeManager();
            }

            if (compiler.Recurse())
            {
                CompileTemplate(compiler);
                compiler.ToParent();
            }
        }
        internal override void Compile(Compiler compiler)
        {
            CompileAttributes(compiler);
            CheckRequiredAttribute(compiler, this.nameAvt, "name");

            this.name  = PrecalculateAvt(ref this.nameAvt);
            this.nsUri = PrecalculateAvt(ref this.nsAvt);

            // if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
            if (this.nameAvt == null && this.nsAvt == null)
            {
                if (this.name != "xmlns")
                {
                    this.qname = CreateAttributeQName(this.name, this.nsUri, compiler.CloneScopeManager());
                }
            }
            else
            {
                this.manager = compiler.CloneScopeManager();
            }

            if (compiler.Recurse())
            {
                CompileTemplate(compiler);
                compiler.ToParent();
            }
        }
        // see http://www.w3.org/TR/xslt#function-element-available
        private bool ElementAvailable(string qname)
        {
            string name, prefix;

            PrefixQName.ParseQualifiedName(qname, out prefix, out name);
            string ns = this.manager.ResolveXmlNamespace(prefix);

            // msxsl:script - is not an "instruction" so we return false for it.
            if (ns == Keywords.s_XsltNamespace)
            {
                return(
                    name == Keywords.s_ApplyImports ||
                    name == Keywords.s_ApplyTemplates ||
                    name == Keywords.s_Attribute ||
                    name == Keywords.s_CallTemplate ||
                    name == Keywords.s_Choose ||
                    name == Keywords.s_Comment ||
                    name == Keywords.s_Copy ||
                    name == Keywords.s_CopyOf ||
                    name == Keywords.s_Element ||
                    name == Keywords.s_Fallback ||
                    name == Keywords.s_ForEach ||
                    name == Keywords.s_If ||
                    name == Keywords.s_Message ||
                    name == Keywords.s_Number ||
                    name == Keywords.s_ProcessingInstruction ||
                    name == Keywords.s_Text ||
                    name == Keywords.s_ValueOf ||
                    name == Keywords.s_Variable
                    );
            }
            return(false);
        }
Exemple #6
0
            public override object Invoke(XsltContext xsltContext, object[] args, XPathNavigator docContext)
            {
                XsltCompileContext xsltCompileContext = (XsltCompileContext)xsltContext;

                string local, prefix;

                PrefixQName.ParseQualifiedName(ToString(args[0]), out prefix, out local);
                string?          ns      = xsltContext.LookupNamespace(prefix);
                XmlQualifiedName keyName = new XmlQualifiedName(local, ns);

                XPathNavigator root = docContext.Clone();

                root.MoveToRoot();

                ArrayList?resultCollection = null;

                foreach (Key key in xsltCompileContext._processor !.KeyList !)
                {
                    if (key.Name == keyName)
                    {
                        Hashtable?keyTable = key.GetKeys(root);
                        if (keyTable == null)
                        {
                            keyTable = xsltCompileContext.BuildKeyTable(key, root);
                            key.AddKey(root, keyTable);
                        }

                        XPathNodeIterator?it = args[1] as XPathNodeIterator;
                        if (it != null)
                        {
                            it = it.Clone();
                            while (it.MoveNext())
                            {
                                resultCollection = AddToList(resultCollection, (ArrayList?)keyTable[it.Current !.Value]);
Exemple #7
0
        internal override void Compile(Compiler compiler)
        {
            CompileAttributes(compiler);
            CheckRequiredAttribute(compiler, _nameAvt, "name");

            _name  = PrecalculateAvt(ref _nameAvt);
            _nsUri = PrecalculateAvt(ref _nsAvt);

            // if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
            if (_nameAvt == null && _nsAvt == null)
            {
                if (_name != "xmlns")
                {
                    _qname = CreateElementQName(_name, _nsUri, compiler.CloneScopeManager());
                }
            }
            else
            {
                _manager = compiler.CloneScopeManager();
            }

            if (compiler.Recurse())
            {
                Debug.Assert(_empty == false);
                CompileTemplate(compiler);
                compiler.ToParent();
            }
            _empty = (this.containedActions == null);
        }
        // see http://www.w3.org/TR/xslt#function-element-available
        private bool ElementAvailable(string qname)
        {
            string name, prefix;

            PrefixQName.ParseQualifiedName(qname, out prefix, out name);
            string ns = this.manager.ResolveXmlNamespace(prefix);

            // msxsl:script - is not an "instruction" so we return false for it.
            if (ns == XmlReservedNs.NsXslt)
            {
                return(
                    name == "apply-imports" ||
                    name == "apply-templates" ||
                    name == "attribute" ||
                    name == "call-template" ||
                    name == "choose" ||
                    name == "comment" ||
                    name == "copy" ||
                    name == "copy-of" ||
                    name == "element" ||
                    name == "fallback" ||
                    name == "for-each" ||
                    name == "if" ||
                    name == "message" ||
                    name == "number" ||
                    name == "processing-instruction" ||
                    name == "text" ||
                    name == "value-of" ||
                    name == "variable"
                    );
            }
            return(false);
        }
Exemple #9
0
        internal XmlQualifiedName CreateXmlQName(string qname)
        {
            string prefix, local;

            PrefixQName.ParseQualifiedName(qname, out prefix, out local);

            return(new XmlQualifiedName(local, _scopeManager.ResolveXmlNamespace(prefix)));
        }
Exemple #10
0
        internal override void Execute(Processor processor, ActionFrame frame)
        {
            Debug.Assert(processor != null && frame != null);

            switch (frame.State)
            {
            case Initialized:
                if (_qname != null)
                {
                    frame.CalulatedName = _qname;
                }
                else
                {
                    frame.CalulatedName = CreateElementQName(
                        _nameAvt == null ? _name : _nameAvt.Evaluate(processor, frame),
                        _nsAvt == null ? _nsUri : _nsAvt.Evaluate(processor, frame),
                        _manager
                        );
                }
                goto case NameDone;

            case NameDone:
            {
                PrefixQName qname = frame.CalulatedName;
                if (processor.BeginEvent(XPathNodeType.Element, qname.Prefix, qname.Name, qname.Namespace, _empty) == false)
                {
                    // Come back later
                    frame.State = NameDone;
                    break;
                }

                if (!_empty)
                {
                    processor.PushActionFrame(frame);
                    frame.State = ProcessingChildren;
                    break;                                      // Allow children to run
                }
                else
                {
                    goto case ProcessingChildren;
                }
            }

            case ProcessingChildren:
                if (processor.EndEvent(XPathNodeType.Element) == false)
                {
                    frame.State = ProcessingChildren;
                    break;
                }
                frame.Finished();
                break;

            default:
                Debug.Fail("Invalid ElementAction execution state");
                break;
            }
        }
        internal override void Execute(Processor processor, ActionFrame frame)
        {
            Debug.Assert(processor != null && frame != null);

            switch (frame.State)
            {
            case Initialized:
                if (this.qname != null)
                {
                    frame.CalulatedName = this.qname;
                }
                else
                {
                    frame.CalulatedName = CreateAttributeQName(
                        this.nameAvt == null ? this.name  : this.nameAvt.Evaluate(processor, frame),
                        this.nsAvt == null ? this.nsUri : this.nsAvt.Evaluate(processor, frame),
                        this.manager
                        );
                    if (frame.CalulatedName == null)
                    {
                        // name == "xmlns" case. Ignore xsl:attribute
                        frame.Finished();
                        break;
                    }
                }
                goto case NameDone;

            case NameDone:
            {
                PrefixQName qname = frame.CalulatedName;
                if (processor.BeginEvent(XPathNodeType.Attribute, qname.Prefix, qname.Name, qname.Namespace, false) == false)
                {
                    // Come back later
                    frame.State = NameDone;
                    break;
                }

                processor.PushActionFrame(frame);
                frame.State = ProcessingChildren;
                break;                                  // Allow children to run
            }

            case ProcessingChildren:
                if (processor.EndEvent(XPathNodeType.Attribute) == false)
                {
                    frame.State = ProcessingChildren;
                    break;
                }
                frame.Finished();
                break;

            default:
                Debug.Fail("Invalid ElementAction execution state");
                break;
            }
        }
        private void AddScript(Compiler compiler)
        {
            NavigatorInput input = compiler.Input;

            ScriptingLanguage lang = ScriptingLanguage.JScript;
            string            implementsNamespace = null;

            if (input.MoveToFirstAttribute())
            {
                do
                {
                    if (input.LocalName == input.Atoms.Language)
                    {
                        string langName = input.Value;
                        if (
                            String.Compare(langName, "jscript", StringComparison.OrdinalIgnoreCase) == 0 ||
                            String.Compare(langName, "javascript", StringComparison.OrdinalIgnoreCase) == 0
                            )
                        {
                            lang = ScriptingLanguage.JScript;
                        }
                        else if (
                            String.Compare(langName, "c#", StringComparison.OrdinalIgnoreCase) == 0 ||
                            String.Compare(langName, "csharp", StringComparison.OrdinalIgnoreCase) == 0
                            )
                        {
                            lang = ScriptingLanguage.CSharp;
                        }
                        else
                        {
                            throw XsltException.Create(Res.Xslt_ScriptInvalidLanguage, langName);
                        }
                    }
                    else if (input.LocalName == input.Atoms.ImplementsPrefix)
                    {
                        if (!PrefixQName.ValidatePrefix(input.Value))
                        {
                            throw XsltException.Create(Res.Xslt_InvalidAttrValue, input.LocalName, input.Value);
                        }
                        implementsNamespace = compiler.ResolveXmlNamespace(input.Value);
                    }
                }while (input.MoveToNextAttribute());
                input.ToParent();
            }
            if (implementsNamespace == null)
            {
                throw XsltException.Create(Res.Xslt_MissingAttribute, input.Atoms.ImplementsPrefix);
            }
            if (!input.Recurse() || input.NodeType != XPathNodeType.Text)
            {
                throw XsltException.Create(Res.Xslt_ScriptEmpty);
            }
            compiler.AddScript(input.Value, lang, implementsNamespace, input.BaseURI, input.LineNumber);
            input.ToParent();
        }
Exemple #13
0
        // see: http://www.w3.org/TR/xslt#function-function-available
        private bool FunctionAvailable(string qname)
        {
            string name, prefix;

            PrefixQName.ParseQualifiedName(qname, out prefix, out name);
            string ns = LookupNamespace(prefix);

            if (ns == XmlReservedNs.NsMsxsl)
            {
                return(name == f_NodeSet);
            }
            else if (ns.Length == 0)
            {
                switch (name)
                {
                case "last":
                case "position":
                case "name":
                case "namespace-uri":
                case "local-name":
                case "count":
                case "id":
                case "string":
                case "concat":
                case "starts-with":
                case "contains":
                case "substring-before":
                case "substring-after":
                case "substring":
                case "string-length":
                case "normalize-space":
                case "translate":
                case "boolean":
                case "not":
                case "true":
                case "false":
                case "lang":
                case "number":
                case "sum":
                case "floor":
                case "ceiling":
                case "round":
                    return(true);

                // XSLT functions:
                default:
                    return(s_FunctionTable[name] != null && name != "unparsed-entity-uri");
                }
            }
            else
            {
                // Is this script or extention function?
                return(GetExtentionMethod(ns, name, /*argTypes*/ null, out _) != null);
            }
        }
        // see: http://www.w3.org/TR/xslt#function-function-available
        private bool FunctionAvailable(string qname)
        {
            string name, prefix;

            PrefixQName.ParseQualifiedName(qname, out prefix, out name);
            string ns = LookupNamespace(prefix);

            if (ns == XmlReservedNs.NsMsxsl)
            {
                return(name == f_NodeSet);
            }
            else if (ns.Length == 0)
            {
                return(
                    // It'll be better to get this information from XPath
                    name == "last" ||
                    name == "position" ||
                    name == "name" ||
                    name == "namespace-uri" ||
                    name == "local-name" ||
                    name == "count" ||
                    name == "id" ||
                    name == "string" ||
                    name == "concat" ||
                    name == "starts-with" ||
                    name == "contains" ||
                    name == "substring-before" ||
                    name == "substring-after" ||
                    name == "substring" ||
                    name == "string-length" ||
                    name == "normalize-space" ||
                    name == "translate" ||
                    name == "boolean" ||
                    name == "not" ||
                    name == "true" ||
                    name == "false" ||
                    name == "lang" ||
                    name == "number" ||
                    name == "sum" ||
                    name == "floor" ||
                    name == "ceiling" ||
                    name == "round" ||
                    // XSLT functions:
                    (s_FunctionTable[name] != null && name != "unparsed-entity-uri")
                    );
            }
            else
            {
                // Is this script or extention function?
                object extension;
                return(GetExtentionMethod(ns, name, /*argTypes*/ null, out extension) != null);
            }
        }
Exemple #15
0
        private static PrefixQName?CreateAttributeQName(string name, string?nsUri, InputScopeManager?manager)
        {
            // if name == "xmlns" we don't need to generate this attribute.
            // to avoid its generation we can return false and not add AttributeCreation to it's parent container action
            // for now not creating this.qname will do the trick at execution time
            if (name == "xmlns")
            {
                return(null);
            }
            if (nsUri == XmlReservedNs.NsXmlNs)
            {
                throw XsltException.Create(SR.Xslt_ReservedNS, nsUri);
            }

            PrefixQName qname = new PrefixQName();

            qname.SetQName(name);

            qname.Namespace = nsUri != null ? nsUri : manager !.ResolveXPathNamespace(qname.Prefix);

            if (qname.Prefix.StartsWith("xml", StringComparison.Ordinal))
            {
                if (qname.Prefix.Length == 3)
                { // prefix == "xml"
                    if (qname.Namespace == XmlReservedNs.NsXml && (qname.Name == "lang" || qname.Name == "space"))
                    {
                        // preserve prefix for xml:lang and xml:space
                    }
                    else
                    {
                        qname.ClearPrefix();
                    }
                }
                else if (qname.Prefix == "xmlns")
                {
                    if (qname.Namespace == XmlReservedNs.NsXmlNs)
                    {
                        // if NS wasn't specified we have to use prefix to find it and this is imposible for 'xmlns'
                        throw XsltException.Create(SR.Xslt_InvalidPrefix, qname.Prefix);
                    }
                    else
                    {
                        qname.ClearPrefix();
                    }
                }
            }
            return(qname);
        }
        private static PrefixQName CreateElementQName(string name, string nsUri, InputScopeManager manager) {
            if (nsUri == XmlReservedNs.NsXmlNs) {
                throw XsltException.Create(Res.Xslt_ReservedNS, nsUri);
            }

            PrefixQName qname = new PrefixQName();
            qname.SetQName(name);

            if (nsUri == null) {
                qname.Namespace = manager.ResolveXmlNamespace(qname.Prefix);
            }
            else {
                qname.Namespace = nsUri;
            }
            return qname;
        }
Exemple #17
0
 public string GetNsAlias(ref string prefix)
 {
     Debug.Assert(
         Keywords.Equals(this.input.LocalName, this.input.Atoms.StylesheetPrefix) ||
         Keywords.Equals(this.input.LocalName, this.input.Atoms.ResultPrefix)
         );
     if (Keywords.Compare(this.input.Atoms.HashDefault, prefix))
     {
         prefix = string.Empty;
         return(this.DefaultNamespace);
     }
     else
     {
         if (!PrefixQName.ValidatePrefix(prefix))
         {
             throw XsltException.Create(Res.Xslt_InvalidAttrValue, this.input.LocalName, prefix);
         }
         return(this.ResolveXPathNamespace(prefix));
     }
 }
Exemple #18
0
 public string GetNsAlias(ref string prefix)
 {
     Debug.Assert(
         Ref.Equal(_input.LocalName, _input.Atoms.StylesheetPrefix) ||
         Ref.Equal(_input.LocalName, _input.Atoms.ResultPrefix)
         );
     if (prefix == "#default")
     {
         prefix = string.Empty;
         return(this.DefaultNamespace);
     }
     else
     {
         if (!PrefixQName.ValidatePrefix(prefix))
         {
             throw XsltException.Create(SR.Xslt_InvalidAttrValue, _input.LocalName, prefix);
         }
         return(this.ResolveXPathNamespace(prefix));
     }
 }
Exemple #19
0
        private static PrefixQName CreateElementQName(string name, string nsUri, InputScopeManager manager)
        {
            if (nsUri == XmlReservedNs.NsXmlNs)
            {
                throw XsltException.Create(SR.Xslt_ReservedNS, nsUri);
            }

            PrefixQName qname = new PrefixQName();

            qname.SetQName(name);

            if (nsUri == null)
            {
                qname.Namespace = manager.ResolveXmlNamespace(qname.Prefix);
            }
            else
            {
                qname.Namespace = nsUri;
            }
            return(qname);
        }
        private String SystemProperty(string qname)
        {
            String result = string.Empty;

            string prefix;
            string local;

            PrefixQName.ParseQualifiedName(qname, out prefix, out local);

            // verify the prefix corresponds to the Xslt namespace
            string urn = LookupNamespace(prefix);

            if (urn == XmlReservedNs.NsXslt)
            {
                if (local == "version")
                {
                    result = "1";
                }
                else if (local == "vendor")
                {
                    result = "Microsoft";
                }
                else if (local == "vendor-url")
                {
                    result = "http://www.microsoft.com";
                }
            }
            else
            {
                if (urn == null && prefix != null)
                {
                    // if prefix exist it has to be mapped to namespace.
                    // Can it be "" here ?
                    throw XsltException.Create(Res.Xslt_InvalidPrefix, prefix);
                }
                return(string.Empty);
            }

            return(result);
        }
        internal override void Compile(Compiler compiler) {
            CompileAttributes(compiler);
            CheckRequiredAttribute(compiler, this.nameAvt, Keywords.s_Name);

            this.name  = PrecalculateAvt(ref this.nameAvt);
            this.nsUri = PrecalculateAvt(ref this.nsAvt  );

            // if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
            if (this.nameAvt == null && this.nsAvt == null) {
                if(this.name != Keywords.s_Xmlns) {
                    this.qname = CreateAttributeQName(this.name, this.nsUri, compiler.CloneScopeManager());                    
                }
            }
            else {
                this.manager = compiler.CloneScopeManager();
            }

            if (compiler.Recurse()) {
                CompileTemplate(compiler);
                compiler.ToParent();
            }
        }
Exemple #22
0
        private static double NameTest(string name)
        {
            if (name == "*")
            {
                return(-0.5);
            }
            int idx = name.Length - 2;

            if (0 <= idx && name[idx] == ':' && name[idx + 1] == '*')
            {
                if (!PrefixQName.ValidatePrefix(name.Substring(0, idx)))
                {
                    throw XsltException.Create(SR.Xslt_InvalidAttrValue, "elements", name);
                }
                return(-0.25);
            }
            else
            {
                PrefixQName.ParseQualifiedName(name, out _, out _);
                return(0);
            }
        }
        private DecimalFormat ResolveFormatName(string formatName)
        {
            string ns = string.Empty, local = string.Empty;

            if (formatName != null)
            {
                string prefix;
                PrefixQName.ParseQualifiedName(formatName, out prefix, out local);
                ns = LookupNamespace(prefix);
            }
            DecimalFormat formatInfo = this.processor.RootAction.GetDecimalFormat(new XmlQualifiedName(local, ns));

            if (formatInfo == null)
            {
                if (formatName != null)
                {
                    throw XsltException.Create(Res.Xslt_NoDecimalFormat, formatName);
                }
                formatInfo = new DecimalFormat(new NumberFormatInfo(), '#', '0', ';');
            }
            return(formatInfo);
        }
        double NameTest(String name)
        {
            if (name == "*")
            {
                return(-0.5);
            }
            int idx = name.Length - 2;

            if (0 <= idx && name[idx] == ':' && name[idx + 1] == '*')
            {
                if (!PrefixQName.ValidatePrefix(name.Substring(0, idx)))
                {
                    throw XsltException.Create(Res.Xslt_InvalidAttrValue, Keywords.s_Elements, name);
                }
                return(-0.25);
            }
            else
            {
                string prefix, localname;
                PrefixQName.ParseQualifiedName(name, out prefix, out localname);
                return(0);
            }
        }
Exemple #25
0
        private XmlDataType ParseDataType(string value, InputScopeManager manager)
        {
            if (value == null)
            { // Avt is not constant, or attribute wasn't defined
                return(XmlDataType.Text);
            }
            if (value == "text")
            {
                return(XmlDataType.Text);
            }
            if (value == "number")
            {
                return(XmlDataType.Number);
            }
            String prefix, localname;

            PrefixQName.ParseQualifiedName(value, out prefix, out localname);
            manager.ResolveXmlNamespace(prefix);
            if (prefix.Length == 0 && !_forwardCompatibility)
            {
                throw XsltException.Create(SR.Xslt_InvalidAttrValue, "data-type", value);
            }
            return(XmlDataType.Text);
        }
        internal override void Compile(Compiler compiler) {
            CompileAttributes(compiler);
            CheckRequiredAttribute(compiler, this.nameAvt, "name");

            this.name  = PrecalculateAvt(ref this.nameAvt);
            this.nsUri = PrecalculateAvt(ref this.nsAvt  );

            // if both name and ns are not AVT we can calculate qname at compile time and will not need namespace manager anymore
            if (this.nameAvt == null && this.nsAvt == null) {
                if(this.name != "xmlns") {
                    this.qname = CreateElementQName(this.name, this.nsUri, compiler.CloneScopeManager());                    
                }
            }
            else {
                this.manager = compiler.CloneScopeManager();
            }

            if (compiler.Recurse()) {
                Debug.Assert(this.empty == false);
                CompileTemplate(compiler);
                compiler.ToParent();
            }
            this.empty = (this.containedActions == null) ;
        }
Exemple #27
0
 internal void SetQName(string qname)
 {
     PrefixQName.ParseQualifiedName(qname, out Prefix, out Name);
 }