示例#1
0
        /// <summary>
        /// Формирование значения переменной для отображения
        /// </summary>
        /// <param name="address"></param>
        /// <returns></returns>
        private string BuildDisplayValue(byte[] buffer, int size, bool hasSign)
        {
            if (buffer == null || size == 0)
            {
                return("Ошибка");
            }

            byte[] Buffer = buffer;
            long   Value  = 0;

            if (_engine.Parameters.InverseByteOrder)
            {
                Array.Reverse(Buffer);
            }
            Value = AppliedMath.BytesToLong(Buffer);
            //Определение типа переменной
            if (hasSign)
            {
                switch (size)
                {
                case 1: Value = (sbyte)Value; break;

                case 2: Value = (Int16)Value; break;

                case 4: Value = (Int32)Value; break;
                }
            }
            else
            {
                switch (size)
                {
                case 1: Value = (Byte)Value; break;

                case 2: Value = (UInt16)Value; break;

                case 4: Value = (UInt32)Value; break;
                }
            }
            //Формирвание прочитанного значения
            String m_StrVar = this._EditCellText;

            switch (codingType)
            {
            case 16:
                String m_Str = Convert.ToString(Value, codingType);
                if (m_Str.Length > size * 2)
                {
                    int m_CutIndex = m_Str.Length - size * 2;
                    m_Str = m_Str.Substring(m_CutIndex);
                }
                m_Str    = "0x" + Utils.AddChars('0', m_Str, 8 /*(int)m_row.ItemArray[4] * 2*/);
                m_StrVar = m_Str.ToUpper();
                break;

            default:
                m_StrVar = Convert.ToString(Value, codingType).ToUpper();
                break;
            }
            return(m_StrVar.Replace('X', 'x'));
        }
示例#2
0
        /// <summary>
        /// Для заданной переменной преобразует ее значение из массива байт в целое число
        /// </summary>
        private long GetVarValue(DebuggerParameters.VarDescription var, byte[] data)
        {
            if (this.debuggerEngine.Parameters.InverseByteOrder)
            {
                data = Utils.ReflectArray <byte>(data);
            }
            long res = AppliedMath.BytesToLong(data);

            switch (var.Size)
            {
            case 1:
                if (var.HasSign)
                {
                    res = (sbyte)res;
                }
                else
                {
                    res = (byte)res;
                }
                break;

            case 2:
                if (var.HasSign)
                {
                    res = (short)res;
                }
                else
                {
                    res = (ushort)res;
                }
                break;

            case 4:
                if (var.HasSign)
                {
                    res = (int)res;
                }
                else
                {
                    res = (uint)res;
                }
                break;
            }
            return(res);
        }
示例#3
0
        /// <summary>
        /// Построение прочитанног значения в зависимости от кодировки
        /// </summary>
        /// <param name="row"></param>
        private void BuildDisplayValue(DataRow row)
        {
            DataRow m_row = row;

            byte[] Buffer = (byte[])m_row.ItemArray[8];

            bool real = (bool)row.ItemArray[9];
            int  size = (int)row.ItemArray[4];

            long   Value  = 0;
            double dValue = 0;

            if (_engine.Parameters.InverseByteOrder && !real)
            {
                Array.Reverse(Buffer);
            }

            if (real)
            {
                if (size == 8)
                {
                    dValue = BitConverter.ToDouble(Buffer, 0);
                }
                else
                {
                    dValue = (double)BitConverter.ToSingle(Buffer, 0);
                }
            }
            else
            {
                Value = AppliedMath.BytesToLong(Buffer);


                if (_vars[m_row.ItemArray[0].ToString()].HasSign)
                {
                    switch ((int)m_row.ItemArray[4])
                    {
                    case 1: Value = (sbyte)Value; break;

                    case 2: Value = (Int16)Value; break;

                    case 4: Value = (Int32)Value; break;
                    }
                }
                else
                {
                    switch ((int)m_row.ItemArray[4])
                    {
                    case 1: Value = (Byte)Value; break;

                    case 2: Value = (UInt16)Value; break;

                    case 4: Value = (UInt32)Value; break;
                    }
                }
            }

            //Добавление прочитанного значения
            String m_StrVar = this._EditCellText;
            String varName  = m_row.ItemArray[0].ToString();
            bool   array    = false;

            array = _vars[varName] is ControllerUserVar && ((ControllerUserVar)_vars[varName]).Array;

            if (!array)
            {
                array = _vars[varName] is ControllerSystemVar && ((ControllerSystemVar)_vars[varName]).Array;
            }

            if (array)
            {//обработка значения если это массив
                switch (codingType)
                {
                case 16:
                    String m_Str  = "";
                    String m_Byte = "";
                    foreach (Byte m_byte in Buffer)
                    {
                        m_Byte = Convert.ToString(m_byte, codingType);
                        switch (m_Byte.Length)
                        {
                        case 0: m_Byte = "00" + m_Byte; break;

                        case 1: m_Byte = "0" + m_Byte; break;

                        default: break;
                        }
                        m_Str += m_Byte + " ";
                    }
                    m_StrVar = m_Str.ToUpper();
                    break;

                default:
                    String m_Str1 = "";
                    foreach (Byte m_byte in Buffer)
                    {
                        m_Str1 += Convert.ToString(m_byte, codingType) + " ";
                    }
                    m_StrVar = m_Str1.ToUpper();
                    break;
                }
            }
            else
            {
                switch (codingType)
                {
                case 16:
                    String m_Str = Convert.ToString(Value, codingType);
                    if (m_Str.Length > (int)m_row.ItemArray[4] * 2)
                    {
                        int m_CutIndex = m_Str.Length - (int)m_row.ItemArray[4] * 2;
                        m_Str = m_Str.Substring(m_CutIndex);
                    }
                    m_Str    = "0x" + Utils.AddChars('0', m_Str, 8 /*(int)m_row.ItemArray[4] * 2*/);
                    m_StrVar = m_Str.ToUpper();
                    break;

                default:
                    if (real)
                    {
                        m_StrVar = dValue.ToString("F2");
                    }
                    else
                    {
                        m_StrVar = Convert.ToString(Value, codingType).ToUpper();
                    }
                    break;
                }
            }
            m_row[1] = m_StrVar.Replace('X', 'x');
        }