Esempio n. 1
0
static PyObject *
Q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
{
    unsigned PY_LONG_LONG val;
    unsigned PY_LONG_LONG field;
    if (get_ulonglong(value, &val) < 0)
        return NULL;
    memcpy(&field, ptr, sizeof(field));
    field = SWAP_8(field);
    field = (unsigned PY_LONG_LONG)SET(field, val, size);
    field = SWAP_8(field);
    memcpy(ptr, &field, sizeof(field));
    _RET(value);
}
Esempio n. 2
0
static PyObject *
q_set_sw(void *ptr, PyObject *value, Py_ssize_t size)
{
    PY_LONG_LONG val;
    PY_LONG_LONG field;
    if (get_longlong(value, &val) < 0)
        return NULL;
    memcpy(&field, ptr, sizeof(field));
    field = SWAP_8(field);
    field = SET(PY_LONG_LONG, field, val, size);
    field = SWAP_8(field);
    memcpy(ptr, &field, sizeof(field));
    _RET(value);
}
Esempio n. 3
0
static PyObject *
Q_get_sw(void *ptr, Py_ssize_t size)
{
    unsigned PY_LONG_LONG val;
    memcpy(&val, ptr, sizeof(val));
    val = SWAP_8(val);
    GET_BITFIELD(val, size);
    return PyLong_FromUnsignedLongLong(val);
}
Esempio n. 4
0
static void
sSwapDYN (
  register MQ_BIN ist
)
{
  MQ_INT numItems = 0, len = 0;
  MQ_BINB type;

  // BDY_NumItems_S
  SWAP_4 (ist);
  memcpy(&numItems, ist, sizeof(MQ_INT));

  // for all Element's
  ist += (HDR_INT_LEN + 1);
  while (numItems) {

    // type
    type = *ist;
    ist += 2;

    // len
    len = (type & MQ_TYPE_IS_NATIVE);
    if (len == 0) {
      SWAP_4 (ist);
      memcpy(&len, ist, sizeof(MQ_INT));
      ist += (HDR_INT_LEN + 1);
    }

    // val
    switch ((enum MqTypeE)type) {
      case MQ_SRTT: SWAP_2  (ist);  break;
      case MQ_INTT: SWAP_4  (ist);  break;
      case MQ_FLTT: SWAP_4  (ist);  break;
      case MQ_WIDT: SWAP_8  (ist);  break;
      case MQ_DBLT: SWAP_8  (ist);  break;
      case MQ_STRT: case MQ_BINT: case MQ_BYTT: case MQ_BOLT: case MQ_TRAT: break;
      case MQ_LSTT: sSwapDYN (ist); break;
    }
    ist += (len + 1);
    numItems--;
  }
}
Esempio n. 5
0
static void testSwap_8(void)
{
    volatile unsigned int t=TEST_VECT_16;
    unsigned int tt;
    WORD x;

    tt = t;
    tt = SWAP_8(tt);
    ASSERT( tt == SWAP_8(TEST_VECT_16));

    x.i = t;
    x.i = SWAP_8(x.i);
    ASSERT( x.i == SWAP_8(TEST_VECT_16));

#if defined (SDCC_mcs51)
    /* this was filed as bug #1638622 (rejected) */
    x.i = t;
    x.i = x.c[1] + 256*x.c[0];
    ASSERT( x.i == SWAP_8(TEST_VECT_16));

    /* and with OR instead of ADD */
    x.i = t;
    x.i = x.c[1] | 256*x.c[0];
    ASSERT( x.i == SWAP_8(TEST_VECT_16));

    /* swapping union with little register pressure */
    {
        unsigned char tmp;
        x.i = t;

        tmp = x.c[0];
        x.c[0]=x.c[1];
        x.c[1]=tmp;

        ASSERT( x.i == SWAP_8(TEST_VECT_16));
    }
#endif
}