decf8e6a8b
The STATIC macro was introduced a very long time ago in commit d5df6cd44a433d6253a61cb0f987835fbc06b2de. The original reason for this was to have the option to define it to nothing so that all static functions become global functions and therefore visible to certain debug tools, so one could do function size comparison and other things. This STATIC feature is rarely (if ever) used. And with the use of LTO and heavy inline optimisation, analysing the size of individual functions when they are not static is not a good representation of the size of code when fully optimised. So the macro does not have much use and it's simpler to just remove it. Then you know exactly what it's doing. For example, newcomers don't have to learn what the STATIC macro is and why it exists. Reading the code is also less "loud" with a lowercase static. One other minor point in favour of removing it, is that it stops bugs with `STATIC inline`, which should always be `static inline`. Methodology for this commit was: 1) git ls-files | egrep '\.[ch]$' | \ xargs sed -Ei "s/(^| )STATIC($| )/\1static\2/" 2) Do some manual cleanup in the diff by searching for the word STATIC in comments and changing those back. 3) "git-grep STATIC docs/", manually fixed those cases. 4) "rg -t python STATIC", manually fixed codegen lines that used STATIC. This work was funded through GitHub Sponsors. Signed-off-by: Angus Gratton <angus@redyak.com.au>
85 lines
3.6 KiB
C
85 lines
3.6 KiB
C
// Include MicroPython API.
|
|
#include "py/runtime.h"
|
|
|
|
// Define example_package.foo.bar.f()
|
|
static mp_obj_t example_package_foo_bar_f(void) {
|
|
mp_printf(&mp_plat_print, "example_package.foo.bar.f\n");
|
|
return mp_const_none;
|
|
}
|
|
static MP_DEFINE_CONST_FUN_OBJ_0(example_package_foo_bar_f_obj, example_package_foo_bar_f);
|
|
|
|
// Define all attributes of the second-level sub-package (example_package.foo.bar).
|
|
static const mp_rom_map_elem_t example_package_foo_bar_globals_table[] = {
|
|
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_example_package_dot_foo_dot_bar) },
|
|
{ MP_ROM_QSTR(MP_QSTR_f), MP_ROM_PTR(&example_package_foo_bar_f_obj) },
|
|
};
|
|
static MP_DEFINE_CONST_DICT(example_package_foo_bar_globals, example_package_foo_bar_globals_table);
|
|
|
|
// Define example_package.foo.bar module object.
|
|
const mp_obj_module_t example_package_foo_bar_user_cmodule = {
|
|
.base = { &mp_type_module },
|
|
.globals = (mp_obj_dict_t *)&example_package_foo_bar_globals,
|
|
};
|
|
|
|
// Define example_package.foo.f()
|
|
static mp_obj_t example_package_foo_f(void) {
|
|
mp_printf(&mp_plat_print, "example_package.foo.f\n");
|
|
return mp_const_none;
|
|
}
|
|
static MP_DEFINE_CONST_FUN_OBJ_0(example_package_foo_f_obj, example_package_foo_f);
|
|
|
|
// Define all attributes of the first-level sub-package (example_package.foo).
|
|
static const mp_rom_map_elem_t example_package_foo_globals_table[] = {
|
|
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_example_package_dot_foo) },
|
|
{ MP_ROM_QSTR(MP_QSTR_bar), MP_ROM_PTR(&example_package_foo_bar_user_cmodule) },
|
|
{ MP_ROM_QSTR(MP_QSTR_f), MP_ROM_PTR(&example_package_foo_f_obj) },
|
|
};
|
|
static MP_DEFINE_CONST_DICT(example_package_foo_globals, example_package_foo_globals_table);
|
|
|
|
// Define example_package.foo module object.
|
|
const mp_obj_module_t example_package_foo_user_cmodule = {
|
|
.base = { &mp_type_module },
|
|
.globals = (mp_obj_dict_t *)&example_package_foo_globals,
|
|
};
|
|
|
|
// Define example_package.f()
|
|
static mp_obj_t example_package_f(void) {
|
|
mp_printf(&mp_plat_print, "example_package.f\n");
|
|
return mp_const_none;
|
|
}
|
|
static MP_DEFINE_CONST_FUN_OBJ_0(example_package_f_obj, example_package_f);
|
|
|
|
static mp_obj_t example_package___init__(void) {
|
|
if (!MP_STATE_VM(example_package_initialised)) {
|
|
// __init__ for builtins is called each time the module is imported,
|
|
// so ensure that initialisation only happens once.
|
|
MP_STATE_VM(example_package_initialised) = true;
|
|
mp_printf(&mp_plat_print, "example_package.__init__\n");
|
|
}
|
|
return mp_const_none;
|
|
}
|
|
static MP_DEFINE_CONST_FUN_OBJ_0(example_package___init___obj, example_package___init__);
|
|
|
|
// The "initialised" state is stored on mp_state so that it is cleared on soft
|
|
// reset.
|
|
MP_REGISTER_ROOT_POINTER(int example_package_initialised);
|
|
|
|
// Define all attributes of the top-level package (example_package).
|
|
static const mp_rom_map_elem_t example_package_globals_table[] = {
|
|
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_example_package) },
|
|
{ MP_ROM_QSTR(MP_QSTR___init__), MP_ROM_PTR(&example_package___init___obj) },
|
|
{ MP_ROM_QSTR(MP_QSTR_foo), MP_ROM_PTR(&example_package_foo_user_cmodule) },
|
|
{ MP_ROM_QSTR(MP_QSTR_f), MP_ROM_PTR(&example_package_f_obj) },
|
|
};
|
|
static MP_DEFINE_CONST_DICT(example_package_globals, example_package_globals_table);
|
|
|
|
// Define module object.
|
|
const mp_obj_module_t example_package_user_cmodule = {
|
|
.base = { &mp_type_module },
|
|
.globals = (mp_obj_dict_t *)&example_package_globals,
|
|
};
|
|
|
|
// Register the module to make it available in Python.
|
|
// Note: subpackages should not be registered with MP_REGISTER_MODULE.
|
|
MP_REGISTER_MODULE(MP_QSTR_example_package, example_package_user_cmodule);
|