Ejemplo n.º 1
0
        public override ParseResult ContinuePopulate(byte a_byte)
        {
            try
            {
                switch (m_state)
                {
                case State.Done:
                    m_state = State.Failed;
                    return(ParseResult.Failed);

                case State.WaitForNextListElement:
                    var res = m_actElement.ContinuePopulate(a_byte);
                    switch (res)
                    {
                    case ParseResult.Failed:
                        m_elements = null;
                        m_state    = State.Failed;
                        return(ParseResult.Failed);

                    case ParseResult.Done:
                        m_elements[m_nbElementsRead] = m_actElement.EndPopulate();
                        m_nbElementsRead++;
                        if (m_tl.NbListElements == m_nbElementsRead)
                        {
                            m_state = State.Done;
                            return(ParseResult.Done);
                        }
                        m_actElement = new SmlTypeLengthField(m_encoding);
                        m_actElement.BeginPopulate();
                        return(ParseResult.MoreBytesNeeded);

                    default:
                        return(res);
                    }

                default:
                    return(ParseResult.Failed);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex);
                m_state = State.Failed;
                return(ParseResult.Failed);
            }
        }
Ejemplo n.º 2
0
        public override ParseResult ContinuePopulate(byte a_byte)
        {
            bool moreBytesNeeded;

            switch (m_state)
            {
            case State.WaitForFirstByte:
                moreBytesNeeded = (a_byte & 0x80) == 0x80;
                switch (a_byte & 0x70)
                {
                case 0x00:
                    if (((a_byte & 0x0F) == 0x01) && !moreBytesNeeded)
                    {
                        m_type = SmlFieldType.Optional;
                    }
                    else if (((a_byte & 0x0F) == 0x00) && !moreBytesNeeded)
                    {
                        m_type = SmlFieldType.EndOfMessage;
                    }
                    else
                    {
                        m_type = SmlFieldType.String;
                    }
                    break;

                case 0x40:
                    m_type = SmlFieldType.Boolean;
                    if (moreBytesNeeded || ((a_byte & 0x0F) != 0x02))
                    {
                        m_state = State.Failed;
                        return(ParseResult.Failed);
                    }
                    break;

                case 0x50:
                    if (moreBytesNeeded)
                    {
                        m_state = State.Failed;
                        return(ParseResult.Failed);
                    }
                    switch (a_byte & 0x0F)
                    {
                    case 0x02:
                        m_type = SmlFieldType.Signed8;
                        break;

                    case 0x03:
                        m_type = SmlFieldType.Signed16;
                        break;

                    case 0x05:
                        m_type = SmlFieldType.Signed32;
                        break;

                    case 0x09:
                        m_type = SmlFieldType.Signed64;
                        break;

                    default:
                        m_state = State.Failed;
                        return(ParseResult.Failed);
                    }
                    break;

                case 0x60:
                    if (moreBytesNeeded)
                    {
                        m_state = State.Failed;
                        return(ParseResult.Failed);
                    }
                    switch (a_byte & 0x0F)
                    {
                    case 0x02:
                        m_type = SmlFieldType.Unsigned8;
                        break;

                    case 0x03:
                        m_type = SmlFieldType.Unsigned16;
                        break;

                    case 0x05:
                        m_type = SmlFieldType.Unsigned32;
                        break;

                    case 0x09:
                        m_type = SmlFieldType.Unsigned64;
                        break;

                    default:
                        m_state = State.Failed;
                        return(ParseResult.Failed);
                    }
                    break;

                case 0x70:
                    m_type = SmlFieldType.List;
                    break;

                default:
                    m_state = State.Failed;
                    return(ParseResult.Failed);
                }
                m_nbTlBytes = 1;
                m_length    = (a_byte & 0x0F);

                if (moreBytesNeeded)
                {
                    m_state = State.WaitForNextByte;
                    return(ParseResult.MoreBytesNeeded);
                }
                return(CreateParseResult());

            case State.WaitForNextByte:
                moreBytesNeeded = (a_byte & 0x80) == 0x80;
                switch (a_byte & 0x70)
                {
                case 0x00:
                    m_nbTlBytes++;
                    m_length = (m_length << 4) | (a_byte & 0x0F);
                    if (moreBytesNeeded)
                    {
                        m_state = State.WaitForNextByte;
                        return(ParseResult.MoreBytesNeeded);
                    }
                    return(CreateParseResult());

                default:
                    m_state = State.Failed;
                    return(ParseResult.Failed);
                }

            case State.ForewardToResult:
                return(m_parseResult.ContinuePopulate(a_byte));

            default:
                m_state = State.Failed;
                return(ParseResult.Failed);
            }
        }