builtinimport.c 19.3 KB
Newer Older
1
2
3
4
5
6
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2013, 2014 Damien P. George
7
 * Copyright (c) 2014 Paul Sokolovsky
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

28
29
30
31
#include <stdio.h>
#include <string.h>
#include <assert.h>

32
33
34
35
36
#include "py/nlr.h"
#include "py/compile.h"
#include "py/objmodule.h"
#include "py/runtime.h"
#include "py/builtin.h"
37
#include "py/frozenmod.h"
38

39
40
41
42
#if 0 // print debugging info
#define DEBUG_PRINT (1)
#define DEBUG_printf DEBUG_printf
#else // don't print debugging info
43
#define DEBUG_PRINT (0)
44
45
46
#define DEBUG_printf(...) (void)0
#endif

47
48
#define PATH_SEP_CHAR '/'

49
#if MICROPY_MODULE_WEAK_LINKS
50
STATIC const mp_rom_map_elem_t mp_builtin_module_weak_links_table[] = {
51
52
53
54
55
56
    MICROPY_PORT_BUILTIN_MODULE_WEAK_LINKS
};

STATIC MP_DEFINE_CONST_MAP(mp_builtin_module_weak_links_map, mp_builtin_module_weak_links_table);
#endif

57
58
59
60
61
62
bool mp_obj_is_package(mp_obj_t module) {
    mp_obj_t dest[2];
    mp_load_method_maybe(module, MP_QSTR___path__, dest);
    return dest[0] != MP_OBJ_NULL;
}

63
64
65
// Stat either frozen or normal module by a given path
// (whatever is available, if at all).
STATIC mp_import_stat_t mp_import_stat_any(const char *path) {
66
    #if MICROPY_MODULE_FROZEN
67
68
69
70
    mp_import_stat_t st = mp_frozen_stat(path);
    if (st != MP_IMPORT_STAT_NO_EXIST) {
        return st;
    }
71
    #endif
72
73
74
    return mp_import_stat(path);
}

Damien George's avatar
Damien George committed
75
STATIC mp_import_stat_t stat_dir_or_file(vstr_t *path) {
76
    mp_import_stat_t stat = mp_import_stat_any(vstr_null_terminated_str(path));
77
    DEBUG_printf("stat %s: %d\n", vstr_str(path), stat);
78
79
    if (stat == MP_IMPORT_STAT_DIR) {
        return stat;
80
    }
81

82
    vstr_add_str(path, ".py");
83
    stat = mp_import_stat_any(vstr_null_terminated_str(path));
84
85
    if (stat == MP_IMPORT_STAT_FILE) {
        return stat;
86
    }
87
88
89

    #if MICROPY_PERSISTENT_CODE_LOAD
    vstr_ins_byte(path, path->len - 2, 'm');
90
    stat = mp_import_stat_any(vstr_null_terminated_str(path));
91
92
93
94
95
    if (stat == MP_IMPORT_STAT_FILE) {
        return stat;
    }
    #endif

96
97
    return MP_IMPORT_STAT_NO_EXIST;
}
98

Damien George's avatar
Damien George committed
99
STATIC mp_import_stat_t find_file(const char *file_str, uint file_len, vstr_t *dest) {
100
#if MICROPY_PY_SYS
101
    // extract the list of paths
102
    mp_uint_t path_num;
103
    mp_obj_t *path_items;
104
    mp_obj_list_get(mp_sys_path, &path_num, &path_items);
105
106

    if (path_num == 0) {
107
#endif
Damien George's avatar
Damien George committed
108
        // mp_sys_path is empty, so just use the given file name
109
110
        vstr_add_strn(dest, file_str, file_len);
        return stat_dir_or_file(dest);
111
#if MICROPY_PY_SYS
112
    } else {
113
        // go through each path looking for a directory or file
114
        for (mp_uint_t i = 0; i < path_num; i++) {
115
            vstr_reset(dest);
116
            mp_uint_t p_len;
117
            const char *p = mp_obj_str_get_data(path_items[i], &p_len);
118
            if (p_len > 0) {
119
                vstr_add_strn(dest, p, p_len);
120
                vstr_add_char(dest, PATH_SEP_CHAR);
121
            }
122
123
124
125
            vstr_add_strn(dest, file_str, file_len);
            mp_import_stat_t stat = stat_dir_or_file(dest);
            if (stat != MP_IMPORT_STAT_NO_EXIST) {
                return stat;
126
127
            }
        }
128
129
130

        // could not find a directory or file
        return MP_IMPORT_STAT_NO_EXIST;
131
    }
132
#endif
133
134
}

135
#if MICROPY_ENABLE_COMPILER
136
STATIC void do_load_from_lexer(mp_obj_t module_obj, mp_lexer_t *lex, const char *fname) {
137

138
    if (lex == NULL) {
139
        // we verified the file exists using stat, but lexer could still fail
140
141
142
143
        if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
            nlr_raise(mp_obj_new_exception_msg(&mp_type_ImportError, "module not found"));
        } else {
            nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError,
144
                "no module named '%s'", fname));
145
        }
146
147
    }

148
    #if MICROPY_PY___FILE__
149
    qstr source_name = lex->source_name;
150
    mp_store_attr(module_obj, MP_QSTR___file__, MP_OBJ_NEW_QSTR(source_name));
151
    #endif
152

153
154
155
    // parse, compile and execute the module in its context
    mp_obj_dict_t *mod_globals = mp_obj_module_get_globals(module_obj);
    mp_parse_compile_execute(lex, MP_PARSE_FILE_INPUT, mod_globals, mod_globals);
156
}
157
#endif
158

159
#if MICROPY_PERSISTENT_CODE_LOAD || MICROPY_MODULE_FROZEN_MPY
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
STATIC void do_execute_raw_code(mp_obj_t module_obj, mp_raw_code_t *raw_code) {
    #if MICROPY_PY___FILE__
    // TODO
    //qstr source_name = lex->source_name;
    //mp_store_attr(module_obj, MP_QSTR___file__, MP_OBJ_NEW_QSTR(source_name));
    #endif

    // execute the module in its context
    mp_obj_dict_t *mod_globals = mp_obj_module_get_globals(module_obj);

    // save context
    mp_obj_dict_t *volatile old_globals = mp_globals_get();
    mp_obj_dict_t *volatile old_locals = mp_locals_get();

    // set new context
    mp_globals_set(mod_globals);
    mp_locals_set(mod_globals);

    nlr_buf_t nlr;
    if (nlr_push(&nlr) == 0) {
        mp_obj_t module_fun = mp_make_function_from_raw_code(raw_code, MP_OBJ_NULL, MP_OBJ_NULL);
        mp_call_function_0(module_fun);

        // finish nlr block, restore context
        nlr_pop();
        mp_globals_set(old_globals);
        mp_locals_set(old_locals);
    } else {
        // exception; restore context and re-raise same exception
        mp_globals_set(old_globals);
        mp_locals_set(old_locals);
191
        nlr_jump(nlr.ret_val);
192
193
194
195
    }
}
#endif

196
STATIC void do_load(mp_obj_t module_obj, vstr_t *file) {
197
    #if MICROPY_MODULE_FROZEN || MICROPY_PERSISTENT_CODE_LOAD || MICROPY_ENABLE_COMPILER
198
    char *file_str = vstr_null_terminated_str(file);
199
    #endif
200

201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
    // If we support frozen modules (either as str or mpy) then try to find the
    // requested filename in the list of frozen module filenames.
    #if MICROPY_MODULE_FROZEN
    void *modref;
    int frozen_type = mp_find_frozen_module(file_str, file->len, &modref);
    #endif

    // If we support frozen str modules and the compiler is enabled, and we
    // found the filename in the list of frozen files, then load and execute it.
    #if MICROPY_MODULE_FROZEN_STR
    if (frozen_type == MP_FROZEN_STR) {
        do_load_from_lexer(module_obj, modref, file_str);
        return;
    }
    #endif

    // If we support frozen mpy modules and we found a corresponding file (and
    // its data) in the list of frozen files, execute it.
    #if MICROPY_MODULE_FROZEN_MPY
    if (frozen_type == MP_FROZEN_MPY) {
        do_execute_raw_code(module_obj, modref);
        return;
    }
    #endif

    // If we support loading .mpy files then check if the file extension is of
    // the correct format and, if so, load and execute the file.
228
229
230
231
    #if MICROPY_PERSISTENT_CODE_LOAD
    if (file_str[file->len - 3] == 'm') {
        mp_raw_code_t *raw_code = mp_raw_code_load_file(file_str);
        do_execute_raw_code(module_obj, raw_code);
232
233
        return;
    }
234
    #endif
235

236
    // If we can compile scripts then load the file and compile and execute it.
237
    #if MICROPY_ENABLE_COMPILER
238
    {
239
240
241
        mp_lexer_t *lex = mp_lexer_new_from_file(file_str);
        do_load_from_lexer(module_obj, lex, file_str);
        return;
242
    }
243
244
245
    #endif

    // If we get here then the file was not frozen and we can't compile scripts.
246
247
    nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError,
        "script compilation not supported"));
248
249
}

250
251
252
253
254
255
256
257
258
259
260
STATIC void chop_component(const char *start, const char **end) {
    const char *p = *end;
    while (p > start) {
        if (*--p == '.') {
            *end = p;
            return;
        }
    }
    *end = p;
}

261
mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
262
#if DEBUG_PRINT
263
    DEBUG_printf("__import__:\n");
264
    for (mp_uint_t i = 0; i < n_args; i++) {
265
        DEBUG_printf("  ");
266
        mp_obj_print(args[i], PRINT_REPR);
267
        DEBUG_printf("\n");
268
    }
269
#endif
270

271
    mp_obj_t module_name = args[0];
272
    mp_obj_t fromtuple = mp_const_none;
273
    mp_int_t level = 0;
274
275
    if (n_args >= 4) {
        fromtuple = args[3];
276
277
278
279
280
        if (n_args >= 5) {
            level = MP_OBJ_SMALL_INT_VALUE(args[4]);
        }
    }

281
282
    mp_uint_t mod_len;
    const char *mod_str = mp_obj_str_get_data(module_name, &mod_len);
283

284
    if (level != 0) {
285
286
287
288
289
290
291
        // What we want to do here is to take name of current module,
        // chop <level> trailing components, and concatenate with passed-in
        // module name, thus resolving relative import name into absolue.
        // This even appears to be correct per
        // http://legacy.python.org/dev/peps/pep-0328/#relative-imports-and-name
        // "Relative imports use a module's __name__ attribute to determine that
        // module's position in the package hierarchy."
292
        level--;
293
        mp_obj_t this_name_q = mp_obj_dict_get(MP_OBJ_FROM_PTR(mp_globals_get()), MP_OBJ_NEW_QSTR(MP_QSTR___name__));
294
        assert(this_name_q != MP_OBJ_NULL);
295
296
297
        #if MICROPY_CPYTHON_COMPAT
        if (MP_OBJ_QSTR_VALUE(this_name_q) == MP_QSTR___main__) {
            // This is a module run by -m command-line switch, get its real name from backup attribute
298
            this_name_q = mp_obj_dict_get(MP_OBJ_FROM_PTR(mp_globals_get()), MP_OBJ_NEW_QSTR(MP_QSTR___main__));
299
300
        }
        #endif
301
        mp_map_t *globals_map = &mp_globals_get()->map;
302
303
304
        mp_map_elem_t *elem = mp_map_lookup(globals_map, MP_OBJ_NEW_QSTR(MP_QSTR___path__), MP_MAP_LOOKUP);
        bool is_pkg = (elem != NULL);

305
#if DEBUG_PRINT
306
        DEBUG_printf("Current module/package: ");
307
        mp_obj_print(this_name_q, PRINT_REPR);
308
        DEBUG_printf(", is_package: %d", is_pkg);
309
        DEBUG_printf("\n");
310
#endif
311

312
313
        mp_uint_t this_name_l;
        const char *this_name = mp_obj_str_get_data(this_name_q, &this_name_l);
314

315
316
317
318
319
320
321
322
        const char *p = this_name + this_name_l;
        if (!is_pkg) {
            // We have module, but relative imports are anchored at package, so
            // go there.
            chop_component(this_name, &p);
        }


323
        uint dots_seen = 0;
324
325
326
        while (level--) {
            chop_component(this_name, &p);
            dots_seen++;
327
328
        }

329
        if (dots_seen == 0 && level >= 1) {
330
331
332
333
334
335
336
337
338
339
            // http://legacy.python.org/dev/peps/pep-0328/#relative-imports-and-name
            // "If the module's name does not contain any package information
            // (e.g. it is set to '__main__') then relative imports are
            // resolved as if the module were a top level module, regardless
            // of where the module is actually located on the file system."
            // Supposedly this if catches this condition and resolve it properly
            // TODO: But nobody knows for sure. This condition happens when
            // package's __init__.py does something like "import .submod". So,
            // maybe we should check for package here? But quote above doesn't
            // talk about packages, it talks about dot-less module names.
340
            DEBUG_printf("Warning: no dots in current module name and level>0\n");
341
            p = this_name + this_name_l;
342
        } else if (level != -1) {
343
344
345
            nlr_raise(mp_obj_new_exception_msg(&mp_type_ImportError, "Invalid relative import"));
        }

346
        uint new_mod_l = (mod_len == 0 ? (size_t)(p - this_name) : (size_t)(p - this_name) + 1 + mod_len);
347
348
349
350
351
352
353
354
        char *new_mod = alloca(new_mod_l);
        memcpy(new_mod, this_name, p - this_name);
        if (mod_len != 0) {
            new_mod[p - this_name] = '.';
            memcpy(new_mod + (p - this_name) + 1, mod_str, mod_len);
        }

        qstr new_mod_q = qstr_from_strn(new_mod, new_mod_l);
355
356
357
358
359
        DEBUG_printf("Resolved base name for relative import: '%s'\n", qstr_str(new_mod_q));
        if (new_mod_q == MP_QSTR_) {
            // CPython raises SystemError
            nlr_raise(mp_obj_new_exception_msg(&mp_type_ImportError, "cannot perform relative import"));
        }
360
361
362
363
        module_name = MP_OBJ_NEW_QSTR(new_mod_q);
        mod_str = new_mod;
        mod_len = new_mod_l;
    }
364

365
    // check if module already exists
366
367
    qstr module_name_qstr = mp_obj_str_get_qstr(module_name);
    mp_obj_t module_obj = mp_module_get(module_name_qstr);
368
    if (module_obj != MP_OBJ_NULL) {
369
        DEBUG_printf("Module already loaded\n");
370
371
372
373
374
        // If it's not a package, return module right away
        char *p = strchr(mod_str, '.');
        if (p == NULL) {
            return module_obj;
        }
375
376
377
378
        // If fromlist is not empty, return leaf module
        if (fromtuple != mp_const_none) {
            return module_obj;
        }
379
380
        // Otherwise, we need to return top-level package
        qstr pkg_name = qstr_from_strn(mod_str, p - mod_str);
381
        return mp_module_get(pkg_name);
382
    }
383
    DEBUG_printf("Module not yet loaded\n");
384
385

    uint last = 0;
386
    VSTR_FIXED(path, MICROPY_ALLOC_PATH_MAX)
387
    module_obj = MP_OBJ_NULL;
388
389
    mp_obj_t top_module_obj = MP_OBJ_NULL;
    mp_obj_t outer_module_obj = MP_OBJ_NULL;
390
391
392
393
394
    uint i;
    for (i = 1; i <= mod_len; i++) {
        if (i == mod_len || mod_str[i] == '.') {
            // create a qstr for the module name up to this depth
            qstr mod_name = qstr_from_strn(mod_str, i);
395
            DEBUG_printf("Processing module: %s\n", qstr_str(mod_name));
396
            DEBUG_printf("Previous path: =%.*s=\n", vstr_len(&path), vstr_str(&path));
397
398
399

            // find the file corresponding to the module name
            mp_import_stat_t stat;
400
            if (vstr_len(&path) == 0) {
401
                // first module in the dotted-name; search for a directory or file
402
                stat = find_file(mod_str, i, &path);
403
404
            } else {
                // latter module in the dotted-name; append to path
405
406
407
                vstr_add_char(&path, PATH_SEP_CHAR);
                vstr_add_strn(&path, mod_str + last, i - last);
                stat = stat_dir_or_file(&path);
408
            }
409
            DEBUG_printf("Current path: %.*s\n", vstr_len(&path), vstr_str(&path));
410
411

            if (stat == MP_IMPORT_STAT_NO_EXIST) {
412
413
414
                #if MICROPY_MODULE_WEAK_LINKS
                // check if there is a weak link to this module
                if (i == mod_len) {
415
                    mp_map_elem_t *el = mp_map_lookup((mp_map_t*)&mp_builtin_module_weak_links_map, MP_OBJ_NEW_QSTR(mod_name), MP_MAP_LOOKUP);
416
417
418
419
420
421
422
423
424
425
426
                    if (el == NULL) {
                        goto no_exist;
                    }
                    // found weak linked module
                    module_obj = el->value;
                } else {
                    no_exist:
                #else
                {
                #endif
                    // couldn't find the file, so fail
427
428
429
430
                    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
                        nlr_raise(mp_obj_new_exception_msg(&mp_type_ImportError, "module not found"));
                    } else {
                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError,
431
                            "no module named '%q'", mod_name));
432
                    }
433
434
435
436
                }
            } else {
                // found the file, so get the module
                module_obj = mp_module_get(mod_name);
437
438
439
440
441
442
443
            }

            if (module_obj == MP_OBJ_NULL) {
                // module not already loaded, so load it!

                module_obj = mp_obj_new_module(mod_name);

444
445
446
447
                // if args[3] (fromtuple) has magic value False, set up
                // this module for command-line "-m" option (set module's
                // name to __main__ instead of real name).
                if (i == mod_len && fromtuple == mp_const_false) {
448
449
                    mp_obj_module_t *o = MP_OBJ_TO_PTR(module_obj);
                    mp_obj_dict_store(MP_OBJ_FROM_PTR(o->globals), MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR___main__));
450
                    #if MICROPY_CPYTHON_COMPAT
451
452
                    // Store module as "__main__" in the dictionary of loaded modules (returned by sys.modules).
                    mp_obj_dict_store(&MP_STATE_VM(mp_loaded_modules_dict), MP_OBJ_NEW_QSTR(MP_QSTR___main__), module_obj);
453
                    // Store real name in "__main__" attribute. Choosen semi-randonly, to reuse existing qstr's.
454
                    mp_obj_dict_store(MP_OBJ_FROM_PTR(o->globals), MP_OBJ_NEW_QSTR(MP_QSTR___main__), MP_OBJ_NEW_QSTR(mod_name));
455
                    #endif
456
457
                }

458
                if (stat == MP_IMPORT_STAT_DIR) {
459
                    DEBUG_printf("%.*s is dir\n", vstr_len(&path), vstr_str(&path));
460
                    // https://docs.python.org/3/reference/import.html
461
                    // "Specifically, any module that contains a __path__ attribute is considered a package."
462
                    mp_store_attr(module_obj, MP_QSTR___path__, mp_obj_new_str(vstr_str(&path), vstr_len(&path), false));
463
464
                    vstr_add_char(&path, PATH_SEP_CHAR);
                    vstr_add_str(&path, "__init__.py");
465
                    if (mp_import_stat_any(vstr_null_terminated_str(&path)) != MP_IMPORT_STAT_FILE) {
466
                        vstr_cut_tail_bytes(&path, sizeof("/__init__.py") - 1); // cut off /__init__.py
467
                        //mp_warning("%s is imported as namespace package", vstr_str(&path));
468
469
                    } else {
                        do_load(module_obj, &path);
470
                        vstr_cut_tail_bytes(&path, sizeof("/__init__.py") - 1); // cut off /__init__.py
471
472
                    }
                } else { // MP_IMPORT_STAT_FILE
473
                    do_load(module_obj, &path);
474
475
476
477
                    // TODO: We cannot just break here, at the very least, we must execute
                    // trailer code below. But otherwise if there're remaining components,
                    // that would be (??) object path within module, not modules path within FS.
                    // break;
478
479
                }
            }
480
481
            if (outer_module_obj != MP_OBJ_NULL) {
                qstr s = qstr_from_strn(mod_str + last, i - last);
Damien George's avatar
Damien George committed
482
                mp_store_attr(outer_module_obj, s, module_obj);
483
484
485
486
487
488
            }
            outer_module_obj = module_obj;
            if (top_module_obj == MP_OBJ_NULL) {
                top_module_obj = module_obj;
            }
            last = i + 1;
489
490
491
492
493
494
495
496
497
        }
    }

    if (i < mod_len) {
        // we loaded a package, now need to load objects from within that package
        // TODO
        assert(0);
    }

498
499
500
501
502
    // If fromlist is not empty, return leaf module
    if (fromtuple != mp_const_none) {
        return module_obj;
    }
    // Otherwise, we need to return top-level package
503
    return top_module_obj;
504
}
505
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin___import___obj, 1, 5, mp_builtin___import__);