Branch data Line data Source code
1 : : /*
2 : : * This file is part of the MicroPython project, http://micropython.org/
3 : : *
4 : : * The MIT License (MIT)
5 : : *
6 : : * Copyright (c) 2013, 2014 Damien P. George
7 : : * Copyright (c) 2014-2017 Paul Sokolovsky
8 : : *
9 : : * Permission is hereby granted, free of charge, to any person obtaining a copy
10 : : * of this software and associated documentation files (the "Software"), to deal
11 : : * in the Software without restriction, including without limitation the rights
12 : : * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 : : * copies of the Software, and to permit persons to whom the Software is
14 : : * furnished to do so, subject to the following conditions:
15 : : *
16 : : * The above copyright notice and this permission notice shall be included in
17 : : * all copies or substantial portions of the Software.
18 : : *
19 : : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 : : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 : : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 : : * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 : : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 : : * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 : : * THE SOFTWARE.
26 : : */
27 : :
28 : : #include "py/builtin.h"
29 : : #include "py/objlist.h"
30 : : #include "py/objmodule.h"
31 : : #include "py/objtuple.h"
32 : : #include "py/objstr.h"
33 : : #include "py/objint.h"
34 : : #include "py/objtype.h"
35 : : #include "py/stream.h"
36 : : #include "py/smallint.h"
37 : : #include "py/runtime.h"
38 : : #include "py/persistentcode.h"
39 : : #include "extmod/modplatform.h"
40 : : #include "genhdr/mpversion.h"
41 : :
42 : : #if MICROPY_PY_SYS_SETTRACE
43 : : #include "py/objmodule.h"
44 : : #include "py/profile.h"
45 : : #endif
46 : :
47 : : #if MICROPY_PY_SYS
48 : :
49 : : // defined per port; type of these is irrelevant, just need pointer
50 : : extern struct _mp_dummy_t mp_sys_stdin_obj;
51 : : extern struct _mp_dummy_t mp_sys_stdout_obj;
52 : : extern struct _mp_dummy_t mp_sys_stderr_obj;
53 : :
54 : : #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
55 : : const mp_print_t mp_sys_stdout_print = {&mp_sys_stdout_obj, mp_stream_write_adaptor};
56 : : #endif
57 : :
58 : : // version - Python language version that this implementation conforms to, as a string
59 : : STATIC const MP_DEFINE_STR_OBJ(mp_sys_version_obj, "3.4.0; " MICROPY_BANNER_NAME_AND_VERSION);
60 : :
61 : : // version_info - Python language version that this implementation conforms to, as a tuple of ints
62 : : // TODO: CPython is now at 5-element array (major, minor, micro, releaselevel, serial), but save 2 els so far...
63 : : STATIC const mp_rom_obj_tuple_t mp_sys_version_info_obj = {{&mp_type_tuple}, 3, {MP_ROM_INT(3), MP_ROM_INT(4), MP_ROM_INT(0)}};
64 : :
65 : : // sys.implementation object
66 : : // this holds the MicroPython version
67 : : STATIC const mp_rom_obj_tuple_t mp_sys_implementation_version_info_obj = {
68 : : {&mp_type_tuple},
69 : : 4,
70 : : {
71 : : MP_ROM_INT(MICROPY_VERSION_MAJOR),
72 : : MP_ROM_INT(MICROPY_VERSION_MINOR),
73 : : MP_ROM_INT(MICROPY_VERSION_MICRO),
74 : : #if MICROPY_VERSION_PRERELEASE
75 : : MP_ROM_QSTR(MP_QSTR_preview),
76 : : #else
77 : : MP_ROM_QSTR(MP_QSTR_),
78 : : #endif
79 : : }
80 : : };
81 : : STATIC const MP_DEFINE_STR_OBJ(mp_sys_implementation_machine_obj, MICROPY_BANNER_MACHINE);
82 : : #define SYS_IMPLEMENTATION_ELEMS_BASE \
83 : : MP_ROM_QSTR(MP_QSTR_micropython), \
84 : : MP_ROM_PTR(&mp_sys_implementation_version_info_obj), \
85 : : MP_ROM_PTR(&mp_sys_implementation_machine_obj)
86 : :
87 : : #if MICROPY_PERSISTENT_CODE_LOAD
88 : : #define SYS_IMPLEMENTATION_ELEMS__MPY \
89 : : , MP_ROM_INT(MPY_FILE_HEADER_INT)
90 : : #else
91 : : #define SYS_IMPLEMENTATION_ELEMS__MPY
92 : : #endif
93 : :
94 : : #if MICROPY_PY_ATTRTUPLE
95 : : #if MICROPY_PREVIEW_VERSION_2
96 : : #define SYS_IMPLEMENTATION_ELEMS__V2 \
97 : : , MP_ROM_TRUE
98 : : #else
99 : : #define SYS_IMPLEMENTATION_ELEMS__V2
100 : : #endif
101 : :
102 : : STATIC const qstr impl_fields[] = {
103 : : MP_QSTR_name,
104 : : MP_QSTR_version,
105 : : MP_QSTR__machine,
106 : : #if MICROPY_PERSISTENT_CODE_LOAD
107 : : MP_QSTR__mpy,
108 : : #endif
109 : : #if MICROPY_PREVIEW_VERSION_2
110 : : MP_QSTR__v2,
111 : : #endif
112 : : };
113 : : STATIC MP_DEFINE_ATTRTUPLE(
114 : : mp_sys_implementation_obj,
115 : : impl_fields,
116 : : 3 + MICROPY_PERSISTENT_CODE_LOAD + MICROPY_PREVIEW_VERSION_2,
117 : : SYS_IMPLEMENTATION_ELEMS_BASE
118 : : SYS_IMPLEMENTATION_ELEMS__MPY
119 : : SYS_IMPLEMENTATION_ELEMS__V2
120 : : );
121 : : #else
122 : : STATIC const mp_rom_obj_tuple_t mp_sys_implementation_obj = {
123 : : {&mp_type_tuple},
124 : : 3 + MICROPY_PERSISTENT_CODE_LOAD,
125 : : // Do not include SYS_IMPLEMENTATION_ELEMS__V2 because
126 : : // SYS_IMPLEMENTATION_ELEMS__MPY may be empty if
127 : : // MICROPY_PERSISTENT_CODE_LOAD is disabled, which means they'll share
128 : : // the same index. Cannot query _v2 if MICROPY_PY_ATTRTUPLE is
129 : : // disabled.
130 : : {
131 : : SYS_IMPLEMENTATION_ELEMS_BASE
132 : : SYS_IMPLEMENTATION_ELEMS__MPY
133 : : }
134 : : };
135 : : #endif
136 : :
137 : : #undef I
138 : :
139 : : #ifdef MICROPY_PY_SYS_PLATFORM
140 : : // platform - the platform that MicroPython is running on
141 : : STATIC const MP_DEFINE_STR_OBJ(mp_sys_platform_obj, MICROPY_PY_SYS_PLATFORM);
142 : : #endif
143 : :
144 : : #ifdef MICROPY_PY_SYS_EXECUTABLE
145 : : // executable - the path to the micropython binary
146 : : // This object is non-const and is populated at startup in main()
147 : : MP_DEFINE_STR_OBJ(mp_sys_executable_obj, "");
148 : : #endif
149 : :
150 : : // exit([retval]): raise SystemExit, with optional argument given to the exception
151 : 8 : STATIC mp_obj_t mp_sys_exit(size_t n_args, const mp_obj_t *args) {
152 [ + + ]: 8 : if (n_args == 0) {
153 : 4 : mp_raise_type(&mp_type_SystemExit);
154 : : } else {
155 : 4 : mp_raise_type_arg(&mp_type_SystemExit, args[0]);
156 : : }
157 : : }
158 : : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_sys_exit_obj, 0, 1, mp_sys_exit);
159 : :
160 : 27 : STATIC mp_obj_t mp_sys_print_exception(size_t n_args, const mp_obj_t *args) {
161 : : #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
162 : 27 : void *stream_obj = &mp_sys_stdout_obj;
163 [ + + ]: 27 : if (n_args > 1) {
164 : 25 : mp_get_stream_raise(args[1], MP_STREAM_OP_WRITE);
165 : 24 : stream_obj = MP_OBJ_TO_PTR(args[1]);
166 : : }
167 : :
168 : 26 : mp_print_t print = {stream_obj, mp_stream_write_adaptor};
169 : 26 : mp_obj_print_exception(&print, args[0]);
170 : : #else
171 : : (void)n_args;
172 : : mp_obj_print_exception(&mp_plat_print, args[0]);
173 : : #endif
174 : :
175 : 26 : return mp_const_none;
176 : : }
177 : : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_sys_print_exception_obj, 1, 2, mp_sys_print_exception);
178 : :
179 : : #if MICROPY_PY_SYS_EXC_INFO
180 : 3 : STATIC mp_obj_t mp_sys_exc_info(void) {
181 : 3 : mp_obj_t cur_exc = MP_OBJ_FROM_PTR(MP_STATE_VM(cur_exception));
182 : 3 : mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
183 : :
184 [ + + ]: 3 : if (cur_exc == MP_OBJ_NULL) {
185 : 1 : t->items[0] = mp_const_none;
186 : 1 : t->items[1] = mp_const_none;
187 : 1 : t->items[2] = mp_const_none;
188 : 1 : return MP_OBJ_FROM_PTR(t);
189 : : }
190 : :
191 : 2 : t->items[0] = MP_OBJ_FROM_PTR(mp_obj_get_type(cur_exc));
192 : 2 : t->items[1] = cur_exc;
193 : 2 : t->items[2] = mp_const_none;
194 : 2 : return MP_OBJ_FROM_PTR(t);
195 : : }
196 : : MP_DEFINE_CONST_FUN_OBJ_0(mp_sys_exc_info_obj, mp_sys_exc_info);
197 : : #endif
198 : :
199 : : #if MICROPY_PY_SYS_GETSIZEOF
200 : 16 : STATIC mp_obj_t mp_sys_getsizeof(mp_obj_t obj) {
201 : 16 : return mp_unary_op(MP_UNARY_OP_SIZEOF, obj);
202 : : }
203 : : STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_getsizeof_obj, mp_sys_getsizeof);
204 : : #endif
205 : :
206 : : #if MICROPY_PY_SYS_ATEXIT
207 : : // atexit(callback): Callback is called when sys.exit is called.
208 : 2 : STATIC mp_obj_t mp_sys_atexit(mp_obj_t obj) {
209 : 2 : mp_obj_t old = MP_STATE_VM(sys_exitfunc);
210 : 2 : MP_STATE_VM(sys_exitfunc) = obj;
211 : 2 : return old;
212 : : }
213 : : STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_atexit_obj, mp_sys_atexit);
214 : : #endif
215 : :
216 : : #if MICROPY_PY_SYS_SETTRACE
217 : : // settrace(tracefunc): Set the system's trace function.
218 : : STATIC mp_obj_t mp_sys_settrace(mp_obj_t obj) {
219 : : return mp_prof_settrace(obj);
220 : : }
221 : : MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_settrace_obj, mp_sys_settrace);
222 : : #endif // MICROPY_PY_SYS_SETTRACE
223 : :
224 : : #if MICROPY_PY_SYS_PATH && !MICROPY_PY_SYS_ATTR_DELEGATION
225 : : #error "MICROPY_PY_SYS_PATH requires MICROPY_PY_SYS_ATTR_DELEGATION"
226 : : #endif
227 : :
228 : : #if MICROPY_PY_SYS_PS1_PS2 && !MICROPY_PY_SYS_ATTR_DELEGATION
229 : : #error "MICROPY_PY_SYS_PS1_PS2 requires MICROPY_PY_SYS_ATTR_DELEGATION"
230 : : #endif
231 : :
232 : : #if MICROPY_PY_SYS_TRACEBACKLIMIT && !MICROPY_PY_SYS_ATTR_DELEGATION
233 : : #error "MICROPY_PY_SYS_TRACEBACKLIMIT requires MICROPY_PY_SYS_ATTR_DELEGATION"
234 : : #endif
235 : :
236 : : #if MICROPY_PY_SYS_ATTR_DELEGATION && !MICROPY_MODULE_ATTR_DELEGATION
237 : : #error "MICROPY_PY_SYS_ATTR_DELEGATION requires MICROPY_MODULE_ATTR_DELEGATION"
238 : : #endif
239 : :
240 : : #if MICROPY_PY_SYS_ATTR_DELEGATION
241 : : // Must be kept in sync with the enum at the top of mpstate.h.
242 : : STATIC const uint16_t sys_mutable_keys[] = {
243 : : #if MICROPY_PY_SYS_PATH
244 : : // Code should access this (as an mp_obj_t) for use with e.g.
245 : : // mp_obj_list_append by using the `mp_sys_path` macro defined in runtime.h.
246 : : MP_QSTR_path,
247 : : #endif
248 : : #if MICROPY_PY_SYS_PS1_PS2
249 : : MP_QSTR_ps1,
250 : : MP_QSTR_ps2,
251 : : #endif
252 : : #if MICROPY_PY_SYS_TRACEBACKLIMIT
253 : : MP_QSTR_tracebacklimit,
254 : : #endif
255 : : MP_QSTRnull,
256 : : };
257 : :
258 : 5612 : void mp_module_sys_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
259 : 5612 : MP_STATIC_ASSERT(MP_ARRAY_SIZE(sys_mutable_keys) == MP_SYS_MUTABLE_NUM + 1);
260 : 5612 : MP_STATIC_ASSERT(MP_ARRAY_SIZE(MP_STATE_VM(sys_mutable)) == MP_SYS_MUTABLE_NUM);
261 : 5612 : mp_module_generic_attr(attr, dest, sys_mutable_keys, MP_STATE_VM(sys_mutable));
262 : 5612 : }
263 : : #endif
264 : :
265 : : STATIC const mp_rom_map_elem_t mp_module_sys_globals_table[] = {
266 : : { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_sys) },
267 : :
268 : : #if MICROPY_PY_SYS_ARGV
269 : : { MP_ROM_QSTR(MP_QSTR_argv), MP_ROM_PTR(&MP_STATE_VM(mp_sys_argv_obj)) },
270 : : #endif
271 : : { MP_ROM_QSTR(MP_QSTR_version), MP_ROM_PTR(&mp_sys_version_obj) },
272 : : { MP_ROM_QSTR(MP_QSTR_version_info), MP_ROM_PTR(&mp_sys_version_info_obj) },
273 : : { MP_ROM_QSTR(MP_QSTR_implementation), MP_ROM_PTR(&mp_sys_implementation_obj) },
274 : : #ifdef MICROPY_PY_SYS_PLATFORM
275 : : { MP_ROM_QSTR(MP_QSTR_platform), MP_ROM_PTR(&mp_sys_platform_obj) },
276 : : #endif
277 : : #if MP_ENDIANNESS_LITTLE
278 : : { MP_ROM_QSTR(MP_QSTR_byteorder), MP_ROM_QSTR(MP_QSTR_little) },
279 : : #else
280 : : { MP_ROM_QSTR(MP_QSTR_byteorder), MP_ROM_QSTR(MP_QSTR_big) },
281 : : #endif
282 : :
283 : : #if MICROPY_PY_SYS_MAXSIZE
284 : : #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_NONE
285 : : // Maximum mp_int_t value is not representable as small int, so we have
286 : : // little choice but to use MP_SMALL_INT_MAX. Apps also should be careful
287 : : // to not try to compare sys.maxsize to some literal number (as this
288 : : // number might not fit in available int size), but instead count number
289 : : // of "one" bits in sys.maxsize.
290 : : { MP_ROM_QSTR(MP_QSTR_maxsize), MP_ROM_INT(MP_SMALL_INT_MAX) },
291 : : #else
292 : : { MP_ROM_QSTR(MP_QSTR_maxsize), MP_ROM_PTR(&mp_sys_maxsize_obj) },
293 : : #endif
294 : : #endif
295 : :
296 : : #if MICROPY_PY_SYS_EXIT
297 : : { MP_ROM_QSTR(MP_QSTR_exit), MP_ROM_PTR(&mp_sys_exit_obj) },
298 : : #endif
299 : :
300 : : #if MICROPY_PY_SYS_SETTRACE
301 : : { MP_ROM_QSTR(MP_QSTR_settrace), MP_ROM_PTR(&mp_sys_settrace_obj) },
302 : : #endif
303 : :
304 : : #if MICROPY_PY_SYS_STDFILES
305 : : { MP_ROM_QSTR(MP_QSTR_stdin), MP_ROM_PTR(&mp_sys_stdin_obj) },
306 : : { MP_ROM_QSTR(MP_QSTR_stdout), MP_ROM_PTR(&mp_sys_stdout_obj) },
307 : : { MP_ROM_QSTR(MP_QSTR_stderr), MP_ROM_PTR(&mp_sys_stderr_obj) },
308 : : #endif
309 : :
310 : : #if MICROPY_PY_SYS_MODULES
311 : : { MP_ROM_QSTR(MP_QSTR_modules), MP_ROM_PTR(&MP_STATE_VM(mp_loaded_modules_dict)) },
312 : : #endif
313 : : #if MICROPY_PY_SYS_EXC_INFO
314 : : { MP_ROM_QSTR(MP_QSTR_exc_info), MP_ROM_PTR(&mp_sys_exc_info_obj) },
315 : : #endif
316 : : #if MICROPY_PY_SYS_GETSIZEOF
317 : : { MP_ROM_QSTR(MP_QSTR_getsizeof), MP_ROM_PTR(&mp_sys_getsizeof_obj) },
318 : : #endif
319 : :
320 : : #if MICROPY_PY_SYS_EXECUTABLE
321 : : { MP_ROM_QSTR(MP_QSTR_executable), MP_ROM_PTR(&mp_sys_executable_obj) },
322 : : #endif
323 : :
324 : : /*
325 : : * Extensions to CPython
326 : : */
327 : :
328 : : { MP_ROM_QSTR(MP_QSTR_print_exception), MP_ROM_PTR(&mp_sys_print_exception_obj) },
329 : : #if MICROPY_PY_SYS_ATEXIT
330 : : { MP_ROM_QSTR(MP_QSTR_atexit), MP_ROM_PTR(&mp_sys_atexit_obj) },
331 : : #endif
332 : : };
333 : :
334 : : STATIC MP_DEFINE_CONST_DICT(mp_module_sys_globals, mp_module_sys_globals_table);
335 : :
336 : : const mp_obj_module_t mp_module_sys = {
337 : : .base = { &mp_type_module },
338 : : .globals = (mp_obj_dict_t *)&mp_module_sys_globals,
339 : : };
340 : :
341 : : // Unlike the other CPython-compatible modules, sys is not extensible from the
342 : : // filesystem. We rely on it to work so that things like sys.path are always
343 : : // available.
344 : : MP_REGISTER_MODULE(MP_QSTR_sys, mp_module_sys);
345 : :
346 : : #if MICROPY_PY_SYS_ARGV
347 : : // Code should access this (as an mp_obj_t) for use with e.g.
348 : : // mp_obj_list_append by using the `mp_sys_argv` macro defined in runtime.h.
349 : : MP_REGISTER_ROOT_POINTER(mp_obj_list_t mp_sys_argv_obj);
350 : : #endif
351 : :
352 : : #if MICROPY_PY_SYS_EXC_INFO
353 : : // current exception being handled, for sys.exc_info()
354 : : MP_REGISTER_ROOT_POINTER(mp_obj_base_t * cur_exception);
355 : : #endif
356 : :
357 : : #if MICROPY_PY_SYS_ATEXIT
358 : : // exposed through sys.atexit function
359 : : MP_REGISTER_ROOT_POINTER(mp_obj_t sys_exitfunc);
360 : : #endif
361 : :
362 : : #if MICROPY_PY_SYS_ATTR_DELEGATION
363 : : // Contains mutable sys attributes.
364 : : MP_REGISTER_ROOT_POINTER(mp_obj_t sys_mutable[MP_SYS_MUTABLE_NUM]);
365 : : MP_REGISTER_MODULE_DELEGATION(mp_module_sys, mp_module_sys_attr);
366 : : #endif
367 : :
368 : : #endif // MICROPY_PY_SYS
|
