all: Remove the "STATIC" macro and just use "static" instead.

The STATIC macro was introduced a very long time ago in commit
d5df6cd.  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 <[email protected]>

docs/develop/compiler.rst

@@ -98,7 +98,7 @@ Then also edit ``py/lexer.c`` to add the new keyword literal text:
 .. code-block:: c
    :emphasize-lines: 12
 
-   STATIC const char *const tok_kw[] = {
+   static const char *const tok_kw[] = {
        ...
        "or",
        "pass",
@@ -301,7 +301,7 @@ code statement:
 
 .. code-block:: c
 
-   STATIC void emit_native_unary_op(emit_t *emit, mp_unary_op_t op) {
+   static void emit_native_unary_op(emit_t *emit, mp_unary_op_t op) {
         vtype_kind_t vtype;
         emit_pre_pop_reg(emit, &vtype, REG_ARG_2);
         if (vtype == VTYPE_PYOBJ) {

docs/develop/library.rst

@@ -48,16 +48,16 @@ hypothetical new module ``subsystem`` in the file ``modsubsystem.c``:
    #if MICROPY_PY_SUBSYSTEM
 
    // info()
-   STATIC mp_obj_t py_subsystem_info(void) {
+   static mp_obj_t py_subsystem_info(void) {
        return MP_OBJ_NEW_SMALL_INT(42);
    }
    MP_DEFINE_CONST_FUN_OBJ_0(subsystem_info_obj, py_subsystem_info);
 
-   STATIC const mp_rom_map_elem_t mp_module_subsystem_globals_table[] = {
+   static const mp_rom_map_elem_t mp_module_subsystem_globals_table[] = {
        { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_subsystem) },
        { MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&subsystem_info_obj) },
    };
-   STATIC MP_DEFINE_CONST_DICT(mp_module_subsystem_globals, mp_module_subsystem_globals_table);
+   static MP_DEFINE_CONST_DICT(mp_module_subsystem_globals, mp_module_subsystem_globals_table);
 
    const mp_obj_module_t mp_module_subsystem = {
        .base = { &mp_type_module },

docs/develop/natmod.rst

@@ -128,15 +128,15 @@ The file ``factorial.c`` contains:
     #include "py/dynruntime.h"
 
     // Helper function to compute factorial
-    STATIC mp_int_t factorial_helper(mp_int_t x) {
+    static mp_int_t factorial_helper(mp_int_t x) {
         if (x == 0) {
             return 1;
         }
         return x * factorial_helper(x - 1);
     }
 
     // This is the function which will be called from Python, as factorial(x)
-    STATIC mp_obj_t factorial(mp_obj_t x_obj) {
+    static mp_obj_t factorial(mp_obj_t x_obj) {
         // Extract the integer from the MicroPython input object
         mp_int_t x = mp_obj_get_int(x_obj);
         // Calculate the factorial
@@ -145,7 +145,7 @@ The file ``factorial.c`` contains:
         return mp_obj_new_int(result);
     }
     // Define a Python reference to the function above
-    STATIC MP_DEFINE_CONST_FUN_OBJ_1(factorial_obj, factorial);
+    static MP_DEFINE_CONST_FUN_OBJ_1(factorial_obj, factorial);
 
     // This is the entry point and is called when the module is imported
     mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {

docs/develop/porting.rst

@@ -262,17 +262,17 @@ To add a custom module like ``myport``, first add the module definition in a fil
 
    #include "py/runtime.h"
 
-   STATIC mp_obj_t myport_info(void) {
+   static mp_obj_t myport_info(void) {
        mp_printf(&mp_plat_print, "info about my port\n");
        return mp_const_none;
    }
-   STATIC MP_DEFINE_CONST_FUN_OBJ_0(myport_info_obj, myport_info);
+   static MP_DEFINE_CONST_FUN_OBJ_0(myport_info_obj, myport_info);
 
-   STATIC const mp_rom_map_elem_t myport_module_globals_table[] = {
+   static const mp_rom_map_elem_t myport_module_globals_table[] = {
        { MP_OBJ_NEW_QSTR(MP_QSTR___name__), MP_OBJ_NEW_QSTR(MP_QSTR_myport) },
        { MP_ROM_QSTR(MP_QSTR_info), MP_ROM_PTR(&myport_info_obj) },
    };
-   STATIC MP_DEFINE_CONST_DICT(myport_module_globals, myport_module_globals_table);
+   static MP_DEFINE_CONST_DICT(myport_module_globals, myport_module_globals_table);
 
    const mp_obj_module_t myport_module = {
        .base = { &mp_type_module },

drivers/bus/softqspi.c

@@ -49,14 +49,14 @@
 
 #endif
 
-STATIC void nibble_write(mp_soft_qspi_obj_t *self, uint8_t v) {
+static void nibble_write(mp_soft_qspi_obj_t *self, uint8_t v) {
     mp_hal_pin_write(self->io0, v & 1);
     mp_hal_pin_write(self->io1, (v >> 1) & 1);
     mp_hal_pin_write(self->io2, (v >> 2) & 1);
     mp_hal_pin_write(self->io3, (v >> 3) & 1);
 }
 
-STATIC int mp_soft_qspi_ioctl(void *self_in, uint32_t cmd) {
+static int mp_soft_qspi_ioctl(void *self_in, uint32_t cmd) {
     mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
 
     switch (cmd) {
@@ -80,7 +80,7 @@ STATIC int mp_soft_qspi_ioctl(void *self_in, uint32_t cmd) {
     return 0; // success
 }
 
-STATIC void mp_soft_qspi_transfer(mp_soft_qspi_obj_t *self, size_t len, const uint8_t *src, uint8_t *dest) {
+static void mp_soft_qspi_transfer(mp_soft_qspi_obj_t *self, size_t len, const uint8_t *src, uint8_t *dest) {
     // Will run as fast as possible, limited only by CPU speed and GPIO time
     mp_hal_pin_input(self->io1);
     mp_hal_pin_output(self->io0);
@@ -119,7 +119,7 @@ STATIC void mp_soft_qspi_transfer(mp_soft_qspi_obj_t *self, size_t len, const ui
     }
 }
 
-STATIC void mp_soft_qspi_qread(mp_soft_qspi_obj_t *self, size_t len, uint8_t *buf) {
+static void mp_soft_qspi_qread(mp_soft_qspi_obj_t *self, size_t len, uint8_t *buf) {
     // Make all IO lines input
     mp_hal_pin_input(self->io2);
     mp_hal_pin_input(self->io3);
@@ -137,7 +137,7 @@ STATIC void mp_soft_qspi_qread(mp_soft_qspi_obj_t *self, size_t len, uint8_t *bu
     }
 }
 
-STATIC void mp_soft_qspi_qwrite(mp_soft_qspi_obj_t *self, size_t len, const uint8_t *buf) {
+static void mp_soft_qspi_qwrite(mp_soft_qspi_obj_t *self, size_t len, const uint8_t *buf) {
     // Make all IO lines output
     mp_hal_pin_output(self->io2);
     mp_hal_pin_output(self->io3);
@@ -158,7 +158,7 @@ STATIC void mp_soft_qspi_qwrite(mp_soft_qspi_obj_t *self, size_t len, const uint
     //mp_hal_pin_input(self->io1);
 }
 
-STATIC int mp_soft_qspi_write_cmd_data(void *self_in, uint8_t cmd, size_t len, uint32_t data) {
+static int mp_soft_qspi_write_cmd_data(void *self_in, uint8_t cmd, size_t len, uint32_t data) {
     mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
     uint32_t cmd_buf = cmd | data << 8;
     CS_LOW(self);
@@ -167,7 +167,7 @@ STATIC int mp_soft_qspi_write_cmd_data(void *self_in, uint8_t cmd, size_t len, u
     return 0;
 }
 
-STATIC int mp_soft_qspi_write_cmd_addr_data(void *self_in, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src) {
+static int mp_soft_qspi_write_cmd_addr_data(void *self_in, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src) {
     mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
     uint8_t cmd_buf[5] = {cmd};
     uint8_t addr_len = mp_spi_set_addr_buff(&cmd_buf[1], addr);
@@ -178,7 +178,7 @@ STATIC int mp_soft_qspi_write_cmd_addr_data(void *self_in, uint8_t cmd, uint32_t
     return 0;
 }
 
-STATIC int mp_soft_qspi_read_cmd(void *self_in, uint8_t cmd, size_t len, uint32_t *dest) {
+static int mp_soft_qspi_read_cmd(void *self_in, uint8_t cmd, size_t len, uint32_t *dest) {
     mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
     uint32_t cmd_buf = cmd;
     CS_LOW(self);
@@ -188,7 +188,7 @@ STATIC int mp_soft_qspi_read_cmd(void *self_in, uint8_t cmd, size_t len, uint32_
     return 0;
 }
 
-STATIC int mp_soft_qspi_read_cmd_qaddr_qdata(void *self_in, uint8_t cmd, uint32_t addr, size_t len, uint8_t *dest) {
+static int mp_soft_qspi_read_cmd_qaddr_qdata(void *self_in, uint8_t cmd, uint32_t addr, size_t len, uint8_t *dest) {
     mp_soft_qspi_obj_t *self = (mp_soft_qspi_obj_t*)self_in;
     uint8_t cmd_buf[7] = {cmd};
     uint8_t addr_len = mp_spi_set_addr_buff(&cmd_buf[1], addr);

drivers/cyw43/cywbt.c

@@ -51,7 +51,7 @@ extern uint8_t mp_bluetooth_hci_cmd_buf[4 + 256];
 // Provided by the port.
 extern machine_uart_obj_t mp_bluetooth_hci_uart_obj;
 
-STATIC void cywbt_wait_cts_low(void) {
+static void cywbt_wait_cts_low(void) {
     mp_hal_pin_config(CYW43_PIN_BT_CTS, MP_HAL_PIN_MODE_INPUT, MP_HAL_PIN_PULL_UP, 0);
     for (int i = 0; i < 200; ++i) {
         if (mp_hal_pin_read(CYW43_PIN_BT_CTS) == 0) {
@@ -64,7 +64,7 @@ STATIC void cywbt_wait_cts_low(void) {
 }
 #endif
 
-STATIC int cywbt_hci_cmd_raw(size_t len, uint8_t *buf) {
+static int cywbt_hci_cmd_raw(size_t len, uint8_t *buf) {
     mp_bluetooth_hci_uart_write((void *)buf, len);
     for (int c, i = 0; i < 6; ++i) {
         while ((c = mp_bluetooth_hci_uart_readchar()) == -1) {
@@ -96,7 +96,7 @@ STATIC int cywbt_hci_cmd_raw(size_t len, uint8_t *buf) {
     return 0;
 }
 
-STATIC int cywbt_hci_cmd(int ogf, int ocf, size_t param_len, const uint8_t *param_buf) {
+static int cywbt_hci_cmd(int ogf, int ocf, size_t param_len, const uint8_t *param_buf) {
     uint8_t *buf = mp_bluetooth_hci_cmd_buf;
     buf[0] = 0x01;
     buf[1] = ocf;
@@ -108,27 +108,27 @@ STATIC int cywbt_hci_cmd(int ogf, int ocf, size_t param_len, const uint8_t *para
     return cywbt_hci_cmd_raw(4 + param_len, buf);
 }
 
-STATIC void put_le16(uint8_t *buf, uint16_t val) {
+static void put_le16(uint8_t *buf, uint16_t val) {
     buf[0] = val;
     buf[1] = val >> 8;
 }
 
-STATIC void put_le32(uint8_t *buf, uint32_t val) {
+static void put_le32(uint8_t *buf, uint32_t val) {
     buf[0] = val;
     buf[1] = val >> 8;
     buf[2] = val >> 16;
     buf[3] = val >> 24;
 }
 
-STATIC int cywbt_set_baudrate(uint32_t baudrate) {
+static int cywbt_set_baudrate(uint32_t baudrate) {
     uint8_t buf[6];
     put_le16(buf, 0);
     put_le32(buf + 2, baudrate);
     return cywbt_hci_cmd(0x3f, 0x18, 6, buf);
 }
 
 // download firmware
-STATIC int cywbt_download_firmware(const uint8_t *firmware) {
+static int cywbt_download_firmware(const uint8_t *firmware) {
     cywbt_hci_cmd(0x3f, 0x2e, 0, NULL);
 
     bool last_packet = false;
@@ -255,7 +255,7 @@ int mp_bluetooth_hci_controller_deinit(void) {
 }
 
 #ifdef CYW43_PIN_BT_DEV_WAKE
-STATIC uint32_t bt_sleep_ticks;
+static uint32_t bt_sleep_ticks;
 #endif
 
 int mp_bluetooth_hci_controller_sleep_maybe(void) {

drivers/dht/dht.c

@@ -40,7 +40,7 @@
 #define mp_hal_pin_od_high_dht mp_hal_pin_od_high
 #endif
 
-STATIC mp_obj_t dht_readinto(mp_obj_t pin_in, mp_obj_t buf_in) {
+static mp_obj_t dht_readinto(mp_obj_t pin_in, mp_obj_t buf_in) {
     mp_hal_pin_obj_t pin = mp_hal_get_pin_obj(pin_in);
     mp_hal_pin_open_drain(pin);
 

drivers/esp-hosted/esp_hosted_hal.c

@@ -44,14 +44,14 @@
 
 extern void mod_network_poll_events(void);
 
-STATIC mp_obj_t esp_hosted_pin_irq_callback(mp_obj_t self_in) {
+static mp_obj_t esp_hosted_pin_irq_callback(mp_obj_t self_in) {
     #ifdef MICROPY_HW_WIFI_LED
     led_toggle(MICROPY_HW_WIFI_LED);
     #endif
     mod_network_poll_events();
     return mp_const_none;
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_1(esp_hosted_pin_irq_callback_obj, esp_hosted_pin_irq_callback);
+static MP_DEFINE_CONST_FUN_OBJ_1(esp_hosted_pin_irq_callback_obj, esp_hosted_pin_irq_callback);
 
 MP_WEAK int esp_hosted_hal_init(uint32_t mode) {
     // Perform a hard reset and set pins to their defaults.

drivers/memory/spiflash.c

@@ -56,21 +56,21 @@
 #define PAGE_SIZE (256) // maximum bytes we can write in one SPI transfer
 #define SECTOR_SIZE MP_SPIFLASH_ERASE_BLOCK_SIZE
 
-STATIC void mp_spiflash_acquire_bus(mp_spiflash_t *self) {
+static void mp_spiflash_acquire_bus(mp_spiflash_t *self) {
     const mp_spiflash_config_t *c = self->config;
     if (c->bus_kind == MP_SPIFLASH_BUS_QSPI) {
         c->bus.u_qspi.proto->ioctl(c->bus.u_qspi.data, MP_QSPI_IOCTL_BUS_ACQUIRE);
     }
 }
 
-STATIC void mp_spiflash_release_bus(mp_spiflash_t *self) {
+static void mp_spiflash_release_bus(mp_spiflash_t *self) {
     const mp_spiflash_config_t *c = self->config;
     if (c->bus_kind == MP_SPIFLASH_BUS_QSPI) {
         c->bus.u_qspi.proto->ioctl(c->bus.u_qspi.data, MP_QSPI_IOCTL_BUS_RELEASE);
     }
 }
 
-STATIC int mp_spiflash_write_cmd_data(mp_spiflash_t *self, uint8_t cmd, size_t len, uint32_t data) {
+static int mp_spiflash_write_cmd_data(mp_spiflash_t *self, uint8_t cmd, size_t len, uint32_t data) {
     int ret = 0;
     const mp_spiflash_config_t *c = self->config;
     if (c->bus_kind == MP_SPIFLASH_BUS_SPI) {
@@ -84,7 +84,7 @@ STATIC int mp_spiflash_write_cmd_data(mp_spiflash_t *self, uint8_t cmd, size_t l
     return ret;
 }
 
-STATIC int mp_spiflash_transfer_cmd_addr_data(mp_spiflash_t *self, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src, uint8_t *dest) {
+static int mp_spiflash_transfer_cmd_addr_data(mp_spiflash_t *self, uint8_t cmd, uint32_t addr, size_t len, const uint8_t *src, uint8_t *dest) {
     int ret = 0;
     const mp_spiflash_config_t *c = self->config;
     if (c->bus_kind == MP_SPIFLASH_BUS_SPI) {
@@ -109,7 +109,7 @@ STATIC int mp_spiflash_transfer_cmd_addr_data(mp_spiflash_t *self, uint8_t cmd,
     return ret;
 }
 
-STATIC int mp_spiflash_read_cmd(mp_spiflash_t *self, uint8_t cmd, size_t len, uint32_t *dest) {
+static int mp_spiflash_read_cmd(mp_spiflash_t *self, uint8_t cmd, size_t len, uint32_t *dest) {
     const mp_spiflash_config_t *c = self->config;
     if (c->bus_kind == MP_SPIFLASH_BUS_SPI) {
         mp_hal_pin_write(c->bus.u_spi.cs, 0);
@@ -122,7 +122,7 @@ STATIC int mp_spiflash_read_cmd(mp_spiflash_t *self, uint8_t cmd, size_t len, ui
     }
 }
 
-STATIC int mp_spiflash_read_data(mp_spiflash_t *self, uint32_t addr, size_t len, uint8_t *dest) {
+static int mp_spiflash_read_data(mp_spiflash_t *self, uint32_t addr, size_t len, uint8_t *dest) {
     const mp_spiflash_config_t *c = self->config;
     uint8_t cmd;
     if (c->bus_kind == MP_SPIFLASH_BUS_SPI) {
@@ -133,11 +133,11 @@ STATIC int mp_spiflash_read_data(mp_spiflash_t *self, uint32_t addr, size_t len,
     return mp_spiflash_transfer_cmd_addr_data(self, cmd, addr, len, NULL, dest);
 }
 
-STATIC int mp_spiflash_write_cmd(mp_spiflash_t *self, uint8_t cmd) {
+static int mp_spiflash_write_cmd(mp_spiflash_t *self, uint8_t cmd) {
     return mp_spiflash_write_cmd_data(self, cmd, 0, 0);
 }
 
-STATIC int mp_spiflash_wait_sr(mp_spiflash_t *self, uint8_t mask, uint8_t val, uint32_t timeout) {
+static int mp_spiflash_wait_sr(mp_spiflash_t *self, uint8_t mask, uint8_t val, uint32_t timeout) {
     do {
         uint32_t sr;
         int ret = mp_spiflash_read_cmd(self, CMD_RDSR, 1, &sr);
@@ -152,11 +152,11 @@ STATIC int mp_spiflash_wait_sr(mp_spiflash_t *self, uint8_t mask, uint8_t val, u
     return -MP_ETIMEDOUT;
 }
 
-STATIC int mp_spiflash_wait_wel1(mp_spiflash_t *self) {
+static int mp_spiflash_wait_wel1(mp_spiflash_t *self) {
     return mp_spiflash_wait_sr(self, 2, 2, WAIT_SR_TIMEOUT);
 }
 
-STATIC int mp_spiflash_wait_wip0(mp_spiflash_t *self) {
+static int mp_spiflash_wait_wip0(mp_spiflash_t *self) {
     return mp_spiflash_wait_sr(self, 1, 0, WAIT_SR_TIMEOUT);
 }
 
@@ -219,7 +219,7 @@ void mp_spiflash_deepsleep(mp_spiflash_t *self, int value) {
     }
 }
 
-STATIC int mp_spiflash_erase_block_internal(mp_spiflash_t *self, uint32_t addr) {
+static int mp_spiflash_erase_block_internal(mp_spiflash_t *self, uint32_t addr) {
     int ret = 0;
     // enable writes
     ret = mp_spiflash_write_cmd(self, CMD_WREN);
@@ -244,7 +244,7 @@ STATIC int mp_spiflash_erase_block_internal(mp_spiflash_t *self, uint32_t addr)
     return mp_spiflash_wait_wip0(self);
 }
 
-STATIC int mp_spiflash_write_page(mp_spiflash_t *self, uint32_t addr, size_t len, const uint8_t *src) {
+static int mp_spiflash_write_page(mp_spiflash_t *self, uint32_t addr, size_t len, const uint8_t *src) {
     int ret = 0;
     // enable writes
     ret = mp_spiflash_write_cmd(self, CMD_WREN);
@@ -361,7 +361,7 @@ int mp_spiflash_cached_read(mp_spiflash_t *self, uint32_t addr, size_t len, uint
     return ret;
 }
 
-STATIC int mp_spiflash_cache_flush_internal(mp_spiflash_t *self) {
+static int mp_spiflash_cache_flush_internal(mp_spiflash_t *self) {
     #if USE_WR_DELAY
     if (!(self->flags & 1)) {
         return 0;
@@ -396,7 +396,7 @@ int mp_spiflash_cache_flush(mp_spiflash_t *self) {
     return ret;
 }
 
-STATIC int mp_spiflash_cached_write_part(mp_spiflash_t *self, uint32_t addr, size_t len, const uint8_t *src) {
+static int mp_spiflash_cached_write_part(mp_spiflash_t *self, uint32_t addr, size_t len, const uint8_t *src) {
     // Align to 4096 sector
     uint32_t offset = addr & 0xfff;
     uint32_t sec = addr >> 12;

examples/natmod/btree/btree_c.c

@@ -100,9 +100,9 @@ mp_getiter_iternext_custom_t btree_getiter_iternext;
 #include "extmod/modbtree.c"
 
 mp_map_elem_t btree_locals_dict_table[8];
-STATIC MP_DEFINE_CONST_DICT(btree_locals_dict, btree_locals_dict_table);
+static MP_DEFINE_CONST_DICT(btree_locals_dict, btree_locals_dict_table);
 
-STATIC mp_obj_t btree_open(size_t n_args, const mp_obj_t *args) {
+static mp_obj_t btree_open(size_t n_args, const mp_obj_t *args) {
     // Make sure we got a stream object
     mp_get_stream_raise(args[0], MP_STREAM_OP_READ | MP_STREAM_OP_WRITE | MP_STREAM_OP_IOCTL);
 
@@ -118,7 +118,7 @@ STATIC mp_obj_t btree_open(size_t n_args, const mp_obj_t *args) {
 
     return MP_OBJ_FROM_PTR(btree_new(db, args[0]));
 }
-STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(btree_open_obj, 5, 5, btree_open);
+static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(btree_open_obj, 5, 5, btree_open);
 
 mp_obj_t mpy_init(mp_obj_fun_bc_t *self, size_t n_args, size_t n_kw, mp_obj_t *args) {
     MP_DYNRUNTIME_INIT_ENTRY