builtinimport.c 19.2 KB
Newer Older
1
/*
2
 * This file is part of the MicroPython project, http://micropython.org/
3 4 5 6
 *
 * 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
#include "py/compile.h"
#include "py/objmodule.h"
34
#include "py/persistentcode.h"
35 36
#include "py/runtime.h"
#include "py/builtin.h"
37
#include "py/frozenmod.h"
38

39
#if MICROPY_DEBUG_VERBOSE // print debugging info
40 41 42
#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
#if MICROPY_ENABLE_EXTERNAL_IMPORT

49 50
#define PATH_SEP_CHAR '/'

51 52 53 54 55 56
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;
}

57 58 59
// 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) {
60
    #if MICROPY_MODULE_FROZEN
61 62 63 64
    mp_import_stat_t st = mp_frozen_stat(path);
    if (st != MP_IMPORT_STAT_NO_EXIST) {
        return st;
    }
65
    #endif
66 67 68
    return mp_import_stat(path);
}

69
STATIC mp_import_stat_t stat_file_py_or_mpy(vstr_t *path) {
70
    mp_import_stat_t stat = mp_import_stat_any(vstr_null_terminated_str(path));
71 72
    if (stat == MP_IMPORT_STAT_FILE) {
        return stat;
73
    }
74 75 76

    #if MICROPY_PERSISTENT_CODE_LOAD
    vstr_ins_byte(path, path->len - 2, 'm');
77
    stat = mp_import_stat_any(vstr_null_terminated_str(path));
78 79 80 81 82
    if (stat == MP_IMPORT_STAT_FILE) {
        return stat;
    }
    #endif

83 84
    return MP_IMPORT_STAT_NO_EXIST;
}
85

86 87 88 89 90 91 92 93 94 95 96 97
STATIC mp_import_stat_t stat_dir_or_file(vstr_t *path) {
    mp_import_stat_t stat = mp_import_stat_any(vstr_null_terminated_str(path));
    DEBUG_printf("stat %s: %d\n", vstr_str(path), stat);
    if (stat == MP_IMPORT_STAT_DIR) {
        return stat;
    }

    // not a directory, add .py and try as a file
    vstr_add_str(path, ".py");
    return stat_file_py_or_mpy(path);
}

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

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

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

134
#if MICROPY_ENABLE_COMPILER
135
STATIC void do_load_from_lexer(mp_obj_t module_obj, mp_lexer_t *lex) {
136
    #if MICROPY_PY___FILE__
137
    qstr source_name = lex->source_name;
138
    mp_store_attr(module_obj, MP_QSTR___file__, MP_OBJ_NEW_QSTR(source_name));
139
    #endif
140

141 142 143
    // 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);
144
}
145
#endif
146

147
#if MICROPY_PERSISTENT_CODE_LOAD || MICROPY_MODULE_FROZEN_MPY
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
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);
179
        nlr_jump(nlr.ret_val);
180 181 182 183
    }
}
#endif

184
STATIC void do_load(mp_obj_t module_obj, vstr_t *file) {
185
    #if MICROPY_MODULE_FROZEN || MICROPY_PERSISTENT_CODE_LOAD || MICROPY_ENABLE_COMPILER
186
    char *file_str = vstr_null_terminated_str(file);
187
    #endif
188

189 190 191 192 193 194 195 196 197 198 199
    // 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) {
200
        do_load_from_lexer(module_obj, modref);
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
        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.
216 217 218 219
    #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);
220 221
        return;
    }
222
    #endif
223

224
    // If we can compile scripts then load the file and compile and execute it.
225
    #if MICROPY_ENABLE_COMPILER
226
    {
227
        mp_lexer_t *lex = mp_lexer_new_from_file(file_str);
228
        do_load_from_lexer(module_obj, lex);
229
        return;
230
    }
231
    #else
232 233

    // If we get here then the file was not frozen and we can't compile scripts.
234
    mp_raise_msg(&mp_type_ImportError, "script compilation not supported");
235
    #endif
236 237
}

238 239 240 241 242 243 244 245 246 247 248
STATIC void chop_component(const char *start, const char **end) {
    const char *p = *end;
    while (p > start) {
        if (*--p == '.') {
            *end = p;
            return;
        }
    }
    *end = p;
}

249
mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
250
#if DEBUG_PRINT
251
    DEBUG_printf("__import__:\n");
252
    for (size_t i = 0; i < n_args; i++) {
253
        DEBUG_printf("  ");
254
        mp_obj_print(args[i], PRINT_REPR);
255
        DEBUG_printf("\n");
256
    }
257
#endif
258

259
    mp_obj_t module_name = args[0];
260
    mp_obj_t fromtuple = mp_const_none;
261
    mp_int_t level = 0;
262 263
    if (n_args >= 4) {
        fromtuple = args[3];
264 265
        if (n_args >= 5) {
            level = MP_OBJ_SMALL_INT_VALUE(args[4]);
266 267 268
            if (level < 0) {
                mp_raise_ValueError(NULL);
            }
269 270 271
        }
    }

272
    size_t mod_len;
273
    const char *mod_str = mp_obj_str_get_data(module_name, &mod_len);
274

275
    if (level != 0) {
276 277
        // What we want to do here is to take name of current module,
        // chop <level> trailing components, and concatenate with passed-in
Ville Skyttä's avatar
Ville Skyttä committed
278
        // module name, thus resolving relative import name into absolute.
279 280 281 282
        // 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."
283
        level--;
284
        mp_obj_t this_name_q = mp_obj_dict_get(MP_OBJ_FROM_PTR(mp_globals_get()), MP_OBJ_NEW_QSTR(MP_QSTR___name__));
285
        assert(this_name_q != MP_OBJ_NULL);
286 287 288
        #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
289
            this_name_q = mp_obj_dict_get(MP_OBJ_FROM_PTR(mp_globals_get()), MP_OBJ_NEW_QSTR(MP_QSTR___main__));
290 291
        }
        #endif
292
        mp_map_t *globals_map = &mp_globals_get()->map;
293 294 295
        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);

296
#if DEBUG_PRINT
297
        DEBUG_printf("Current module/package: ");
298
        mp_obj_print(this_name_q, PRINT_REPR);
299
        DEBUG_printf(", is_package: %d", is_pkg);
300
        DEBUG_printf("\n");
301
#endif
302

303
        size_t this_name_l;
304
        const char *this_name = mp_obj_str_get_data(this_name_q, &this_name_l);
305

306 307 308 309 310 311 312 313 314
        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);
        }

        while (level--) {
            chop_component(this_name, &p);
315 316
        }

317 318 319
        // We must have some component left over to import from
        if (p == this_name) {
            mp_raise_ValueError("cannot perform relative import");
320 321
        }

322
        uint new_mod_l = (mod_len == 0 ? (size_t)(p - this_name) : (size_t)(p - this_name) + 1 + mod_len);
323
        char *new_mod = mp_local_alloc(new_mod_l);
324 325 326 327 328 329 330
        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);
331
        mp_local_free(new_mod);
332
        DEBUG_printf("Resolved base name for relative import: '%s'\n", qstr_str(new_mod_q));
333
        module_name = MP_OBJ_NEW_QSTR(new_mod_q);
334
        mod_str = qstr_str(new_mod_q);
335 336
        mod_len = new_mod_l;
    }
337

338
    // check if module already exists
339 340
    qstr module_name_qstr = mp_obj_str_get_qstr(module_name);
    mp_obj_t module_obj = mp_module_get(module_name_qstr);
341
    if (module_obj != MP_OBJ_NULL) {
342
        DEBUG_printf("Module already loaded\n");
343 344 345 346 347
        // If it's not a package, return module right away
        char *p = strchr(mod_str, '.');
        if (p == NULL) {
            return module_obj;
        }
348 349 350 351
        // If fromlist is not empty, return leaf module
        if (fromtuple != mp_const_none) {
            return module_obj;
        }
352 353
        // Otherwise, we need to return top-level package
        qstr pkg_name = qstr_from_strn(mod_str, p - mod_str);
354
        return mp_module_get(pkg_name);
355
    }
356
    DEBUG_printf("Module not yet loaded\n");
357 358

    uint last = 0;
359
    VSTR_FIXED(path, MICROPY_ALLOC_PATH_MAX)
360
    module_obj = MP_OBJ_NULL;
361 362
    mp_obj_t top_module_obj = MP_OBJ_NULL;
    mp_obj_t outer_module_obj = MP_OBJ_NULL;
363 364 365 366 367
    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);
368
            DEBUG_printf("Processing module: %s\n", qstr_str(mod_name));
369
            DEBUG_printf("Previous path: =%.*s=\n", vstr_len(&path), vstr_str(&path));
370 371 372

            // find the file corresponding to the module name
            mp_import_stat_t stat;
373
            if (vstr_len(&path) == 0) {
374
                // first module in the dotted-name; search for a directory or file
375
                stat = find_file(mod_str, i, &path);
376 377
            } else {
                // latter module in the dotted-name; append to path
378 379 380
                vstr_add_char(&path, PATH_SEP_CHAR);
                vstr_add_strn(&path, mod_str + last, i - last);
                stat = stat_dir_or_file(&path);
381
            }
382
            DEBUG_printf("Current path: %.*s\n", vstr_len(&path), vstr_str(&path));
383 384

            if (stat == MP_IMPORT_STAT_NO_EXIST) {
385 386 387
                #if MICROPY_MODULE_WEAK_LINKS
                // check if there is a weak link to this module
                if (i == mod_len) {
388
                    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);
389 390 391 392 393
                    if (el == NULL) {
                        goto no_exist;
                    }
                    // found weak linked module
                    module_obj = el->value;
394
                    mp_module_call_init(mod_name, module_obj);
395 396 397 398 399 400
                } else {
                    no_exist:
                #else
                {
                #endif
                    // couldn't find the file, so fail
401
                    #if MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE
402
                        mp_raise_msg(&mp_type_ImportError, "module not found");
403
                    #else
404
                        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError,
405
                            "no module named '%q'", mod_name));
406
                    #endif
407 408 409 410
                }
            } else {
                // found the file, so get the module
                module_obj = mp_module_get(mod_name);
411 412 413 414 415 416 417
            }

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

                module_obj = mp_obj_new_module(mod_name);

418 419
                // if args[3] (fromtuple) has magic value False, set up
                // this module for command-line "-m" option (set module's
420 421 422 423 424 425 426
                // name to __main__ instead of real name). Do this only
                // for *modules* however - packages never have their names
                // replaced, instead they're -m'ed using a special __main__
                // submodule in them. (This all apparently is done to not
                // touch package name itself, which is important for future
                // imports).
                if (i == mod_len && fromtuple == mp_const_false && stat != MP_IMPORT_STAT_DIR) {
427 428
                    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__));
429
                    #if MICROPY_CPYTHON_COMPAT
430
                    // Store module as "__main__" in the dictionary of loaded modules (returned by sys.modules).
431
                    mp_obj_dict_store(MP_OBJ_FROM_PTR(&MP_STATE_VM(mp_loaded_modules_dict)), MP_OBJ_NEW_QSTR(MP_QSTR___main__), module_obj);
Ville Skyttä's avatar
Ville Skyttä committed
432
                    // Store real name in "__main__" attribute. Chosen semi-randonly, to reuse existing qstr's.
433
                    mp_obj_dict_store(MP_OBJ_FROM_PTR(o->globals), MP_OBJ_NEW_QSTR(MP_QSTR___main__), MP_OBJ_NEW_QSTR(mod_name));
434
                    #endif
435 436
                }

437
                if (stat == MP_IMPORT_STAT_DIR) {
438
                    DEBUG_printf("%.*s is dir\n", vstr_len(&path), vstr_str(&path));
439
                    // https://docs.python.org/3/reference/import.html
440
                    // "Specifically, any module that contains a __path__ attribute is considered a package."
441
                    mp_store_attr(module_obj, MP_QSTR___path__, mp_obj_new_str(vstr_str(&path), vstr_len(&path)));
442
                    size_t orig_path_len = path.len;
443 444
                    vstr_add_char(&path, PATH_SEP_CHAR);
                    vstr_add_str(&path, "__init__.py");
445
                    if (stat_file_py_or_mpy(&path) != MP_IMPORT_STAT_FILE) {
446
                        //mp_warning("%s is imported as namespace package", vstr_str(&path));
447 448
                    } else {
                        do_load(module_obj, &path);
449
                    }
450
                    path.len = orig_path_len;
451
                } else { // MP_IMPORT_STAT_FILE
452
                    do_load(module_obj, &path);
453 454 455 456
                    // This should be the last component in the import path.  If there are
                    // remaining components then it's an ImportError because the current path
                    // (the module that was just loaded) is not a package.  This will be caught
                    // on the next iteration because the file will not exist.
457 458
                }
            }
459 460
            if (outer_module_obj != MP_OBJ_NULL) {
                qstr s = qstr_from_strn(mod_str + last, i - last);
Damien George's avatar
Damien George committed
461
                mp_store_attr(outer_module_obj, s, module_obj);
462 463 464 465 466 467
            }
            outer_module_obj = module_obj;
            if (top_module_obj == MP_OBJ_NULL) {
                top_module_obj = module_obj;
            }
            last = i + 1;
468 469 470
        }
    }

471 472 473 474 475
    // If fromlist is not empty, return leaf module
    if (fromtuple != mp_const_none) {
        return module_obj;
    }
    // Otherwise, we need to return top-level package
476
    return top_module_obj;
477
}
478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514

#else // MICROPY_ENABLE_EXTERNAL_IMPORT

mp_obj_t mp_builtin___import__(size_t n_args, const mp_obj_t *args) {
    // Check that it's not a relative import
    if (n_args >= 5 && MP_OBJ_SMALL_INT_VALUE(args[4]) != 0) {
        mp_raise_NotImplementedError("relative import");
    }

    // Check if module already exists, and return it if it does
    qstr module_name_qstr = mp_obj_str_get_qstr(args[0]);
    mp_obj_t module_obj = mp_module_get(module_name_qstr);
    if (module_obj != MP_OBJ_NULL) {
        return module_obj;
    }

    #if MICROPY_MODULE_WEAK_LINKS
    // Check if there is a weak link to this module
    mp_map_elem_t *el = mp_map_lookup((mp_map_t*)&mp_builtin_module_weak_links_map, MP_OBJ_NEW_QSTR(module_name_qstr), MP_MAP_LOOKUP);
    if (el != NULL) {
        // Found weak-linked module
        mp_module_call_init(module_name_qstr, el->value);
        return el->value;
    }
    #endif

    // Couldn't find the module, so fail
    if (MICROPY_ERROR_REPORTING == MICROPY_ERROR_REPORTING_TERSE) {
        mp_raise_msg(&mp_type_ImportError, "module not found");
    } else {
        nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ImportError,
            "no module named '%q'", module_name_qstr));
    }
}

#endif // MICROPY_ENABLE_EXTERNAL_IMPORT

515
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_builtin___import___obj, 1, 5, mp_builtin___import__);