Beispiel #1
0
        private ExpressionToken LoadItemSelectionCondition(XmlNode itemNode)
        {
            using (this.StackFrame(itemNode))
            {
                bool expressionNodeFound = false;     // cardinality 1

                ExpressionNodeMatch expressionMatch = new ExpressionNodeMatch(this);
                foreach (XmlNode n in itemNode.ChildNodes)
                {
                    if (expressionMatch.MatchNode(n))
                    {
                        if (expressionNodeFound)
                        {
                            this.ProcessDuplicateNode(n);
                            return(null); // fatal error
                        }
                        expressionNodeFound = true;
                        if (!expressionMatch.ProcessNode(n))
                        {
                            return(null);
                        }
                    }
                    else
                    {
                        this.ProcessUnknownNode(n);
                    }
                }

                return(expressionMatch.GenerateExpressionToken());
            }
        }
 private TypeOrGroupReference LoadSelectionConditionNode(System.Xml.XmlNode selectionConditionNode)
 {
     using (base.StackFrame(selectionConditionNode))
     {
         TypeOrGroupReference reference = null;
         bool flag = false;
         bool flag2 = false;
         bool flag3 = false;
         ExpressionNodeMatch match = new ExpressionNodeMatch(this);
         foreach (System.Xml.XmlNode node in selectionConditionNode.ChildNodes)
         {
             if (base.MatchNodeName(node, "SelectionSetName"))
             {
                 if (flag3)
                 {
                     base.ProcessDuplicateAlternateNode(node, "SelectionSetName", "TypeName");
                     return null;
                 }
                 flag3 = true;
                 TypeGroupReference reference2 = this.LoadTypeGroupReference(node);
                 if (reference2 == null)
                 {
                     return null;
                 }
                 reference = reference2;
             }
             else if (base.MatchNodeName(node, "TypeName"))
             {
                 if (flag2)
                 {
                     base.ProcessDuplicateAlternateNode(node, "SelectionSetName", "TypeName");
                     return null;
                 }
                 flag2 = true;
                 TypeReference reference3 = this.LoadTypeReference(node);
                 if (reference3 == null)
                 {
                     return null;
                 }
                 reference = reference3;
             }
             else if (match.MatchNode(node))
             {
                 if (flag)
                 {
                     base.ProcessDuplicateNode(node);
                     return null;
                 }
                 flag = true;
                 if (!match.ProcessNode(node))
                 {
                     return null;
                 }
             }
             else
             {
                 base.ProcessUnknownNode(node);
             }
         }
         if (flag2 && flag3)
         {
             base.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.SelectionSetNameAndTypeName, base.ComputeCurrentXPath(), base.FilePath));
             return null;
         }
         if (reference == null)
         {
             base.ReportMissingNodes(new string[] { "SelectionSetName", "TypeName" });
             return null;
         }
         if (flag)
         {
             reference.conditionToken = match.GenerateExpressionToken();
             if (reference.conditionToken == null)
             {
                 return null;
             }
             return reference;
         }
         base.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.ExpectExpression, base.ComputeCurrentXPath(), base.FilePath));
         return null;
     }
 }
 private bool LoadPropertyBaseHelper(System.Xml.XmlNode propertyBaseNode, PropertyTokenBase ptb, List<System.Xml.XmlNode> unprocessedNodes)
 {
     ExpressionNodeMatch match = new ExpressionNodeMatch(this);
     bool flag = false;
     bool flag2 = false;
     bool flag3 = false;
     ExpressionToken token = null;
     foreach (System.Xml.XmlNode node in propertyBaseNode.ChildNodes)
     {
         if (match.MatchNode(node))
         {
             if (flag)
             {
                 base.ProcessDuplicateNode(node);
                 return false;
             }
             flag = true;
             if (!match.ProcessNode(node))
             {
                 return false;
             }
         }
         else if (base.MatchNodeName(node, "EnumerateCollection"))
         {
             if (flag2)
             {
                 base.ProcessDuplicateNode(node);
                 return false;
             }
             flag2 = true;
             if (!this.ReadBooleanNode(node, out ptb.enumerateCollection))
             {
                 return false;
             }
         }
         else if (base.MatchNodeName(node, "ItemSelectionCondition"))
         {
             if (flag3)
             {
                 base.ProcessDuplicateNode(node);
                 return false;
             }
             flag3 = true;
             token = this.LoadItemSelectionCondition(node);
             if (token == null)
             {
                 return false;
             }
         }
         else if (!XmlLoaderBase.IsFilteredOutNode(node))
         {
             unprocessedNodes.Add(node);
         }
     }
     if (flag)
     {
         ExpressionToken token2 = match.GenerateExpressionToken();
         if (token2 == null)
         {
             return false;
         }
         ptb.expression = token2;
         ptb.conditionToken = token;
     }
     return true;
 }
 private ExpressionToken LoadItemSelectionCondition(System.Xml.XmlNode itemNode)
 {
     using (base.StackFrame(itemNode))
     {
         bool flag = false;
         ExpressionNodeMatch match = new ExpressionNodeMatch(this);
         foreach (System.Xml.XmlNode node in itemNode.ChildNodes)
         {
             if (match.MatchNode(node))
             {
                 if (flag)
                 {
                     base.ProcessDuplicateNode(node);
                     return null;
                 }
                 flag = true;
                 if (!match.ProcessNode(node))
                 {
                     return null;
                 }
             }
             else
             {
                 base.ProcessUnknownNode(node);
             }
         }
         return match.GenerateExpressionToken();
     }
 }
 private GroupBy LoadGroupBySection(System.Xml.XmlNode groupByNode)
 {
     using (base.StackFrame(groupByNode))
     {
         ExpressionNodeMatch match = new ExpressionNodeMatch(this);
         ComplexControlMatch match2 = new ComplexControlMatch(this);
         bool flag = false;
         bool flag2 = false;
         bool flag3 = false;
         GroupBy by = new GroupBy();
         TextToken token = null;
         foreach (System.Xml.XmlNode node in groupByNode)
         {
             if (match.MatchNode(node))
             {
                 if (flag)
                 {
                     base.ProcessDuplicateNode(node);
                     return null;
                 }
                 flag = true;
                 if (!match.ProcessNode(node))
                 {
                     return null;
                 }
             }
             else if (match2.MatchNode(node))
             {
                 if (flag2)
                 {
                     base.ProcessDuplicateAlternateNode(node, "CustomControl", "CustomControlName");
                     return null;
                 }
                 flag2 = true;
                 if (!match2.ProcessNode(node))
                 {
                     return null;
                 }
             }
             else if (base.MatchNodeNameWithAttributes(node, "Label"))
             {
                 if (flag3)
                 {
                     base.ProcessDuplicateAlternateNode(node, "CustomControl", "CustomControlName");
                     return null;
                 }
                 flag3 = true;
                 token = this.LoadLabel(node);
                 if (token == null)
                 {
                     return null;
                 }
             }
             else
             {
                 base.ProcessUnknownNode(node);
             }
         }
         if (flag2 && flag3)
         {
             base.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.ControlAndLabel, base.ComputeCurrentXPath(), base.FilePath));
             return null;
         }
         if (flag2 || flag3)
         {
             if (!flag)
             {
                 base.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.ControlLabelWithoutExpression, base.ComputeCurrentXPath(), base.FilePath));
                 return null;
             }
             if (flag2)
             {
                 by.startGroup.control = match2.Control;
             }
             else if (flag3)
             {
                 by.startGroup.labelTextToken = token;
             }
         }
         if (flag)
         {
             ExpressionToken token2 = match.GenerateExpressionToken();
             if (token2 == null)
             {
                 return null;
             }
             by.startGroup.expression = token2;
             return by;
         }
         base.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.ExpectExpression, base.ComputeCurrentXPath(), base.FilePath));
         return null;
     }
 }
Beispiel #6
0
            internal bool ProcessExpressionDirectives(XmlNode containerNode, List<XmlNode> unprocessedNodes)
            {
                if (containerNode == null)
                    throw PSTraceSource.NewArgumentNullException("containerNode");

                string formatString = null;
                TextToken textToken = null;
                ExpressionNodeMatch expressionMatch = new ExpressionNodeMatch(_loader);

                bool formatStringNodeFound = false; // cardinality 0..1
                bool expressionNodeFound = false;   // cardinality 0..1
                bool textNodeFound = false;         // cardinality 0..1

                foreach (XmlNode n in containerNode.ChildNodes)
                {
                    if (expressionMatch.MatchNode(n))
                    {
                        if (expressionNodeFound)
                        {
                            _loader.ProcessDuplicateNode(n);
                            return false; // fatal error
                        }
                        expressionNodeFound = true;
                        if (!expressionMatch.ProcessNode(n))
                            return false; // fatal error
                    }
                    else if (_loader.MatchNodeName(n, XmlTags.FormatStringNode))
                    {
                        if (formatStringNodeFound)
                        {
                            _loader.ProcessDuplicateNode(n);
                            return false; // fatal error
                        }

                        formatStringNodeFound = true;
                        formatString = _loader.GetMandatoryInnerText(n);
                        if (formatString == null)
                        {
                            //Error at XPath {0} in file {1}: Missing a format string.
                            _loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NoFormatString, _loader.ComputeCurrentXPath(), _loader.FilePath));
                            return false; // fatal error
                        }
                    }
                    else if (_loader.MatchNodeNameWithAttributes(n, XmlTags.TextNode))
                    {
                        if (textNodeFound)
                        {
                            _loader.ProcessDuplicateNode(n);
                            return false; // fatal error
                        }
                        textNodeFound = true;
                        textToken = _loader.LoadText(n);
                        if (textToken == null)
                        {
                            //Error at XPath {0} in file {1}: Invalid {2}.
                            _loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.InvalidNode, _loader.ComputeCurrentXPath(), _loader.FilePath, XmlTags.TextNode));
                            return false; // fatal error
                        }
                    }
                    else
                    {
                        // for further processing by calling context
                        unprocessedNodes.Add(n);
                    }
                } // foreach

                if (expressionNodeFound)
                {
                    // RULE: cannot have a text node and an expression at the same time
                    if (textNodeFound)
                    {
                        //Error at XPath {0} in file {1}: {2} cannot be specified with an expression.
                        _loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NodeWithExpression, _loader.ComputeCurrentXPath(),
                            _loader.FilePath, XmlTags.TextNode));
                        return false; // fatal error
                    }

                    ExpressionToken expression = expressionMatch.GenerateExpressionToken();
                    if (expression == null)
                    {
                        return false; // fatal error
                    }

                    // set the output data
                    if (!string.IsNullOrEmpty(formatString))
                    {
                        _formatString = formatString;
                    }
                    _expression = expression;
                }
                else
                {
                    // RULE: we cannot have a format string without an expression node
                    if (formatStringNodeFound)
                    {
                        //Error at XPath {0} in file {1}: {2} cannot be specified without an expression.
                        _loader.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.NodeWithoutExpression, _loader.ComputeCurrentXPath(),
                            _loader.FilePath, XmlTags.FormatStringNode));
                        return false; // fatal error
                    }

                    // we might have a text node
                    if (textNodeFound)
                    {
                        _textToken = textToken;
                    }
                }

                return true;
            }
Beispiel #7
0
        private GroupBy LoadGroupBySection(XmlNode groupByNode)
        {
            using (this.StackFrame(groupByNode))
            {
                ExpressionNodeMatch expressionMatch = new ExpressionNodeMatch(this);
                ComplexControlMatch controlMatch = new ComplexControlMatch(this);

                bool expressionNodeFound = false;       // cardinality 0..1

                // these two nodes are mutually exclusive
                bool controlFound = false;              // cardinality 0..1
                bool labelFound = false;              // cardinality 0..1

                GroupBy groupBy = new GroupBy();
                TextToken labelTextToken = null;

                foreach (XmlNode n in groupByNode)
                {
                    if (expressionMatch.MatchNode(n))
                    {
                        if (expressionNodeFound)
                        {
                            this.ProcessDuplicateNode(n);
                            return null; // fatal error
                        }
                        expressionNodeFound = true;
                        if (!expressionMatch.ProcessNode(n))
                            return null; // fatal error
                    }
                    else if (controlMatch.MatchNode(n))
                    {
                        if (controlFound)
                        {
                            this.ProcessDuplicateAlternateNode(n, XmlTags.ComplexControlNode, XmlTags.ComplexControlNameNode);
                            return null;
                        }
                        controlFound = true;
                        if (!controlMatch.ProcessNode(n))
                            return null; // fatal error
                    }
                    else if (MatchNodeNameWithAttributes(n, XmlTags.LabelNode))
                    {
                        if (labelFound)
                        {
                            this.ProcessDuplicateAlternateNode(n, XmlTags.ComplexControlNode, XmlTags.ComplexControlNameNode);
                            return null;
                        }
                        labelFound = true;

                        labelTextToken = LoadLabel(n);
                        if (labelTextToken == null)
                        {
                            return null; // fatal error
                        }
                    }
                    else
                    {
                        this.ProcessUnknownNode(n);
                    }
                }

                if (controlFound && labelFound)
                {
                    //Error at XPath {0} in file {1}: Cannot have control and label at the same time.
                    this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.ControlAndLabel, ComputeCurrentXPath(), FilePath));
                    return null; // fatal error
                }

                if (controlFound || labelFound)
                {
                    if (!expressionNodeFound)
                    {
                        //Error at XPath {0} in file {1}: Cannot have control or label without an expression.
                        this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.ControlLabelWithoutExpression, ComputeCurrentXPath(), FilePath));
                        return null; // fatal error
                    }
                    if (controlFound)
                    {
                        groupBy.startGroup.control = controlMatch.Control;
                    }
                    else if (labelFound)
                    {
                        groupBy.startGroup.labelTextToken = labelTextToken;
                    }
                }

                if (expressionNodeFound)
                {
                    // we add only if we encountered one, since it's not mandatory
                    ExpressionToken expression = expressionMatch.GenerateExpressionToken();
                    if (expression == null)
                    {
                        return null; // fatal error
                    }
                    groupBy.startGroup.expression = expression;
                    return groupBy;
                }


                // failure: expression is mandatory
                //Error at XPath {0} in file {1}: An expression is expected.
                this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.ExpectExpression, ComputeCurrentXPath(), FilePath));
                return null;
            }
        }
Beispiel #8
0
        private TypeOrGroupReference LoadSelectionConditionNode(XmlNode selectionConditionNode)
        {
            using (this.StackFrame(selectionConditionNode))
            {
                TypeOrGroupReference retVal = null;

                bool expressionNodeFound = false;       // cardinality 1

                // these two nodes are mutually exclusive
                bool typeFound = false;              // cardinality 0..1
                bool typeGroupFound = false;              // cardinality 0..1

                ExpressionNodeMatch expressionMatch = new ExpressionNodeMatch(this);

                foreach (XmlNode n in selectionConditionNode.ChildNodes)
                {
                    if (MatchNodeName(n, XmlTags.SelectionSetNameNode))
                    {
                        if (typeGroupFound)
                        {
                            this.ProcessDuplicateAlternateNode(n, XmlTags.SelectionSetNameNode, XmlTags.TypeNameNode);
                            return null;
                        }
                        typeGroupFound = true;
                        TypeGroupReference tgr = LoadTypeGroupReference(n);
                        if (tgr != null)
                        {
                            retVal = tgr;
                        }
                        else
                        {
                            return null;
                        }
                    }
                    else if (MatchNodeName(n, XmlTags.TypeNameNode))
                    {
                        if (typeFound)
                        {
                            this.ProcessDuplicateAlternateNode(n, XmlTags.SelectionSetNameNode, XmlTags.TypeNameNode);
                            return null;
                        }
                        typeFound = true;
                        TypeReference tr = LoadTypeReference(n);
                        if (tr != null)
                        {
                            retVal = tr;
                        }
                        else
                        {
                            return null;
                        }
                    }
                    else if (expressionMatch.MatchNode(n))
                    {
                        if (expressionNodeFound)
                        {
                            this.ProcessDuplicateNode(n);
                            return null; // fatal error
                        }
                        expressionNodeFound = true;
                        if (!expressionMatch.ProcessNode(n))
                            return null; // fatal error
                    }
                    else
                    {
                        this.ProcessUnknownNode(n);
                    }
                }


                if (typeFound && typeGroupFound)
                {
                    //Error at XPath {0} in file {1}: Cannot have SelectionSetName and TypeName at the same time.
                    this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.SelectionSetNameAndTypeName, ComputeCurrentXPath(), FilePath));
                    return null; // fatal error
                }

                if (retVal == null)
                {
                    // missing mandatory node
                    this.ReportMissingNodes(new string[] { XmlTags.SelectionSetNameNode, XmlTags.TypeNameNode });
                    return null;
                }

                if (expressionNodeFound)
                {
                    // mandatory node
                    retVal.conditionToken = expressionMatch.GenerateExpressionToken();
                    if (retVal.conditionToken == null)
                    {
                        return null; // fatal error
                    }
                    return retVal;
                }
                // failure: expression is mandatory
                //Error at XPath {0} in file {1}: An expression is expected.
                this.ReportError(StringUtil.Format(FormatAndOutXmlLoadingStrings.ExpectExpression, ComputeCurrentXPath(), FilePath));
                return null;
            }
        }
        private bool LoadPropertyBaseHelper(XmlNode propertyBaseNode, PropertyTokenBase ptb, List <XmlNode> unprocessedNodes)
        {
            ExpressionNodeMatch expressionMatch = new ExpressionNodeMatch(this);

            bool expressionNodeFound             = false; // cardinality 0..1
            bool collectionNodeFound             = false; // cardinality 0..1
            bool itemSelectionConditionNodeFound = false; // cardinality 0..1

            ExpressionToken condition = null;

            foreach (XmlNode n in propertyBaseNode.ChildNodes)
            {
                if (expressionMatch.MatchNode(n))
                {
                    if (expressionNodeFound)
                    {
                        this.ProcessDuplicateNode(n);
                        return(false); // fatal error
                    }
                    expressionNodeFound = true;
                    if (!expressionMatch.ProcessNode(n))
                    {
                        return(false); // fatal error
                    }
                }
                else if (MatchNodeName(n, XmlTags.EnumerateCollectionNode))
                {
                    if (collectionNodeFound)
                    {
                        this.ProcessDuplicateNode(n);
                        return(false);
                    }

                    collectionNodeFound = true;
                    if (!ReadBooleanNode(n, out ptb.enumerateCollection))
                    {
                        return(false);
                    }
                }
                else if (MatchNodeName(n, XmlTags.ItemSelectionConditionNode))
                {
                    if (itemSelectionConditionNodeFound)
                    {
                        this.ProcessDuplicateNode(n);
                        return(false);
                    }
                    itemSelectionConditionNodeFound = true;
                    condition = LoadItemSelectionCondition(n);
                    if (condition == null)
                    {
                        return(false);
                    }
                }
                else
                {
                    if (!IsFilteredOutNode(n))
                    {
                        unprocessedNodes.Add(n);
                    }
                }
            } // foreach


            if (expressionNodeFound)
            {
                // we add only if we encountered one, since it's not mandatory
                ExpressionToken expression = expressionMatch.GenerateExpressionToken();
                if (expression == null)
                {
                    return(false); // fatal error
                }

                ptb.expression     = expression;
                ptb.conditionToken = condition;
            }

            return(true);
        }
        private ExpressionToken LoadItemSelectionCondition(XmlNode itemNode)
        {
            using (this.StackFrame(itemNode))
            {
                bool expressionNodeFound = false;     // cardinality 1

                ExpressionNodeMatch expressionMatch = new ExpressionNodeMatch(this);
                foreach (XmlNode n in itemNode.ChildNodes)
                {
                    if (expressionMatch.MatchNode(n))
                    {
                        if (expressionNodeFound)
                        {
                            this.ProcessDuplicateNode(n);
                            return null; // fatal error
                        }
                        expressionNodeFound = true;
                        if (!expressionMatch.ProcessNode(n))
                            return null;
                    }
                    else
                    {
                        this.ProcessUnknownNode(n);
                    }
                }

                return expressionMatch.GenerateExpressionToken();
            }
        }
        private bool LoadPropertyBaseHelper(XmlNode propertyBaseNode, PropertyTokenBase ptb, List<XmlNode> unprocessedNodes)
        {
            ExpressionNodeMatch expressionMatch = new ExpressionNodeMatch(this);

            bool expressionNodeFound = false;     // cardinality 0..1
            bool collectionNodeFound = false;       // cardinality 0..1
            bool itemSelectionConditionNodeFound = false; // cardinality 0..1

            ExpressionToken condition = null;

            foreach (XmlNode n in propertyBaseNode.ChildNodes)
            {
                if (expressionMatch.MatchNode(n))
                {
                    if (expressionNodeFound)
                    {
                        this.ProcessDuplicateNode(n);
                        return false; // fatal error
                    }
                    expressionNodeFound = true;
                    if (!expressionMatch.ProcessNode(n))
                        return false; // fatal error
                }
                else if (MatchNodeName(n, XmlTags.EnumerateCollectionNode))
                {
                    if (collectionNodeFound)
                    {
                        this.ProcessDuplicateNode(n);
                        return false;
                    }

                    collectionNodeFound = true;
                    if (!ReadBooleanNode(n, out ptb.enumerateCollection))
                        return false;
                }
                else if (MatchNodeName(n, XmlTags.ItemSelectionConditionNode))
                {
                    if (itemSelectionConditionNodeFound)
                    {
                        this.ProcessDuplicateNode(n);
                        return false;
                    }
                    itemSelectionConditionNodeFound = true;
                    condition = LoadItemSelectionCondition(n);
                    if (condition == null)
                    {
                        return false;
                    }
                }
                else
                {
                    if (!IsFilteredOutNode(n))
                        unprocessedNodes.Add(n);
                }
            } // foreach


            if (expressionNodeFound)
            {
                // we add only if we encountered one, since it's not mandatory
                ExpressionToken expression = expressionMatch.GenerateExpressionToken();
                if (expression == null)
                {
                    return false; // fatal error
                }

                ptb.expression = expression;
                ptb.conditionToken = condition;
            }

            return true;
        }