objint_longlong.c 3.81 KB
Newer Older
1
2
3
4
5
6
7
8
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <assert.h>

#include "nlr.h"
#include "misc.h"
#include "mpconfig.h"
9
#include "qstr.h"
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#include "obj.h"
#include "objint.h"
#include "runtime0.h"

#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG

static mp_obj_t mp_obj_new_int_from_ll(long long val);

// Python3 no longer has "l" suffix for long ints. We allow to use it
// for debugging purpose though.
#ifdef DEBUG
#define SUFFIX "l"
#else
#define SUFFIX ""
#endif

void int_print(void (*print)(void *env, const char *fmt, ...), void *env, mp_obj_t self_in, mp_print_kind_t kind) {
    mp_obj_int_t *self = self_in;
    print(env, "%lld" SUFFIX, self->val);
}

mp_obj_t int_binary_op(int op, mp_obj_t lhs_in, mp_obj_t rhs_in) {
    mp_obj_int_t *lhs = lhs_in;
    mp_obj_int_t *rhs = rhs_in;
    long long rhs_val;

    if (MP_OBJ_IS_SMALL_INT(rhs)) {
        rhs_val = MP_OBJ_SMALL_INT_VALUE(rhs);
    } else if (MP_OBJ_IS_TYPE(rhs, &int_type)) {
        rhs_val = rhs->val;
    } else {
        return MP_OBJ_NULL;
    }

    switch (op) {
        case RT_BINARY_OP_ADD:
            return mp_obj_new_int_from_ll(lhs->val + rhs_val);
        case RT_BINARY_OP_SUBTRACT:
            return mp_obj_new_int_from_ll(lhs->val - rhs_val);

        case RT_BINARY_OP_INPLACE_ADD:
            lhs->val += rhs_val;
            return lhs;
        case RT_BINARY_OP_INPLACE_SUBTRACT:
            lhs->val -= rhs_val;
            return lhs;

        case RT_BINARY_OP_AND:
            return mp_obj_new_int_from_ll(lhs->val & rhs_val);
        case RT_BINARY_OP_OR:
            return mp_obj_new_int_from_ll(lhs->val | rhs_val);
        case RT_BINARY_OP_XOR:
            return mp_obj_new_int_from_ll(lhs->val ^ rhs_val);

        case RT_BINARY_OP_LSHIFT:
            return mp_obj_new_int_from_ll(lhs->val << (int)rhs_val);
        case RT_BINARY_OP_RSHIFT:
            return mp_obj_new_int_from_ll(lhs->val >> (int)rhs_val);

        case RT_COMPARE_OP_LESS:
            return MP_BOOL(lhs->val < rhs_val);
        case RT_COMPARE_OP_MORE:
            return MP_BOOL(lhs->val > rhs_val);
        case RT_COMPARE_OP_LESS_EQUAL:
            return MP_BOOL(lhs->val <= rhs_val);
        case RT_COMPARE_OP_MORE_EQUAL:
            return MP_BOOL(lhs->val >= rhs_val);
        case RT_COMPARE_OP_EQUAL:
            return MP_BOOL(lhs->val == rhs_val);
        case RT_COMPARE_OP_NOT_EQUAL:
            return MP_BOOL(lhs->val != rhs_val);

        default:
            // op not supported
            return MP_OBJ_NULL;
    }
}

mp_obj_t mp_obj_new_int(machine_int_t value) {
    if (MP_OBJ_FITS_SMALL_INT(value)) {
        return MP_OBJ_NEW_SMALL_INT(value);
    }
    return mp_obj_new_int_from_ll(value);
}

mp_obj_t mp_obj_new_int_from_uint(machine_uint_t value) {
    // SMALL_INT accepts only signed numbers, of one bit less size
    // than word size, which totals 2 bits less for unsigned numbers.
    if ((value & (WORD_MSBIT_HIGH | (WORD_MSBIT_HIGH >> 1))) == 0) {
        return MP_OBJ_NEW_SMALL_INT(value);
    }
    return mp_obj_new_int_from_ll(value);
}

mp_obj_t mp_obj_new_int_from_ll(long long val) {
    mp_obj_int_t *o = m_new_obj(mp_obj_int_t);
    o->base.type = &int_type;
    o->val = val;
    return o;
}

mp_obj_t mp_obj_new_int_from_long_str(const char *s) {
    long long v;
    char *end;
    // TODO: this doesn't handle Python hacked 0o octal syntax
    v = strtoll(s, &end, 0);
    assert(*end == 0);
    mp_obj_int_t *o = m_new_obj(mp_obj_int_t);
    o->base.type = &int_type;
    o->val = v;
    return o;
}

123
124
125
126
machine_int_t mp_obj_int_get(mp_obj_t self_in) {
    if (MP_OBJ_IS_SMALL_INT(self_in)) {
        return MP_OBJ_SMALL_INT_VALUE(self_in);
    }
127
128
129
130
    mp_obj_int_t *self = self_in;
    return self->val;
}

131
132
133
134
135
machine_int_t mp_obj_int_get_checked(mp_obj_t self_in) {
    // TODO: Check overflow
    return mp_obj_int_get(self_in);
}

136
#endif