objint_longlong.c 5.33 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
#include "obj.h"
#include "objint.h"
#include "runtime0.h"

#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_LONGLONG

// 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) {
25
26
27
28
29
30
    if (MP_OBJ_IS_SMALL_INT(self_in)) {
        print(env, "%d", (int)MP_OBJ_SMALL_INT_VALUE(self_in));
    } else {
        mp_obj_int_t *self = self_in;
        print(env, "%lld" SUFFIX, self->val);
    }
31
32
}

33
34
35
mp_obj_t int_unary_op(int op, mp_obj_t o_in) {
    mp_obj_int_t *o = o_in;
    switch (op) {
36
        case RT_UNARY_OP_BOOL: return MP_BOOL(o->val != 0);
37
38
39
40
41
42
43
        case RT_UNARY_OP_POSITIVE: return o_in;
        case RT_UNARY_OP_NEGATIVE: return mp_obj_new_int_from_ll(-o->val);
        case RT_UNARY_OP_INVERT: return mp_obj_new_int_from_ll(~o->val);
        default: return NULL; // op not supported
    }
}

44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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);
62
63
64
65
66
67
        case RT_BINARY_OP_MULTIPLY:
            return mp_obj_new_int_from_ll(lhs->val * rhs_val);
        case RT_BINARY_OP_FLOOR_DIVIDE:
            return mp_obj_new_int_from_ll(lhs->val / rhs_val);
        case RT_BINARY_OP_MODULO:
            return mp_obj_new_int_from_ll(lhs->val % rhs_val);
68
69

        case RT_BINARY_OP_INPLACE_ADD:
70
            lhs->val += rhs_val; return lhs;
71
        case RT_BINARY_OP_INPLACE_SUBTRACT:
72
73
74
75
76
77
78
            lhs->val -= rhs_val; return lhs;
        case RT_BINARY_OP_INPLACE_MULTIPLY:
            lhs->val *= rhs_val; return lhs;
        case RT_BINARY_OP_INPLACE_FLOOR_DIVIDE:
            lhs->val /= rhs_val; return lhs;
        case RT_BINARY_OP_INPLACE_MODULO:
            lhs->val %= rhs_val; return lhs;
79
80
81
82
83
84
85
86

        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);

87
88
89
90
91
92
93
        case RT_BINARY_OP_INPLACE_AND:
            lhs->val &= rhs_val; return lhs;
        case RT_BINARY_OP_INPLACE_OR:
            lhs->val |= rhs_val; return lhs;
        case RT_BINARY_OP_INPLACE_XOR:
            lhs->val ^= rhs_val; return lhs;

94
95
96
97
98
        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);

99
100
101
102
103
        case RT_BINARY_OP_INPLACE_LSHIFT:
            lhs->val <<= (int)rhs_val; return lhs;
        case RT_BINARY_OP_INPLACE_RSHIFT:
            lhs->val >>= (int)rhs_val; return lhs;

104
        case RT_BINARY_OP_LESS:
105
            return MP_BOOL(lhs->val < rhs_val);
106
        case RT_BINARY_OP_MORE:
107
            return MP_BOOL(lhs->val > rhs_val);
108
        case RT_BINARY_OP_LESS_EQUAL:
109
            return MP_BOOL(lhs->val <= rhs_val);
110
        case RT_BINARY_OP_MORE_EQUAL:
111
            return MP_BOOL(lhs->val >= rhs_val);
112
        case RT_BINARY_OP_EQUAL:
113
            return MP_BOOL(lhs->val == rhs_val);
114
        case RT_BINARY_OP_NOT_EQUAL:
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
            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);
151
152
153
    if (*end != 0) {
        nlr_jump(mp_obj_new_exception_msg(&mp_type_SyntaxError, "invalid syntax for number"));
    }
154
155
156
157
158
159
    mp_obj_int_t *o = m_new_obj(mp_obj_int_t);
    o->base.type = &int_type;
    o->val = v;
    return o;
}

160
161
162
163
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);
    }
164
165
166
167
    mp_obj_int_t *self = self_in;
    return self->val;
}

168
169
170
171
172
machine_int_t mp_obj_int_get_checked(mp_obj_t self_in) {
    // TODO: Check overflow
    return mp_obj_int_get(self_in);
}

173
#endif