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/moduplatform.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 : : #define I(n) MP_OBJ_NEW_SMALL_INT(n)
63 : : // TODO: CPython is now at 5-element array, but save 2 els so far...
64 : : STATIC const mp_obj_tuple_t mp_sys_version_info_obj = {{&mp_type_tuple}, 3, {I(3), I(4), I(0)}};
65 : :
66 : : // sys.implementation object
67 : : // this holds the MicroPython version
68 : : STATIC const mp_obj_tuple_t mp_sys_implementation_version_info_obj = {
69 : : {&mp_type_tuple},
70 : : 3,
71 : : { I(MICROPY_VERSION_MAJOR), I(MICROPY_VERSION_MINOR), I(MICROPY_VERSION_MICRO) }
72 : : };
73 : : STATIC const MP_DEFINE_STR_OBJ(mp_sys_implementation_machine_obj, MICROPY_BANNER_MACHINE);
74 : : #if MICROPY_PERSISTENT_CODE_LOAD
75 : : #define SYS_IMPLEMENTATION_ELEMS \
76 : : MP_ROM_QSTR(MP_QSTR_micropython), \
77 : : MP_ROM_PTR(&mp_sys_implementation_version_info_obj), \
78 : : MP_ROM_PTR(&mp_sys_implementation_machine_obj), \
79 : : MP_ROM_INT(MPY_FILE_HEADER_INT)
80 : : #else
81 : : #define SYS_IMPLEMENTATION_ELEMS \
82 : : MP_ROM_QSTR(MP_QSTR_micropython), \
83 : : MP_ROM_PTR(&mp_sys_implementation_version_info_obj), \
84 : : MP_ROM_PTR(&mp_sys_implementation_machine_obj)
85 : : #endif
86 : : #if MICROPY_PY_ATTRTUPLE
87 : : STATIC const qstr impl_fields[] = {
88 : : MP_QSTR_name,
89 : : MP_QSTR_version,
90 : : MP_QSTR__machine,
91 : : #if MICROPY_PERSISTENT_CODE_LOAD
92 : : MP_QSTR__mpy,
93 : : #endif
94 : : };
95 : : STATIC MP_DEFINE_ATTRTUPLE(
96 : : mp_sys_implementation_obj,
97 : : impl_fields,
98 : : 3 + MICROPY_PERSISTENT_CODE_LOAD,
99 : : SYS_IMPLEMENTATION_ELEMS
100 : : );
101 : : #else
102 : : STATIC const mp_rom_obj_tuple_t mp_sys_implementation_obj = {
103 : : {&mp_type_tuple},
104 : : 3 + MICROPY_PERSISTENT_CODE_LOAD,
105 : : {
106 : : SYS_IMPLEMENTATION_ELEMS
107 : : }
108 : : };
109 : : #endif
110 : :
111 : : #undef I
112 : :
113 : : #ifdef MICROPY_PY_SYS_PLATFORM
114 : : // platform - the platform that MicroPython is running on
115 : : STATIC const MP_DEFINE_STR_OBJ(mp_sys_platform_obj, MICROPY_PY_SYS_PLATFORM);
116 : : #endif
117 : :
118 : : #ifdef MICROPY_PY_SYS_EXECUTABLE
119 : : // executable - the path to the micropython binary
120 : : // This object is non-const and is populated at startup in main()
121 : : MP_DEFINE_STR_OBJ(mp_sys_executable_obj, "");
122 : : #endif
123 : :
124 : : // exit([retval]): raise SystemExit, with optional argument given to the exception
125 : 8 : STATIC mp_obj_t mp_sys_exit(size_t n_args, const mp_obj_t *args) {
126 [ + + ]: 8 : if (n_args == 0) {
127 : 4 : mp_raise_type(&mp_type_SystemExit);
128 : : } else {
129 : 4 : mp_raise_type_arg(&mp_type_SystemExit, args[0]);
130 : : }
131 : : }
132 : : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_sys_exit_obj, 0, 1, mp_sys_exit);
133 : :
134 : 27 : STATIC mp_obj_t mp_sys_print_exception(size_t n_args, const mp_obj_t *args) {
135 : : #if MICROPY_PY_IO && MICROPY_PY_SYS_STDFILES
136 : 27 : void *stream_obj = &mp_sys_stdout_obj;
137 [ + + ]: 27 : if (n_args > 1) {
138 : 25 : mp_get_stream_raise(args[1], MP_STREAM_OP_WRITE);
139 : 24 : stream_obj = MP_OBJ_TO_PTR(args[1]);
140 : : }
141 : :
142 : 26 : mp_print_t print = {stream_obj, mp_stream_write_adaptor};
143 : 26 : mp_obj_print_exception(&print, args[0]);
144 : : #else
145 : : (void)n_args;
146 : : mp_obj_print_exception(&mp_plat_print, args[0]);
147 : : #endif
148 : :
149 : 26 : return mp_const_none;
150 : : }
151 : : MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_sys_print_exception_obj, 1, 2, mp_sys_print_exception);
152 : :
153 : : #if MICROPY_PY_SYS_EXC_INFO
154 : 3 : STATIC mp_obj_t mp_sys_exc_info(void) {
155 : 3 : mp_obj_t cur_exc = MP_OBJ_FROM_PTR(MP_STATE_VM(cur_exception));
156 : 3 : mp_obj_tuple_t *t = MP_OBJ_TO_PTR(mp_obj_new_tuple(3, NULL));
157 : :
158 [ + + ]: 3 : if (cur_exc == MP_OBJ_NULL) {
159 : 1 : t->items[0] = mp_const_none;
160 : 1 : t->items[1] = mp_const_none;
161 : 1 : t->items[2] = mp_const_none;
162 : 1 : return MP_OBJ_FROM_PTR(t);
163 : : }
164 : :
165 : 2 : t->items[0] = MP_OBJ_FROM_PTR(mp_obj_get_type(cur_exc));
166 : 2 : t->items[1] = cur_exc;
167 : 2 : t->items[2] = mp_const_none;
168 : 2 : return MP_OBJ_FROM_PTR(t);
169 : : }
170 : : MP_DEFINE_CONST_FUN_OBJ_0(mp_sys_exc_info_obj, mp_sys_exc_info);
171 : : #endif
172 : :
173 : : #if MICROPY_PY_SYS_GETSIZEOF
174 : 16 : STATIC mp_obj_t mp_sys_getsizeof(mp_obj_t obj) {
175 : 16 : return mp_unary_op(MP_UNARY_OP_SIZEOF, obj);
176 : : }
177 : : STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_getsizeof_obj, mp_sys_getsizeof);
178 : : #endif
179 : :
180 : : #if MICROPY_PY_SYS_ATEXIT
181 : : // atexit(callback): Callback is called when sys.exit is called.
182 : 2 : STATIC mp_obj_t mp_sys_atexit(mp_obj_t obj) {
183 : 2 : mp_obj_t old = MP_STATE_VM(sys_exitfunc);
184 : 2 : MP_STATE_VM(sys_exitfunc) = obj;
185 : 2 : return old;
186 : : }
187 : : STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_atexit_obj, mp_sys_atexit);
188 : : #endif
189 : :
190 : : #if MICROPY_PY_SYS_SETTRACE
191 : : // settrace(tracefunc): Set the system's trace function.
192 : : STATIC mp_obj_t mp_sys_settrace(mp_obj_t obj) {
193 : : return mp_prof_settrace(obj);
194 : : }
195 : : MP_DEFINE_CONST_FUN_OBJ_1(mp_sys_settrace_obj, mp_sys_settrace);
196 : : #endif // MICROPY_PY_SYS_SETTRACE
197 : :
198 : : #if MICROPY_PY_SYS_ATTR_DELEGATION
199 : : STATIC const uint16_t sys_mutable_keys[] = {
200 : : #if MICROPY_PY_SYS_PS1_PS2
201 : : MP_QSTR_ps1,
202 : : MP_QSTR_ps2,
203 : : #endif
204 : : #if MICROPY_PY_SYS_TRACEBACKLIMIT
205 : : MP_QSTR_tracebacklimit,
206 : : #endif
207 : : MP_QSTRnull,
208 : : };
209 : :
210 : 5446 : STATIC void mp_module_sys_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
211 : 5446 : MP_STATIC_ASSERT(MP_ARRAY_SIZE(sys_mutable_keys) == MP_SYS_MUTABLE_NUM + 1);
212 : 5446 : MP_STATIC_ASSERT(MP_ARRAY_SIZE(MP_STATE_VM(sys_mutable)) == MP_SYS_MUTABLE_NUM);
213 : 5446 : mp_module_generic_attr(attr, dest, sys_mutable_keys, MP_STATE_VM(sys_mutable));
214 : 5446 : }
215 : : #endif
216 : :
217 : : STATIC const mp_rom_map_elem_t mp_module_sys_globals_table[] = {
218 : : { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_sys) },
219 : :
220 : : { MP_ROM_QSTR(MP_QSTR_path), MP_ROM_PTR(&MP_STATE_VM(mp_sys_path_obj)) },
221 : : { MP_ROM_QSTR(MP_QSTR_argv), MP_ROM_PTR(&MP_STATE_VM(mp_sys_argv_obj)) },
222 : : { MP_ROM_QSTR(MP_QSTR_version), MP_ROM_PTR(&mp_sys_version_obj) },
223 : : { MP_ROM_QSTR(MP_QSTR_version_info), MP_ROM_PTR(&mp_sys_version_info_obj) },
224 : : { MP_ROM_QSTR(MP_QSTR_implementation), MP_ROM_PTR(&mp_sys_implementation_obj) },
225 : : #ifdef MICROPY_PY_SYS_PLATFORM
226 : : { MP_ROM_QSTR(MP_QSTR_platform), MP_ROM_PTR(&mp_sys_platform_obj) },
227 : : #endif
228 : : #if MP_ENDIANNESS_LITTLE
229 : : { MP_ROM_QSTR(MP_QSTR_byteorder), MP_ROM_QSTR(MP_QSTR_little) },
230 : : #else
231 : : { MP_ROM_QSTR(MP_QSTR_byteorder), MP_ROM_QSTR(MP_QSTR_big) },
232 : : #endif
233 : :
234 : : #if MICROPY_PY_SYS_MAXSIZE
235 : : #if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_NONE
236 : : // Maximum mp_int_t value is not representable as small int, so we have
237 : : // little choice but to use MP_SMALL_INT_MAX. Apps also should be careful
238 : : // to not try to compare sys.maxsize to some literal number (as this
239 : : // number might not fit in available int size), but instead count number
240 : : // of "one" bits in sys.maxsize.
241 : : { MP_ROM_QSTR(MP_QSTR_maxsize), MP_ROM_INT(MP_SMALL_INT_MAX) },
242 : : #else
243 : : { MP_ROM_QSTR(MP_QSTR_maxsize), MP_ROM_PTR(&mp_sys_maxsize_obj) },
244 : : #endif
245 : : #endif
246 : :
247 : : #if MICROPY_PY_SYS_EXIT
248 : : { MP_ROM_QSTR(MP_QSTR_exit), MP_ROM_PTR(&mp_sys_exit_obj) },
249 : : #endif
250 : :
251 : : #if MICROPY_PY_SYS_SETTRACE
252 : : { MP_ROM_QSTR(MP_QSTR_settrace), MP_ROM_PTR(&mp_sys_settrace_obj) },
253 : : #endif
254 : :
255 : : #if MICROPY_PY_SYS_STDFILES
256 : : { MP_ROM_QSTR(MP_QSTR_stdin), MP_ROM_PTR(&mp_sys_stdin_obj) },
257 : : { MP_ROM_QSTR(MP_QSTR_stdout), MP_ROM_PTR(&mp_sys_stdout_obj) },
258 : : { MP_ROM_QSTR(MP_QSTR_stderr), MP_ROM_PTR(&mp_sys_stderr_obj) },
259 : : #endif
260 : :
261 : : #if MICROPY_PY_SYS_MODULES
262 : : { MP_ROM_QSTR(MP_QSTR_modules), MP_ROM_PTR(&MP_STATE_VM(mp_loaded_modules_dict)) },
263 : : #endif
264 : : #if MICROPY_PY_SYS_EXC_INFO
265 : : { MP_ROM_QSTR(MP_QSTR_exc_info), MP_ROM_PTR(&mp_sys_exc_info_obj) },
266 : : #endif
267 : : #if MICROPY_PY_SYS_GETSIZEOF
268 : : { MP_ROM_QSTR(MP_QSTR_getsizeof), MP_ROM_PTR(&mp_sys_getsizeof_obj) },
269 : : #endif
270 : :
271 : : #if MICROPY_PY_SYS_EXECUTABLE
272 : : { MP_ROM_QSTR(MP_QSTR_executable), MP_ROM_PTR(&mp_sys_executable_obj) },
273 : : #endif
274 : :
275 : : /*
276 : : * Extensions to CPython
277 : : */
278 : :
279 : : { MP_ROM_QSTR(MP_QSTR_print_exception), MP_ROM_PTR(&mp_sys_print_exception_obj) },
280 : : #if MICROPY_PY_SYS_ATEXIT
281 : : { MP_ROM_QSTR(MP_QSTR_atexit), MP_ROM_PTR(&mp_sys_atexit_obj) },
282 : : #endif
283 : :
284 : : #if MICROPY_PY_SYS_ATTR_DELEGATION
285 : : // Delegation of attr lookup.
286 : : MP_MODULE_ATTR_DELEGATION_ENTRY(&mp_module_sys_attr),
287 : : #endif
288 : : };
289 : :
290 : : STATIC MP_DEFINE_CONST_DICT(mp_module_sys_globals, mp_module_sys_globals_table);
291 : :
292 : : const mp_obj_module_t mp_module_sys = {
293 : : .base = { &mp_type_module },
294 : : .globals = (mp_obj_dict_t *)&mp_module_sys_globals,
295 : : };
296 : :
297 : : MP_REGISTER_MODULE(MP_QSTR_usys, mp_module_sys);
298 : :
299 : : // If MICROPY_PY_SYS_PATH_ARGV_DEFAULTS is not enabled then these two lists
300 : : // must be initialised after the call to mp_init.
301 : : MP_REGISTER_ROOT_POINTER(mp_obj_list_t mp_sys_path_obj);
302 : : MP_REGISTER_ROOT_POINTER(mp_obj_list_t mp_sys_argv_obj);
303 : :
304 : : #if MICROPY_PY_SYS_EXC_INFO
305 : : // current exception being handled, for sys.exc_info()
306 : : MP_REGISTER_ROOT_POINTER(mp_obj_base_t * cur_exception);
307 : : #endif
308 : :
309 : : #if MICROPY_PY_SYS_ATEXIT
310 : : // exposed through sys.atexit function
311 : : MP_REGISTER_ROOT_POINTER(mp_obj_t sys_exitfunc);
312 : : #endif
313 : :
314 : : #if MICROPY_PY_SYS_ATTR_DELEGATION
315 : : // Contains mutable sys attributes.
316 : : MP_REGISTER_ROOT_POINTER(mp_obj_t sys_mutable[MP_SYS_MUTABLE_NUM]);
317 : : #endif
318 : :
319 : : #endif // MICROPY_PY_SYS
|
