public void NegateFailParse()
        {
            IScanner        scanner = Provider.Scanner;
            NegatableParser parser  = -Prims.CharOf(MatchedChar);

            ParserMatch m = parser.Parse(scanner);

            Assert.IsTrue(!m.Success);
            Assert.AreEqual(scanner.Offset, 0);
        }
Example #2
0
        public void NegateFailParse()
        {
            IScanner        scanner = Provider.NewScanner;
            NegatableParser parser  = ~Prims.Ch(MatchedChar);

            ParserMatch m = parser.Parse(scanner);

            Assert.IsFalse(m.Success);
            Assert.AreEqual(scanner.Offset, 0);
        }
        public void NegateSuccessParse()
        {
            IScanner        scanner = Provider.Scanner;
            NegatableParser parser  = -Prims.CharOf(NonMatchedChar);

            ParserMatch m = parser.Parse(scanner);

            Assert.IsTrue(m.Success);
            Assert.AreEqual(m.Offset, 0);
            Assert.AreEqual(m.Length, 1);
            Assert.AreEqual(scanner.Offset, 1);
        }
Example #4
0
        public AttributeParser()
        {
            // Basic symbolic parameters
            Parser name = Ops.Seq(Prims.Letter | '_', Ops.Star(Prims.LetterOrDigit | '_'));

            m_NameRule   = new Rule(name);
            m_SymbolRule = new Rule(name);

            // Integer and floating point parameters
            Parser natural = Ops.Plus(Prims.Digit);
            Parser integer = Ops.Seq(Ops.Optional('-'), natural);
            Parser scalar  = Ops.Seq(Ops.Optional('-'), Ops.Star(Prims.Digit), '.', natural, Ops.Optional(Ops.Seq('e', integer)));

            m_IntegerRule = new Rule(integer);
            m_ScalarRule  = new Rule(scalar);

            // String parameters
            Parser          quotes_esc = Ops.Seq('\\', '\"');
            NegatableParser quotes     = Prims.Ch('\"');
            Parser          text       = Ops.Seq('\"', Ops.Star(quotes_esc | ~quotes), '\"');

            m_TextRule = new Rule(text);

            // Definition of an attribute
            Parser whitespace = Ops.Star(Prims.WhiteSpace);
            Parser assign     = Ops.Seq(whitespace, '=', whitespace, m_SymbolRule | m_ScalarRule | m_IntegerRule | m_TextRule);

            m_AttributeRule = new Rule(Ops.Seq(m_NameRule, Ops.Optional(assign)));

            // The final definition of a list of attributes
            m_AttributesParser = Ops.Seq(whitespace, m_AttributeRule, Ops.Star(Ops.Seq(whitespace, ',', whitespace, m_AttributeRule)));

            // Setup event handlers for reading the parse results
            m_NameRule.Act    += OnName;
            m_SymbolRule.Act  += OnSymbol;
            m_IntegerRule.Act += OnInteger;
            m_ScalarRule.Act  += OnScalar;
            m_TextRule.Act    += OnText;
        }