Example #1
0
        protected override ParsingResult InternalInternalMatch(
            Position position,
            IMemo memo)
        {
            var pos = position;

            for (int i = 0; i < Value.Length; i++)
            {
                if (pos.EOF)
                {
                    return(new ParsingError(
                               $"Expected \"{Value}\", got EOF",
                               pos,
                               this));
                }
                var exp = Value[i];
                var rec = pos.String[pos.Index];
                if (exp != rec)
                {
                    return(new ParsingError(
                               $"Expected \"{Value}\", got '{rec}' instead of '{exp}'",
                               pos,
                               this));
                }
                pos = pos.Advance();
            }
            return(new ParseNode(this, position, pos));
        }
Example #2
0
 public bool Equals(IMemo other)
 {
     if (other == null)
     {
         return(false);
     }
     return(InstanceID == other.InstanceID);
 }
Example #3
0
 public bool Equals(IMemo other)
 {
     if(other == null)
     {
         return false;
     }
     return InstanceID == other.InstanceID;
 }
Example #4
0
 protected override void WriteEventProviderClientMessage(IMemo memo)
 {
     if (WriteEventProviderMemos == null)
     {
         WriteEventProviderMemos = new List <IMemo>();
     }
     WriteEventProviderMemos.Add(memo);
 }
Example #5
0
        /*
         * Some notes on the ParseNode creation.
         *
         * Our current pattern can be
         * a) Named
         * b) not Named
         * Inner pattern can return the following nodes:
         * 1) Named with no children
         * 2) Named with children
         * 3) not Named with no children
         * 4) not Named with children
         *
         * We can say that it makes no sense to have a node with children, unless the children are named
         *
         * Therefore a pattern will have only children that are named. We flatten the nodes that are nameless.
         */
        protected override ParsingResult InternalMatch(
            Position position,
            IMemo memo)
        {
            var nodes       = new List <ParseNode>();
            var totalLength = 0;
            var pos         = position;

            for (int i = 0; i < Maximum; i++)
            {
                var result = Pattern.Match(pos, memo);
                var node   = result as ParseNode;

                if (node != null)
                {
                    if (node.Name != null)
                    {
                        nodes.Add(node);
                    }
                    else
                    {
                        //if there are no children, we add nothing at all
                        nodes.AddRange(node.Children.Where(n => n.Name != null));
                    }
                    totalLength += node.Length;
                    pos          = node.NextPosition;
                }
                else
                {
                    if (i >= Minimum)
                    {
                        break;
                    }
                    else
                    {
                        return(new ParsingError(
                                   $"Found only {i} repetitions instead of {Minimum}",
                                   pos,
                                   this));
                    }
                }
            }
            if (nodes.Count > 0)
            {
                if (!Named && nodes.Count == 1)
                {
                    return(nodes[0]);
                }
                else
                {
                    return(new ParseNode(this, nodes));
                }
            }
            else
            {
                return(new ParseNode(this, position, pos));
            }
        }
Example #6
0
        internal ParsingResult Match(Position position, IMemo memo)
        {
            ParsingResult result;

            if (memo.TryGetValue(Tuple.Create(this, position), out result))
            {
                return(result);
            }

            return(InternalMatch(position, memo));
        }
Example #7
0
 protected override sealed ParsingResult InternalMatch(Position position, IMemo memo)
 {
     if (position.EOF)
     {
         return(new ParsingError("EOF reached", position, this));
     }
     else
     {
         return(InternalInternalMatch(position, memo));
     }
 }
Example #8
0
        protected override ParsingResult InternalMatch(
            Position position,
            IMemo memo)
        {
            var nodes       = new List <ParseNode>();
            var pos         = position;
            var lastPattern = default(Pattern);
            var lastNode    = default(ParseNode);

            foreach (var pattern in Patterns)
            {
                var result = pattern.Match(pos, memo);
                var node   = result as ParseNode;

                if (node != null)
                {
                    if (node.Name != null)
                    {
                        nodes.Add(node);
                    }
                    else
                    {
                        //if there are no children, we add nothing at all
                        nodes.AddRange(node.Children.Where(n => n.Name != null));
                    }
                    pos = node.NextPosition;
                }
                else
                {
                    return(result); //TODO: nested errors
                }
            }
            if (nodes.Count > 0)
            {
                if (!Named && nodes.Count == 1)
                {
                    return(nodes[0]);
                }
                else
                {
                    return(new ParseNode(this, nodes));
                }
            }
            else
            {
                return(new ParseNode(this, position, pos));
            }
        }
Example #9
0
        protected override ParsingResult InternalInternalMatch(Position position, IMemo memo)
        {
            var c   = position.String[position.Index];
            var cat = char.GetUnicodeCategory(c);

            if (cat == Category)
            {
                return(new ParseNode(this, position, position.Advance()));
            }
            else
            {
                return(new ParsingError(
                           $"Expected {Category}, got {cat}",
                           position,
                           this));
            }
        }
Example #10
0
        protected override ParsingResult InternalMatch(
            Position position,
            IMemo memo)
        {
            var result = Pattern.Match(position, memo) as ParseNode;

            if (result != null)
            {
                return(new ParsingError(
                           $"Successfully matched antipattern",
                           position,
                           this));
            }
            else
            {
                return(new ParseNode(this, position, position));
            }
        }
Example #11
0
        protected override ParsingResult InternalMatch(
            Position position,
            IMemo memo)
        {
            var result = Pattern.Match(position, memo) as ParseNode;

            if (result != null)
            {
                return(new ParseNode(this, position, position));
            }
            else
            {
                return(new ParsingError(
                           $"Couldn't match pattern {Pattern}",
                           position,
                           this));
            }
        }
Example #12
0
        protected override ParsingResult InternalInternalMatch(
            Position position,
            IMemo memo)
        {
            var c = position.String[position.Index];

            if (Low <= c && c <= High)
            {
                return(new ParseNode(this, position, position.Advance()));
            }
            else
            {
                return(new ParsingError(
                           $"Character '{c}' not in set {this}",
                           position,
                           this));
            }
        }
Example #13
0
        protected override ParsingResult InternalMatch(
            Position position,
            IMemo memo)
        {
            foreach (var pattern in Patterns)
            {
                var result = pattern.Match(position, memo);
                var node   = result as ParseNode;

                if (node != null)
                {
                    return(node);
                }
            }

            return(new ParsingError(
                       "Failed to match any patern",
                       position,
                       this));
        }
Example #14
0
 protected virtual void WriteEventProviderClientMessage(IMemo memo)
 {
     SendMemo(memo as Memo);
 }
Example #15
0
 protected override void WriteEventProviderClientMessage(IMemo memo)
 {
     if (WriteEventProviderMemos == null)
     {
         WriteEventProviderMemos = new List<IMemo>();
     }
     WriteEventProviderMemos.Add(memo);
 }
Example #16
0
 protected override ParsingResult InternalInternalMatch(
     Position position,
     IMemo memo)
 {
     return(new ParseNode(this, position, position.Advance()));
 }
Example #17
0
 protected abstract ParsingResult InternalInternalMatch(Position position, IMemo memo);
Example #18
0
 protected override ParsingResult InternalMatch(
     Position position,
     IMemo memo)
 {
     return(Pattern.Match(position, memo));
 }