protected override bool CompareField(XElement field, Datagram datagram)
        {
            EthernetDatagram ethernetDatagram = (EthernetDatagram)datagram;
            switch (field.Name())
            {
                case "eth.dst":
                    CompareEthernetAddress(field, ethernetDatagram.Destination);
                    break;

                case "eth.src":
                    CompareEthernetAddress(field, ethernetDatagram.Source);
                    break;

                case "eth.type":
                    field.AssertShowHex((ushort)ethernetDatagram.EtherType);
                    break;

                case "eth.trailer":
                    if (ethernetDatagram.Trailer != null)
                        field.AssertValue(ethernetDatagram.Trailer);
                    break;

                case "":
                    if (ethernetDatagram.Trailer != null)
                        field.AssertValue(ethernetDatagram.FrameCheckSequence);
                    break;

                default:
                    throw new InvalidOperationException("Invalid etherent field " + field.Name());
            }

            return true;
        }
        protected override bool CompareField(XElement field, Datagram parentDatagram, Datagram datagram)
        {
            IpDatagram ipDatagram = (IpDatagram)parentDatagram;
            UdpDatagram udpDatagram = (UdpDatagram)datagram;

            switch (field.Name())
            {
                case "udp.srcport":
                    field.AssertShowDecimal(udpDatagram.SourcePort);
                    break;

                case "udp.dstport":
                    field.AssertShowDecimal(udpDatagram.DestinationPort);
                    break;

                case "udp.port":
                    Assert.IsTrue(ushort.Parse(field.Show()) == udpDatagram.SourcePort ||
                                  ushort.Parse(field.Show()) == udpDatagram.DestinationPort);
                    break;

                case "udp.length":
                    field.AssertShowDecimal(udpDatagram.TotalLength);
                    break;

                case "udp.checksum":
                    field.AssertShowDecimal(udpDatagram.Checksum);
                    if (udpDatagram.Checksum != 0)
                    {
                        foreach (var checksumField in field.Fields())
                        {
                            switch (checksumField.Name())
                            {
                                case "udp.checksum_good":
                                    checksumField.AssertShowDecimal(ipDatagram.IsTransportChecksumCorrect);
                                    break;

                                case "udp.checksum_bad":
                                    if (checksumField.Show() == "1")
                                        Assert.IsFalse(ipDatagram.IsTransportChecksumCorrect);
                                    else
                                        checksumField.AssertShowDecimal(0);
                                    break;
                            }
                        }
                    }
                    break;

                case "udp.checksum_coverage":
                    field.AssertShowDecimal(udpDatagram.TotalLength);
                    break;

                case "udp.stream":
                    break;

                default:
                    throw new InvalidOperationException("Invalid udp field " + field.Name());
            }

            return true;
        }
        protected override bool CompareField(XElement field, Datagram datagram)
        {
            IpV6Datagram ipV6Datagram = datagram as IpV6Datagram;
            if (ipV6Datagram == null)
                return true;
            while (_count > 0)
            {
                do
                {
                    ++_currentExtensionHeaderIndex;
                    if (_currentExtensionHeaderIndex >= ipV6Datagram.ExtensionHeaders.Headers.Count)
                    {
                        Assert.IsFalse(ipV6Datagram.ExtensionHeaders.IsValid);
                        return false;
                    }
                } while (ipV6Datagram.ExtensionHeaders[_currentExtensionHeaderIndex].Protocol != IpV4Protocol.AuthenticationHeader);
                --_count;
            }
            IpV6ExtensionHeaderAuthentication authenticationHeader = (IpV6ExtensionHeaderAuthentication)ipV6Datagram.ExtensionHeaders[_currentExtensionHeaderIndex];

            switch (field.Name())
            {
                case "":
                    string[] headerFieldShowParts = field.Show().Split(':');
                    string headerFieldShowName = headerFieldShowParts[0];
                    string headerFieldShowValue = headerFieldShowParts[1];
                    switch (headerFieldShowName)
                    {
                        case "Next Header":
                            field.AssertValue((byte)authenticationHeader.NextHeader.Value);
                            break;

                        case "Length":
                            Assert.AreEqual(string.Format(" {0}", authenticationHeader.Length), headerFieldShowValue);
                            break;

                        default:
                            throw new InvalidOperationException("Invalid ipv6 authentication header unnamed field show name " + headerFieldShowName);
                    }
                    break;

                case "ah.spi":
                    field.AssertShowDecimal(authenticationHeader.SecurityParametersIndex);
                    break;

                case "ah.sequence":
                    field.AssertShowDecimal(authenticationHeader.SequenceNumber);
                    break;

                case "ah.icv":
                    field.AssertValue(authenticationHeader.AuthenticationData);
                    break;

                default:
                    throw new InvalidOperationException(string.Format("Invalid ipv6 authentication header field {0}", field.Name()));
            }

            return true;
        }
 public static UnifiedSet<UnifiedArgument> CreateArglist(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "arglist");
     /*
      * arglist: (argument ',')* (argument [',']
      *							  |'*' test (',' argument)* [',' '**' test]
      *							  |'**' test)
      */
     return node.Elements()
             .Where(
                     e =>
                     e.Name() == "argument"
                     || e.Name() == "test")
             .Select(
                     e => e.Name() == "argument"
                                  ? CreateArgument(e)
                                  : UnifiedArgument.Create(
                                          CreateTest(e), null,
                                          UnifiedModifier.Create(
                                                  e.PreviousElement().
                                                          Value).
                                                  ToSet()))
             .ToSet();
 }
        public static UnifiedExpression CreateIterationStatement(XElement node)
        {
            Contract.Requires(node != null);
            Contract.Requires(node.Name() == "iteration_statement");
            /*
            iteration_statement
            : 'while' '(' expression ')' statement
            | 'do' statement 'while' '(' expression ')' ';'
            | 'for' '(' expression_statement expression_statement expression? ')' statement
             */

            var first = node.FirstElement().Value;
            var body =
                    UnifiedBlock.Create(
                            CreateStatement(node.FirstElement("statement")));
            switch (first) {
            case "while":
                return UnifiedWhile.Create(CreateExpression(node.NthElement(2)), body);
            case "do":
                return UnifiedDoWhile.Create(CreateExpression(node.NthElement(4)), body);
            case "for":
                var step = node.Element("expression");
                var stepExp = step != null ? CreateExpression(step) : null;
                return UnifiedFor.Create(
                        CreateExpressionStatement(node.NthElement(2)),
                        CreateExpressionStatement(node.NthElement(3)),
                        stepExp, body);
            default:
                throw new InvalidOperationException();
            }
        }
 public static UnifiedExpression CreateFloat(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "Float");
     return UnifiedFractionLiteral.Create(
             double.Parse(node.Value),
             UnifiedFractionLiteralKind.Double);
 }
 public static UnifiedSet<UnifiedArgument> CreateArglist(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "arglist");
     return node.Elements()
             .Select(e => CreateExpresion(e).ToArgument())
             .ToSet();
 }
 public static UnifiedBlock CreateBlock(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "block");
     return node.Elements()
             .Select(CreateExpresion)
             .ToBlock();
 }
 public static UnifiedExpression CreateAlias(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "alias");
     return UnifiedAlias.Create(
             CreateExpresion(node.FirstElement()),
             CreateExpresion(node.LastElement()));
 }
 public static UnifiedExpression CreateBignum(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "Bignum");
     return
             UnifiedInt32Literal.Create(
                     LiteralFuzzyParser.ParseBigInteger(node.Value));
 }
 public static UnifiedExpression CreateFixnum(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "Fixnum");
     return
             UnifiedInt32Literal.Create(
                     NumberParser.ParseInt32(node.Value));
 }
 public static UnifiedIf CreateIf(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "if");
     return UnifiedIf.Create(
             CreateExpresion(node.NthElement(0)),
             CreateBlock(node.NthElement(1)),
             CreateBlock(node.NthElement(2)));
 }
 public static UnifiedClassDefinition CreateModule(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "module");
     return UnifiedClassDefinition.Create(
             null, null, CreateSymbol(node.NthElement(0)), null,
             null,
             CreateScope(node.NthElement(1)));
 }
 public static UnifiedElement CreateBlock(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "block");
     /*
      * block : chunk;
      */
     throw new NotImplementedException(); //TODO: implement
 }
 public static UnifiedElement CreateBinop(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "binop");
     /*
      * binop : '+' | '-' | '*' | '/' | '^' | '%' | '..' |
      */
     throw new NotImplementedException(); //TODO: implement
 }
 public static UnifiedElement CreateArgs(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "args");
     /*
      * args :  '(' (explist1)? ')' | tableconstructor | lua_string ;
      */
     throw new NotImplementedException(); //TODO: implement
 }
 public static UnifiedExpression CreateDefn(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "defn");
     return UnifiedFunctionDefinition.Create(
             null, null, null, null,
             CreateSymbol(node.NthElement(0)),
             CreateArgs(node.NthElement(1)), null,
             CreateScope(node.NthElement(2)));
 }
 public static UnifiedIntegerLiteral CreateDecimalLiteral(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "DECIMAL_LITERAL");
     /*
      * DECIMAL_LITERAL : ('0' | '1'..'9' '0'..'9'*) IntegerTypeSuffix? ;
      */
     var result = NumberParser.ParseBigInteger(node.Value);
     return CreateIntegerLiteral(node, result);
 }
 // literals
 public static UnifiedIntegerLiteral CreateHexLiteral(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "HEX_LITERAL");
     /*
      * HEX_LITERAL : '0' ('x'|'X') HexDigit+ IntegerTypeSuffix? ;
      */
     var result = NumberParser.ParseHexicalBigInteger(node.Value.Substring(2));
     return CreateIntegerLiteral(node, result);
 }
 public static UnifiedLiteral CreateCharacterLiteral(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "CHARACTER_LITERAL");
     /*
      * CHARACTER_LITERAL
      * :   '\'' ( EscapeSequence | ~('\''|'\\') ) '\'' ;
      */
     return UnifiedCharLiteral.Create(node.Value);
 }
 public static UnifiedExpression CreateAnd_test(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "and_test");
     /*
      * and_test: not_test ('and' not_test)*
      */
     return UnifiedProgramGeneratorHelper.CreateBinaryExpression(
             node, CreateNot_test, Sign2BinaryOperator);
 }
 public static UnifiedExpression CreateAnd_expr(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "and_expr");
     /*
      * and_expr: shift_expr ('&' shift_expr)*
      */
     return UnifiedProgramGeneratorHelper.CreateBinaryExpression(
             node, CreateShift_expr, Sign2BinaryOperator);
 }
 public static UnifiedExpression CreateAndExpression(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "and_expression");
     /*
     and_expression
     : equality_expression ('&' equality_expression)*
      */
     return UnifiedProgramGeneratorHelper.CreateBinaryExpression(
             node, CreateEqualityExpression, Sign2BinaryOperator);
 }
 public static UnifiedEigenClassDefinition CreateSclass(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "sclass");
     return UnifiedEigenClassDefinition.Create(
             null, null, null, null,
             UnifiedEigenConstrain.Create(
                     CreateExpresion(node.NthElement(0))).
                     ToSet<UnifiedTypeConstrain>(),
             CreateScope(node.NthElement(1)));
 }
 public static UnifiedExpression CreateCase(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "case");
     return UnifiedSwitch.Create(
             CreateExpresion(node.NthElement(0)),
             node.Elements().Skip(1)
                     .SelectMany(CreateWhenAndDefault)
                     .ToSet()
             );
 }
 public static UnifiedExpression CreateLit(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "lit");
     var child = node.FirstElement();
     switch (child.Name()) {
     case "Symbol":
         return UnifiedSymbolLiteral.Create(child.Value);
     }
     return CreateExpresion(child);
 }
 public static UnifiedExpression CreateAdditiveExpression(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "additiveExpression");
     /*
      * additiveExpression
      *		: multiplicativeExpression (LT!* ('+' | '-') LT!* multiplicativeExpression)*
      */
     return UnifiedProgramGeneratorHelper.CreateBinaryExpression(
             node, CreateMultiplicativeExpression, Sign2BinaryOperator);
 }
        protected override bool CompareField(XElement field, Datagram datagram)
        {
            EthernetDatagram ethernetDatagram = (EthernetDatagram)datagram;
            switch (field.Name())
            {
                case "eth.dst":
                    CompareEthernetAddress(field, ethernetDatagram.Destination);
                    break;

                case "eth.src":
                    CompareEthernetAddress(field, ethernetDatagram.Source);
                    break;

                case "eth.type":
                    field.AssertNoFields();
                    field.AssertShowDecimal((ushort)ethernetDatagram.EtherType);
                    break;

                case "eth.trailer":
                    // TODO: Support RARP.
                    if (ethernetDatagram.EtherType != EthernetType.ReverseArp)
                        field.AssertValue(ethernetDatagram.Trailer);
                    break;

                case "eth.fcs":
                    // TODO: Support RARP.
                    if (ethernetDatagram.EtherType != EthernetType.ReverseArp)
                        field.AssertValue(ethernetDatagram.FrameCheckSequence);
                    break;

                case "eth.padding":
                    field.AssertNoFields();
                    field.AssertValue(ethernetDatagram.Padding);
                    break;

                default:
                    throw new InvalidOperationException("Invalid etherent field " + field.Name());
            }

            return true;
        }
 private static UnifiedExpression CreateDefs(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "defs");
     var owner = CreateExpresion(node.NthElement(0));
     var target = UnifiedFunctionDefinition.Create(
             null, null, null, null,
             CreateSymbol(node.NthElement(1)),
             CreateArgs(node.NthElement(2)), null,
             CreateScope(node.NthElement(3)));
     return UnifiedProperty.Create(".", owner, target);
 }
 public static UnifiedExpression CreateFor(XElement node)
 {
     Contract.Requires(node != null);
     Contract.Requires(node.Name() == "for");
     Contract.Assert(
             node.NthElement(1).Name() == "lasgn"
             || node.NthElement(1).Name() == "masgn");
     return UnifiedForeach.Create(
             CreateExpresion(node.NthElement(0)),
             CreateExpresion(node.NthElement(1).FirstElement()),
             CreateBlock(node.NthElement(2)));
 }