TonBERRY/micropython
3
0
Fork 0
Code Pull Requests Activity

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

Browse Source 
The STATIC macro was introduced a very long time ago in commit
d5df6cd44a.  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>
This commit is contained in:
Angus Gratton
2024-02-27 15:32:29 +11:00
committed by Damien George
parent b3f2f18f92
commit decf8e6a8b
482 changed files with 6287 additions and 6293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
ports/unix/coverage.c
View File

@@ -31,7 +31,7 @@ typedef struct _mp_obj_streamtest_t {
int error_code;
} mp_obj_streamtest_t;
STATIC mp_obj_t stest_set_buf(mp_obj_t o_in, mp_obj_t buf_in) {
static mp_obj_t stest_set_buf(mp_obj_t o_in, mp_obj_t buf_in) {
mp_obj_streamtest_t *o = MP_OBJ_TO_PTR(o_in);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(buf_in, &bufinfo, MP_BUFFER_READ);
@@ -41,16 +41,16 @@ STATIC mp_obj_t stest_set_buf(mp_obj_t o_in, mp_obj_t buf_in) {
o->pos = 0;
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(stest_set_buf_obj, stest_set_buf);
static MP_DEFINE_CONST_FUN_OBJ_2(stest_set_buf_obj, stest_set_buf);
STATIC mp_obj_t stest_set_error(mp_obj_t o_in, mp_obj_t err_in) {
static mp_obj_t stest_set_error(mp_obj_t o_in, mp_obj_t err_in) {
mp_obj_streamtest_t *o = MP_OBJ_TO_PTR(o_in);
o->error_code = mp_obj_get_int(err_in);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(stest_set_error_obj, stest_set_error);
static MP_DEFINE_CONST_FUN_OBJ_2(stest_set_error_obj, stest_set_error);
STATIC mp_uint_t stest_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
static mp_uint_t stest_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
mp_obj_streamtest_t *o = MP_OBJ_TO_PTR(o_in);
if (o->pos < o->len) {
if (size > o->len - o->pos) {
@@ -67,7 +67,7 @@ STATIC mp_uint_t stest_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errco
}
}
STATIC mp_uint_t stest_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
static mp_uint_t stest_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
mp_obj_streamtest_t *o = MP_OBJ_TO_PTR(o_in);
(void)buf;
(void)size;
@@ -75,7 +75,7 @@ STATIC mp_uint_t stest_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int
return MP_STREAM_ERROR;
}
STATIC mp_uint_t stest_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
static mp_uint_t stest_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
mp_obj_streamtest_t *o = MP_OBJ_TO_PTR(o_in);
(void)arg;
(void)request;
@@ -87,7 +87,7 @@ STATIC mp_uint_t stest_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, in
return 0;
}
STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
static const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_set_buf), MP_ROM_PTR(&stest_set_buf_obj) },
{ MP_ROM_QSTR(MP_QSTR_set_error), MP_ROM_PTR(&stest_set_error_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
@@ -99,15 +99,15 @@ STATIC const mp_rom_map_elem_t rawfile_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_ioctl), MP_ROM_PTR(&mp_stream_ioctl_obj) },
};
STATIC MP_DEFINE_CONST_DICT(rawfile_locals_dict, rawfile_locals_dict_table);
static MP_DEFINE_CONST_DICT(rawfile_locals_dict, rawfile_locals_dict_table);
STATIC const mp_stream_p_t fileio_stream_p = {
static const mp_stream_p_t fileio_stream_p = {
.read = stest_read,
.write = stest_write,
.ioctl = stest_ioctl,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
mp_type_stest_fileio,
MP_QSTR_stest_fileio,
MP_TYPE_FLAG_NONE,
@@ -116,7 +116,7 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
);
// stream read returns non-blocking error
STATIC mp_uint_t stest_read2(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
static mp_uint_t stest_read2(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
(void)o_in;
(void)buf;
(void)size;
@@ -124,19 +124,19 @@ STATIC mp_uint_t stest_read2(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
return MP_STREAM_ERROR;
}
STATIC const mp_rom_map_elem_t rawfile_locals_dict_table2[] = {
static const mp_rom_map_elem_t rawfile_locals_dict_table2[] = {
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
};
STATIC MP_DEFINE_CONST_DICT(rawfile_locals_dict2, rawfile_locals_dict_table2);
static MP_DEFINE_CONST_DICT(rawfile_locals_dict2, rawfile_locals_dict_table2);
STATIC const mp_stream_p_t textio_stream_p2 = {
static const mp_stream_p_t textio_stream_p2 = {
.read = stest_read2,
.write = NULL,
.is_text = true,
};
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
mp_type_stest_textio2,
MP_QSTR_stest_textio2,
MP_TYPE_FLAG_NONE,
@@ -145,15 +145,15 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
);
// str/bytes objects without a valid hash
STATIC const mp_obj_str_t str_no_hash_obj = {{&mp_type_str}, 0, 10, (const byte *)"0123456789"};
STATIC const mp_obj_str_t bytes_no_hash_obj = {{&mp_type_bytes}, 0, 10, (const byte *)"0123456789"};
static const mp_obj_str_t str_no_hash_obj = {{&mp_type_str}, 0, 10, (const byte *)"0123456789"};
static const mp_obj_str_t bytes_no_hash_obj = {{&mp_type_bytes}, 0, 10, (const byte *)"0123456789"};
STATIC int pairheap_lt(mp_pairheap_t *a, mp_pairheap_t *b) {
static int pairheap_lt(mp_pairheap_t *a, mp_pairheap_t *b) {
return (uintptr_t)a < (uintptr_t)b;
}
// ops array contain operations: x>=0 means push(x), x<0 means delete(-x)
STATIC void pairheap_test(size_t nops, int *ops) {
static void pairheap_test(size_t nops, int *ops) {
mp_pairheap_t node[8];
for (size_t i = 0; i < MP_ARRAY_SIZE(node); ++i) {
mp_pairheap_init_node(pairheap_lt, &node[i]);
@@ -183,7 +183,7 @@ STATIC void pairheap_test(size_t nops, int *ops) {
}
// function to run extra tests for things that can't be checked by scripts
STATIC mp_obj_t extra_coverage(void) {
static mp_obj_t extra_coverage(void) {
// mp_printf (used by ports that don't have a native printf)
{
mp_printf(&mp_plat_print, "# mp_printf\n");

2
ports/unix/coveragecpp.cpp
View File

@@ -5,7 +5,7 @@ extern "C" {
#if defined(MICROPY_UNIX_COVERAGE)
// Just to test building of C++ code.
STATIC mp_obj_t extra_cpp_coverage_impl() {
static mp_obj_t extra_cpp_coverage_impl() {
return mp_const_none;
}

30
ports/unix/main.c
View File

@@ -55,8 +55,8 @@
#include "input.h"
// Command line options, with their defaults
STATIC bool compile_only = false;
STATIC uint emit_opt = MP_EMIT_OPT_NONE;
static bool compile_only = false;
static uint emit_opt = MP_EMIT_OPT_NONE;
#if MICROPY_ENABLE_GC
// Heap size of GC heap (if enabled)
@@ -77,7 +77,7 @@ long heap_size = 1024 * 1024 * (sizeof(mp_uint_t) / 4);
#error "The unix port requires MICROPY_PY_SYS_ARGV=1"
#endif
STATIC void stderr_print_strn(void *env, const char *str, size_t len) {
static void stderr_print_strn(void *env, const char *str, size_t len) {
(void)env;
ssize_t ret;
MP_HAL_RETRY_SYSCALL(ret, write(STDERR_FILENO, str, len), {});
@@ -90,7 +90,7 @@ const mp_print_t mp_stderr_print = {NULL, stderr_print_strn};
// If exc is SystemExit, return value where FORCED_EXIT bit set,
// and lower 8 bits are SystemExit value. For all other exceptions,
// return 1.
STATIC int handle_uncaught_exception(mp_obj_base_t *exc) {
static int handle_uncaught_exception(mp_obj_base_t *exc) {
// check for SystemExit
if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(exc->type), MP_OBJ_FROM_PTR(&mp_type_SystemExit))) {
// None is an exit value of 0; an int is its value; anything else is 1
@@ -115,7 +115,7 @@ STATIC int handle_uncaught_exception(mp_obj_base_t *exc) {
// Returns standard error codes: 0 for success, 1 for all other errors,
// except if FORCED_EXIT bit is set then script raised SystemExit and the
// value of the exit is in the lower 8 bits of the return value
STATIC int execute_from_lexer(int source_kind, const void *source, mp_parse_input_kind_t input_kind, bool is_repl) {
static int execute_from_lexer(int source_kind, const void *source, mp_parse_input_kind_t input_kind, bool is_repl) {
mp_hal_set_interrupt_char(CHAR_CTRL_C);
nlr_buf_t nlr;
@@ -177,7 +177,7 @@ STATIC int execute_from_lexer(int source_kind, const void *source, mp_parse_inpu
#if MICROPY_USE_READLINE == 1
#include "shared/readline/readline.h"
#else
STATIC char *strjoin(const char *s1, int sep_char, const char *s2) {
static char *strjoin(const char *s1, int sep_char, const char *s2) {
int l1 = strlen(s1);
int l2 = strlen(s2);
char *s = malloc(l1 + l2 + 2);
@@ -192,7 +192,7 @@ STATIC char *strjoin(const char *s1, int sep_char, const char *s2) {
}
#endif
STATIC int do_repl(void) {
static int do_repl(void) {
mp_hal_stdout_tx_str(MICROPY_BANNER_NAME_AND_VERSION);
mp_hal_stdout_tx_str("; " MICROPY_BANNER_MACHINE);
mp_hal_stdout_tx_str("\nUse Ctrl-D to exit, Ctrl-E for paste mode\n");
@@ -306,15 +306,15 @@ STATIC int do_repl(void) {
#endif
}
STATIC int do_file(const char *file) {
static int do_file(const char *file) {
return execute_from_lexer(LEX_SRC_FILENAME, file, MP_PARSE_FILE_INPUT, false);
}
STATIC int do_str(const char *str) {
static int do_str(const char *str) {
return execute_from_lexer(LEX_SRC_STR, str, MP_PARSE_FILE_INPUT, false);
}
STATIC void print_help(char **argv) {
static void print_help(char **argv) {
printf(
"usage: %s [<opts>] [-X <implopt>] [-c <command> | -m <module> | <filename>]\n"
"Options:\n"
@@ -353,13 +353,13 @@ STATIC void print_help(char **argv) {
}
}
STATIC int invalid_args(void) {
static int invalid_args(void) {
fprintf(stderr, "Invalid command line arguments. Use -h option for help.\n");
return 1;
}
// Process options which set interpreter init options
STATIC void pre_process_options(int argc, char **argv) {
static void pre_process_options(int argc, char **argv) {
for (int a = 1; a < argc; a++) {
if (argv[a][0] == '-') {
if (strcmp(argv[a], "-c") == 0 || strcmp(argv[a], "-m") == 0) {
@@ -439,7 +439,7 @@ STATIC void pre_process_options(int argc, char **argv) {
}
}
STATIC void set_sys_argv(char *argv[], int argc, int start_arg) {
static void set_sys_argv(char *argv[], int argc, int start_arg) {
for (int i = start_arg; i < argc; i++) {
mp_obj_list_append(mp_sys_argv, MP_OBJ_NEW_QSTR(qstr_from_str(argv[i])));
}
@@ -447,9 +447,9 @@ STATIC void set_sys_argv(char *argv[], int argc, int start_arg) {
#if MICROPY_PY_SYS_EXECUTABLE
extern mp_obj_str_t mp_sys_executable_obj;
STATIC char executable_path[MICROPY_ALLOC_PATH_MAX];
static char executable_path[MICROPY_ALLOC_PATH_MAX];
STATIC void sys_set_excecutable(char *argv0) {
static void sys_set_excecutable(char *argv0) {
if (realpath(argv0, executable_path)) {
mp_obj_str_set_data(&mp_sys_executable_obj, (byte *)executable_path, strlen(executable_path));
}

90
ports/unix/modffi.c
View File

@@ -107,13 +107,13 @@ typedef struct _mp_obj_fficallback_t {
ffi_type *params[];
} mp_obj_fficallback_t;
// STATIC const mp_obj_type_t opaque_type;
STATIC const mp_obj_type_t ffimod_type;
STATIC const mp_obj_type_t ffifunc_type;
STATIC const mp_obj_type_t fficallback_type;
STATIC const mp_obj_type_t ffivar_type;
// static const mp_obj_type_t opaque_type;
static const mp_obj_type_t ffimod_type;
static const mp_obj_type_t ffifunc_type;
static const mp_obj_type_t fficallback_type;
static const mp_obj_type_t ffivar_type;
STATIC ffi_type *char2ffi_type(char c) {
static ffi_type *char2ffi_type(char c) {
switch (c) {
case 'b':
return &ffi_type_schar;
@@ -154,7 +154,7 @@ STATIC ffi_type *char2ffi_type(char c) {
}
}
STATIC ffi_type *get_ffi_type(mp_obj_t o_in) {
static ffi_type *get_ffi_type(mp_obj_t o_in) {
if (mp_obj_is_str(o_in)) {
const char *s = mp_obj_str_get_str(o_in);
ffi_type *t = char2ffi_type(*s);
@@ -167,7 +167,7 @@ STATIC ffi_type *get_ffi_type(mp_obj_t o_in) {
mp_raise_TypeError(MP_ERROR_TEXT("unknown type"));
}
STATIC mp_obj_t return_ffi_value(ffi_union_t *val, char type) {
static mp_obj_t return_ffi_value(ffi_union_t *val, char type) {
switch (type) {
case 's': {
const char *s = (const char *)(intptr_t)val->ffi;
@@ -209,20 +209,20 @@ STATIC mp_obj_t return_ffi_value(ffi_union_t *val, char type) {
// FFI module
STATIC void ffimod_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
static void ffimod_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
(void)kind;
mp_obj_ffimod_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "<ffimod %p>", self->handle);
}
STATIC mp_obj_t ffimod_close(mp_obj_t self_in) {
static mp_obj_t ffimod_close(mp_obj_t self_in) {
mp_obj_ffimod_t *self = MP_OBJ_TO_PTR(self_in);
dlclose(self->handle);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(ffimod_close_obj, ffimod_close);
static MP_DEFINE_CONST_FUN_OBJ_1(ffimod_close_obj, ffimod_close);
STATIC mp_obj_t make_func(mp_obj_t rettype_in, void *func, mp_obj_t argtypes_in) {
static mp_obj_t make_func(mp_obj_t rettype_in, void *func, mp_obj_t argtypes_in) {
const char *rettype = mp_obj_str_get_str(rettype_in);
const char *argtypes = mp_obj_str_get_str(argtypes_in);
@@ -249,7 +249,7 @@ STATIC mp_obj_t make_func(mp_obj_t rettype_in, void *func, mp_obj_t argtypes_in)
return MP_OBJ_FROM_PTR(o);
}
STATIC mp_obj_t ffimod_func(size_t n_args, const mp_obj_t *args) {
static mp_obj_t ffimod_func(size_t n_args, const mp_obj_t *args) {
(void)n_args; // always 4
mp_obj_ffimod_t *self = MP_OBJ_TO_PTR(args[0]);
const char *symname = mp_obj_str_get_str(args[2]);
@@ -262,13 +262,13 @@ STATIC mp_obj_t ffimod_func(size_t n_args, const mp_obj_t *args) {
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(ffimod_func_obj, 4, 4, ffimod_func);
STATIC mp_obj_t mod_ffi_func(mp_obj_t rettype, mp_obj_t addr_in, mp_obj_t argtypes) {
static mp_obj_t mod_ffi_func(mp_obj_t rettype, mp_obj_t addr_in, mp_obj_t argtypes) {
void *addr = (void *)MP_OBJ_TO_PTR(mp_obj_int_get_truncated(addr_in));
return make_func(rettype, addr, argtypes);
}
MP_DEFINE_CONST_FUN_OBJ_3(mod_ffi_func_obj, mod_ffi_func);
STATIC void call_py_func(ffi_cif *cif, void *ret, void **args, void *user_data) {
static void call_py_func(ffi_cif *cif, void *ret, void **args, void *user_data) {
mp_obj_t pyargs[cif->nargs];
mp_obj_fficallback_t *o = user_data;
mp_obj_t pyfunc = o->pyfunc;
@@ -283,7 +283,7 @@ STATIC void call_py_func(ffi_cif *cif, void *ret, void **args, void *user_data)
}
}
STATIC void call_py_func_with_lock(ffi_cif *cif, void *ret, void **args, void *user_data) {
static void call_py_func_with_lock(ffi_cif *cif, void *ret, void **args, void *user_data) {
mp_obj_t pyargs[cif->nargs];
mp_obj_fficallback_t *o = user_data;
mp_obj_t pyfunc = o->pyfunc;
@@ -316,7 +316,7 @@ STATIC void call_py_func_with_lock(ffi_cif *cif, void *ret, void **args, void *u
#endif
}
STATIC mp_obj_t mod_ffi_callback(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
static mp_obj_t mod_ffi_callback(size_t n_args, const mp_obj_t *pos_args, mp_map_t *kw_args) {
// first 3 args are positional: retttype, func, paramtypes.
mp_obj_t rettype_in = pos_args[0];
mp_obj_t func_in = pos_args[1];
@@ -364,7 +364,7 @@ STATIC mp_obj_t mod_ffi_callback(size_t n_args, const mp_obj_t *pos_args, mp_map
}
MP_DEFINE_CONST_FUN_OBJ_KW(mod_ffi_callback_obj, 3, mod_ffi_callback);
STATIC mp_obj_t ffimod_var(mp_obj_t self_in, mp_obj_t vartype_in, mp_obj_t symname_in) {
static mp_obj_t ffimod_var(mp_obj_t self_in, mp_obj_t vartype_in, mp_obj_t symname_in) {
mp_obj_ffimod_t *self = MP_OBJ_TO_PTR(self_in);
const char *rettype = mp_obj_str_get_str(vartype_in);
const char *symname = mp_obj_str_get_str(symname_in);
@@ -381,7 +381,7 @@ STATIC mp_obj_t ffimod_var(mp_obj_t self_in, mp_obj_t vartype_in, mp_obj_t symna
}
MP_DEFINE_CONST_FUN_OBJ_3(ffimod_var_obj, ffimod_var);
STATIC mp_obj_t ffimod_addr(mp_obj_t self_in, mp_obj_t symname_in) {
static mp_obj_t ffimod_addr(mp_obj_t self_in, mp_obj_t symname_in) {
mp_obj_ffimod_t *self = MP_OBJ_TO_PTR(self_in);
const char *symname = mp_obj_str_get_str(symname_in);
@@ -393,7 +393,7 @@ STATIC mp_obj_t ffimod_addr(mp_obj_t self_in, mp_obj_t symname_in) {
}
MP_DEFINE_CONST_FUN_OBJ_2(ffimod_addr_obj, ffimod_addr);
STATIC mp_obj_t ffimod_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
static mp_obj_t ffimod_make_new(const mp_obj_type_t *type, size_t n_args, size_t n_kw, const mp_obj_t *args) {
(void)n_args;
(void)n_kw;
@@ -411,16 +411,16 @@ STATIC mp_obj_t ffimod_make_new(const mp_obj_type_t *type, size_t n_args, size_t
return MP_OBJ_FROM_PTR(o);
}
STATIC const mp_rom_map_elem_t ffimod_locals_dict_table[] = {
static const mp_rom_map_elem_t ffimod_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_func), MP_ROM_PTR(&ffimod_func_obj) },
{ MP_ROM_QSTR(MP_QSTR_var), MP_ROM_PTR(&ffimod_var_obj) },
{ MP_ROM_QSTR(MP_QSTR_addr), MP_ROM_PTR(&ffimod_addr_obj) },
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&ffimod_close_obj) },
};
STATIC MP_DEFINE_CONST_DICT(ffimod_locals_dict, ffimod_locals_dict_table);
static MP_DEFINE_CONST_DICT(ffimod_locals_dict, ffimod_locals_dict_table);
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
ffimod_type,
MP_QSTR_ffimod,
MP_TYPE_FLAG_NONE,
@@ -431,13 +431,13 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
// FFI function
STATIC void ffifunc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
static void ffifunc_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
(void)kind;
mp_obj_ffifunc_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "<ffifunc %p>", self->func);
}
STATIC unsigned long long ffi_get_int_value(mp_obj_t o) {
static unsigned long long ffi_get_int_value(mp_obj_t o) {
if (mp_obj_is_small_int(o)) {
return MP_OBJ_SMALL_INT_VALUE(o);
} else {
@@ -447,7 +447,7 @@ STATIC unsigned long long ffi_get_int_value(mp_obj_t o) {
}
}
STATIC ffi_union_t ffi_int_obj_to_ffi_union(mp_obj_t o, const char argtype) {
static ffi_union_t ffi_int_obj_to_ffi_union(mp_obj_t o, const char argtype) {
ffi_union_t ret;
if ((argtype | 0x20) == 'q') {
ret.Q = ffi_get_int_value(o);
@@ -479,7 +479,7 @@ STATIC ffi_union_t ffi_int_obj_to_ffi_union(mp_obj_t o, const char argtype) {
return ret;
}
STATIC mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
static mp_obj_t ffifunc_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
(void)n_kw;
mp_obj_ffifunc_t *self = MP_OBJ_TO_PTR(self_in);
assert(n_kw == 0);
@@ -530,7 +530,7 @@ error:
mp_raise_TypeError(MP_ERROR_TEXT("don't know how to pass object to native function"));
}
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
ffifunc_type,
MP_QSTR_ffifunc,
MP_TYPE_FLAG_NONE,
@@ -540,24 +540,24 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
// FFI callback for Python function
STATIC void fficallback_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
static void fficallback_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
(void)kind;
mp_obj_fficallback_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "<fficallback %p>", self->func);
}
STATIC mp_obj_t fficallback_cfun(mp_obj_t self_in) {
static mp_obj_t fficallback_cfun(mp_obj_t self_in) {
mp_obj_fficallback_t *self = MP_OBJ_TO_PTR(self_in);
return mp_obj_new_int_from_ull((uintptr_t)self->func);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(fficallback_cfun_obj, fficallback_cfun);
static MP_DEFINE_CONST_FUN_OBJ_1(fficallback_cfun_obj, fficallback_cfun);
STATIC const mp_rom_map_elem_t fficallback_locals_dict_table[] = {
static const mp_rom_map_elem_t fficallback_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_cfun), MP_ROM_PTR(&fficallback_cfun_obj) }
};
STATIC MP_DEFINE_CONST_DICT(fficallback_locals_dict, fficallback_locals_dict_table);
static MP_DEFINE_CONST_DICT(fficallback_locals_dict, fficallback_locals_dict_table);
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
fficallback_type,
MP_QSTR_fficallback,
MP_TYPE_FLAG_NONE,
@@ -567,34 +567,34 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
// FFI variable
STATIC void ffivar_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
static void ffivar_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
(void)kind;
mp_obj_ffivar_t *self = MP_OBJ_TO_PTR(self_in);
// Variable value printed as cast to int
mp_printf(print, "<ffivar @%p: 0x%x>", self->var, *(int *)self->var);
}
STATIC mp_obj_t ffivar_get(mp_obj_t self_in) {
static mp_obj_t ffivar_get(mp_obj_t self_in) {
mp_obj_ffivar_t *self = MP_OBJ_TO_PTR(self_in);
return mp_binary_get_val_array(self->type, self->var, 0);
}
MP_DEFINE_CONST_FUN_OBJ_1(ffivar_get_obj, ffivar_get);
STATIC mp_obj_t ffivar_set(mp_obj_t self_in, mp_obj_t val_in) {
static mp_obj_t ffivar_set(mp_obj_t self_in, mp_obj_t val_in) {
mp_obj_ffivar_t *self = MP_OBJ_TO_PTR(self_in);
mp_binary_set_val_array(self->type, self->var, 0, val_in);
return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(ffivar_set_obj, ffivar_set);
STATIC const mp_rom_map_elem_t ffivar_locals_dict_table[] = {
static const mp_rom_map_elem_t ffivar_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_get), MP_ROM_PTR(&ffivar_get_obj) },
{ MP_ROM_QSTR(MP_QSTR_set), MP_ROM_PTR(&ffivar_set_obj) },
};
STATIC MP_DEFINE_CONST_DICT(ffivar_locals_dict, ffivar_locals_dict_table);
static MP_DEFINE_CONST_DICT(ffivar_locals_dict, ffivar_locals_dict_table);
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
ffivar_type,
MP_QSTR_ffivar,
MP_TYPE_FLAG_NONE,
@@ -605,7 +605,7 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
// Generic opaque storage object (unused)
/*
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
opaque_type,
MP_QSTR_opaqueval,
MP_TYPE_FLAG_NONE,
@@ -613,17 +613,17 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
);
*/
STATIC mp_obj_t mod_ffi_open(size_t n_args, const mp_obj_t *args) {
static mp_obj_t mod_ffi_open(size_t n_args, const mp_obj_t *args) {
return ffimod_make_new(&ffimod_type, n_args, 0, args);
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_ffi_open_obj, 1, 2, mod_ffi_open);
STATIC mp_obj_t mod_ffi_as_bytearray(mp_obj_t ptr, mp_obj_t size) {
static mp_obj_t mod_ffi_as_bytearray(mp_obj_t ptr, mp_obj_t size) {
return mp_obj_new_bytearray_by_ref(mp_obj_int_get_truncated(size), (void *)(uintptr_t)mp_obj_int_get_truncated(ptr));
}
MP_DEFINE_CONST_FUN_OBJ_2(mod_ffi_as_bytearray_obj, mod_ffi_as_bytearray);
STATIC const mp_rom_map_elem_t mp_module_ffi_globals_table[] = {
static const mp_rom_map_elem_t mp_module_ffi_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_ffi) },
{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mod_ffi_open_obj) },
{ MP_ROM_QSTR(MP_QSTR_callback), MP_ROM_PTR(&mod_ffi_callback_obj) },
@@ -631,7 +631,7 @@ STATIC const mp_rom_map_elem_t mp_module_ffi_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR_as_bytearray), MP_ROM_PTR(&mod_ffi_as_bytearray_obj) },
};
STATIC MP_DEFINE_CONST_DICT(mp_module_ffi_globals, mp_module_ffi_globals_table);
static MP_DEFINE_CONST_DICT(mp_module_ffi_globals, mp_module_ffi_globals_table);
const mp_obj_module_t mp_module_ffi = {
.base = { &mp_type_module },

76
ports/unix/modjni.c
View File

@@ -59,13 +59,13 @@ static jmethodID List_size_mid;
static jclass IndexException_class;
STATIC const mp_obj_type_t jobject_type;
STATIC const mp_obj_type_t jmethod_type;
static const mp_obj_type_t jobject_type;
static const mp_obj_type_t jmethod_type;
STATIC mp_obj_t new_jobject(jobject jo);
STATIC mp_obj_t new_jclass(jclass jc);
STATIC mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool is_constr, size_t n_args, const mp_obj_t *args);
STATIC bool py2jvalue(const char **jtypesig, mp_obj_t arg, jvalue *out);
static mp_obj_t new_jobject(jobject jo);
static mp_obj_t new_jclass(jclass jc);
static mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool is_constr, size_t n_args, const mp_obj_t *args);
static bool py2jvalue(const char **jtypesig, mp_obj_t arg, jvalue *out);
typedef struct _mp_obj_jclass_t {
mp_obj_base_t base;
@@ -87,7 +87,7 @@ typedef struct _mp_obj_jmethod_t {
// Utility functions
STATIC bool is_object_type(const char *jtypesig) {
static bool is_object_type(const char *jtypesig) {
while (*jtypesig != ' ' && *jtypesig) {
if (*jtypesig == '.') {
return true;
@@ -97,7 +97,7 @@ STATIC bool is_object_type(const char *jtypesig) {
return false;
}
STATIC void check_exception(void) {
static void check_exception(void) {
jobject exc = JJ1(ExceptionOccurred);
if (exc) {
// JJ1(ExceptionDescribe);
@@ -110,7 +110,7 @@ STATIC void check_exception(void) {
}
}
STATIC void print_jobject(const mp_print_t *print, jobject obj) {
static void print_jobject(const mp_print_t *print, jobject obj) {
jobject str_o = JJ(CallObjectMethod, obj, Object_toString_mid);
const char *str = JJ(GetStringUTFChars, str_o, NULL);
mp_printf(print, str);
@@ -119,7 +119,7 @@ STATIC void print_jobject(const mp_print_t *print, jobject obj) {
// jclass
STATIC void jclass_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
static void jclass_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
mp_obj_jclass_t *self = MP_OBJ_TO_PTR(self_in);
if (kind == PRINT_REPR) {
mp_printf(print, "<jclass @%p \"", self->cls);
@@ -130,7 +130,7 @@ STATIC void jclass_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kin
}
}
STATIC void jclass_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
static void jclass_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
if (dest[0] == MP_OBJ_NULL) {
// load attribute
mp_obj_jclass_t *self = MP_OBJ_TO_PTR(self_in);
@@ -156,7 +156,7 @@ STATIC void jclass_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
}
}
STATIC mp_obj_t jclass_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
static mp_obj_t jclass_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
if (n_kw != 0) {
mp_raise_TypeError(MP_ERROR_TEXT("kwargs not supported"));
}
@@ -167,14 +167,14 @@ STATIC mp_obj_t jclass_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
return call_method(self->cls, NULL, methods, true, n_args, args);
}
STATIC const mp_rom_map_elem_t jclass_locals_dict_table[] = {
static const mp_rom_map_elem_t jclass_locals_dict_table[] = {
// { MP_ROM_QSTR(MP_QSTR_get), MP_ROM_PTR(&ffivar_get_obj) },
// { MP_ROM_QSTR(MP_QSTR_set), MP_ROM_PTR(&ffivar_set_obj) },
};
STATIC MP_DEFINE_CONST_DICT(jclass_locals_dict, jclass_locals_dict_table);
static MP_DEFINE_CONST_DICT(jclass_locals_dict, jclass_locals_dict_table);
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
jclass_type,
MP_QSTR_jclass,
MP_TYPE_FLAG_NONE,
@@ -184,7 +184,7 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
locals_dict, &jclass_locals_dict
);
STATIC mp_obj_t new_jclass(jclass jc) {
static mp_obj_t new_jclass(jclass jc) {
mp_obj_jclass_t *o = mp_obj_malloc(mp_obj_jclass_t, &jclass_type);
o->cls = jc;
return MP_OBJ_FROM_PTR(o);
@@ -192,7 +192,7 @@ STATIC mp_obj_t new_jclass(jclass jc) {
// jobject
STATIC void jobject_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
static void jobject_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
mp_obj_jobject_t *self = MP_OBJ_TO_PTR(self_in);
if (kind == PRINT_REPR) {
mp_printf(print, "<jobject @%p \"", self->obj);
@@ -203,7 +203,7 @@ STATIC void jobject_print(const mp_print_t *print, mp_obj_t self_in, mp_print_ki
}
}
STATIC void jobject_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
static void jobject_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
if (dest[0] == MP_OBJ_NULL) {
// load attribute
mp_obj_jobject_t *self = MP_OBJ_TO_PTR(self_in);
@@ -233,7 +233,7 @@ STATIC void jobject_attr(mp_obj_t self_in, qstr attr_in, mp_obj_t *dest) {
}
}
STATIC void get_jclass_name(jobject obj, char *buf) {
static void get_jclass_name(jobject obj, char *buf) {
jclass obj_class = JJ(GetObjectClass, obj);
jstring name = JJ(CallObjectMethod, obj_class, Class_getName_mid);
jint len = JJ(GetStringLength, name);
@@ -241,7 +241,7 @@ STATIC void get_jclass_name(jobject obj, char *buf) {
check_exception();
}
STATIC mp_obj_t jobject_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
static mp_obj_t jobject_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
mp_obj_jobject_t *self = MP_OBJ_TO_PTR(self_in);
mp_uint_t idx = mp_obj_get_int(index);
char class_name[64];
@@ -291,7 +291,7 @@ STATIC mp_obj_t jobject_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value)
return MP_OBJ_NULL;
}
STATIC mp_obj_t jobject_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
static mp_obj_t jobject_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
mp_obj_jobject_t *self = MP_OBJ_TO_PTR(self_in);
switch (op) {
case MP_UNARY_OP_BOOL:
@@ -309,19 +309,19 @@ STATIC mp_obj_t jobject_unary_op(mp_unary_op_t op, mp_obj_t self_in) {
// TODO: subscr_load_adaptor & subscr_getiter convenience functions
// should be moved to common location for reuse.
STATIC mp_obj_t subscr_load_adaptor(mp_obj_t self_in, mp_obj_t index_in) {
static mp_obj_t subscr_load_adaptor(mp_obj_t self_in, mp_obj_t index_in) {
return mp_obj_subscr(self_in, index_in, MP_OBJ_SENTINEL);
}
MP_DEFINE_CONST_FUN_OBJ_2(subscr_load_adaptor_obj, subscr_load_adaptor);
// .getiter special method which returns iterator which works in terms
// of object subscription.
STATIC mp_obj_t subscr_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
static mp_obj_t subscr_getiter(mp_obj_t self_in, mp_obj_iter_buf_t *iter_buf) {
mp_obj_t dest[2] = {MP_OBJ_FROM_PTR(&subscr_load_adaptor_obj), self_in};
return mp_obj_new_getitem_iter(dest, iter_buf);
}
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
jobject_type,
MP_QSTR_jobject,
MP_TYPE_FLAG_ITER_IS_GETITER,
@@ -332,7 +332,7 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
iter, subscr_getiter
);
STATIC mp_obj_t new_jobject(jobject jo) {
static mp_obj_t new_jobject(jobject jo) {
if (jo == NULL) {
return mp_const_none;
} else if (JJ(IsInstanceOf, jo, String_class)) {
@@ -353,7 +353,7 @@ STATIC mp_obj_t new_jobject(jobject jo) {
// jmethod
STATIC void jmethod_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
static void jmethod_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
(void)kind;
mp_obj_jmethod_t *self = MP_OBJ_TO_PTR(self_in);
// Variable value printed as cast to int
@@ -368,14 +368,14 @@ STATIC void jmethod_print(const mp_print_t *print, mp_obj_t self_in, mp_print_ki
} \
arg_type += sizeof(java_type_name) - 1;
STATIC const char *strprev(const char *s, char c) {
static const char *strprev(const char *s, char c) {
while (*s != c) {
s--;
}
return s;
}
STATIC bool py2jvalue(const char **jtypesig, mp_obj_t arg, jvalue *out) {
static bool py2jvalue(const char **jtypesig, mp_obj_t arg, jvalue *out) {
const char *arg_type = *jtypesig;
const mp_obj_type_t *type = mp_obj_get_type(arg);
@@ -442,7 +442,7 @@ STATIC bool py2jvalue(const char **jtypesig, mp_obj_t arg, jvalue *out) {
// perspective, it's aggregate object which may require passing via stack
// instead of registers. Work that around by passing jobject and typecasting
// it.
STATIC mp_obj_t jvalue2py(const char *jtypesig, jobject arg) {
static mp_obj_t jvalue2py(const char *jtypesig, jobject arg) {
if (arg == NULL || MATCH(jtypesig, "void")) {
return mp_const_none;
} else if (MATCH(jtypesig, "boolean")) {
@@ -460,7 +460,7 @@ STATIC mp_obj_t jvalue2py(const char *jtypesig, jobject arg) {
}
#endif
STATIC mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool is_constr, size_t n_args, const mp_obj_t *args) {
static mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool is_constr, size_t n_args, const mp_obj_t *args) {
jvalue jargs[n_args];
// printf("methods=%p\n", methods);
jsize num_methods = JJ(GetArrayLength, methods);
@@ -550,7 +550,7 @@ STATIC mp_obj_t call_method(jobject obj, const char *name, jarray methods, bool
}
STATIC mp_obj_t jmethod_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
static mp_obj_t jmethod_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
if (n_kw != 0) {
mp_raise_TypeError(MP_ERROR_TEXT("kwargs not supported"));
}
@@ -568,7 +568,7 @@ STATIC mp_obj_t jmethod_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const
return call_method(self->obj, name, methods, false, n_args, args);
}
STATIC MP_DEFINE_CONST_OBJ_TYPE(
static MP_DEFINE_CONST_OBJ_TYPE(
jmethod_type,
MP_QSTR_jmethod,
MP_TYPE_FLAG_NONE,
@@ -582,7 +582,7 @@ STATIC MP_DEFINE_CONST_OBJ_TYPE(
#define LIBJVM_SO "libjvm.so"
#endif
STATIC void create_jvm(void) {
static void create_jvm(void) {
JavaVMInitArgs args;
JavaVMOption options;
options.optionString = "-Djava.class.path=.";
@@ -635,7 +635,7 @@ STATIC void create_jvm(void) {
IndexException_class = JJ(FindClass, "java/lang/IndexOutOfBoundsException");
}
STATIC mp_obj_t mod_jni_cls(mp_obj_t cls_name_in) {
static mp_obj_t mod_jni_cls(mp_obj_t cls_name_in) {
const char *cls_name = mp_obj_str_get_str(cls_name_in);
if (!env) {
create_jvm();
@@ -648,7 +648,7 @@ STATIC mp_obj_t mod_jni_cls(mp_obj_t cls_name_in) {
}
MP_DEFINE_CONST_FUN_OBJ_1(mod_jni_cls_obj, mod_jni_cls);
STATIC mp_obj_t mod_jni_array(mp_obj_t type_in, mp_obj_t size_in) {
static mp_obj_t mod_jni_array(mp_obj_t type_in, mp_obj_t size_in) {
if (!env) {
create_jvm();
}
@@ -696,19 +696,19 @@ STATIC mp_obj_t mod_jni_array(mp_obj_t type_in, mp_obj_t size_in) {
MP_DEFINE_CONST_FUN_OBJ_2(mod_jni_array_obj, mod_jni_array);
STATIC mp_obj_t mod_jni_env(void) {
static mp_obj_t mod_jni_env(void) {
return mp_obj_new_int((mp_int_t)(uintptr_t)env);
}
MP_DEFINE_CONST_FUN_OBJ_0(mod_jni_env_obj, mod_jni_env);
STATIC const mp_rom_map_elem_t mp_module_jni_globals_table[] = {
static const mp_rom_map_elem_t mp_module_jni_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_jni) },
{ MP_ROM_QSTR(MP_QSTR_cls), MP_ROM_PTR(&mod_jni_cls_obj) },
{ MP_ROM_QSTR(MP_QSTR_array), MP_ROM_PTR(&mod_jni_array_obj) },
{ MP_ROM_QSTR(MP_QSTR_env), MP_ROM_PTR(&mod_jni_env_obj) },
};
STATIC MP_DEFINE_CONST_DICT(mp_module_jni_globals, mp_module_jni_globals_table);
static MP_DEFINE_CONST_DICT(mp_module_jni_globals, mp_module_jni_globals_table);
const mp_obj_module_t mp_module_jni = {
.base = { &mp_type_module },

2
ports/unix/modmachine.c
View File

@@ -70,7 +70,7 @@ uintptr_t mod_machine_mem_get_addr(mp_obj_t addr_o, uint align) {
return addr;
}
STATIC void mp_machine_idle(void) {
static void mp_machine_idle(void) {
#ifdef MICROPY_UNIX_MACHINE_IDLE
MICROPY_UNIX_MACHINE_IDLE
#else

24
ports/unix/modos.c
View File

@@ -32,7 +32,7 @@
#include "py/runtime.h"
#include "py/mphal.h"
STATIC mp_obj_t mp_os_getenv(size_t n_args, const mp_obj_t *args) {
static mp_obj_t mp_os_getenv(size_t n_args, const mp_obj_t *args) {
const char *s = getenv(mp_obj_str_get_str(args[0]));
if (s == NULL) {
if (n_args == 2) {
@@ -42,9 +42,9 @@ STATIC mp_obj_t mp_os_getenv(size_t n_args, const mp_obj_t *args) {
}
return mp_obj_new_str(s, strlen(s));
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_os_getenv_obj, 1, 2, mp_os_getenv);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_os_getenv_obj, 1, 2, mp_os_getenv);
STATIC mp_obj_t mp_os_putenv(mp_obj_t key_in, mp_obj_t value_in) {
static mp_obj_t mp_os_putenv(mp_obj_t key_in, mp_obj_t value_in) {
const char *key = mp_obj_str_get_str(key_in);
const char *value = mp_obj_str_get_str(value_in);
int ret;
@@ -60,9 +60,9 @@ STATIC mp_obj_t mp_os_putenv(mp_obj_t key_in, mp_obj_t value_in) {
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(mp_os_putenv_obj, mp_os_putenv);
static MP_DEFINE_CONST_FUN_OBJ_2(mp_os_putenv_obj, mp_os_putenv);
STATIC mp_obj_t mp_os_unsetenv(mp_obj_t key_in) {
static mp_obj_t mp_os_unsetenv(mp_obj_t key_in) {
const char *key = mp_obj_str_get_str(key_in);
int ret;
@@ -77,9 +77,9 @@ STATIC mp_obj_t mp_os_unsetenv(mp_obj_t key_in) {
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_os_unsetenv_obj, mp_os_unsetenv);
static MP_DEFINE_CONST_FUN_OBJ_1(mp_os_unsetenv_obj, mp_os_unsetenv);
STATIC mp_obj_t mp_os_system(mp_obj_t cmd_in) {
static mp_obj_t mp_os_system(mp_obj_t cmd_in) {
const char *cmd = mp_obj_str_get_str(cmd_in);
MP_THREAD_GIL_EXIT();
@@ -90,18 +90,18 @@ STATIC mp_obj_t mp_os_system(mp_obj_t cmd_in) {
return MP_OBJ_NEW_SMALL_INT(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_os_system_obj, mp_os_system);
static MP_DEFINE_CONST_FUN_OBJ_1(mp_os_system_obj, mp_os_system);
STATIC mp_obj_t mp_os_urandom(mp_obj_t num) {
static mp_obj_t mp_os_urandom(mp_obj_t num) {
mp_int_t n = mp_obj_get_int(num);
vstr_t vstr;
vstr_init_len(&vstr, n);
mp_hal_get_random(n, vstr.buf);
return mp_obj_new_bytes_from_vstr(&vstr);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mp_os_urandom_obj, mp_os_urandom);
static MP_DEFINE_CONST_FUN_OBJ_1(mp_os_urandom_obj, mp_os_urandom);
STATIC mp_obj_t mp_os_errno(size_t n_args, const mp_obj_t *args) {
static mp_obj_t mp_os_errno(size_t n_args, const mp_obj_t *args) {
if (n_args == 0) {
return MP_OBJ_NEW_SMALL_INT(errno);
}
@@ -109,4 +109,4 @@ STATIC mp_obj_t mp_os_errno(size_t n_args, const mp_obj_t *args) {
errno = mp_obj_get_int(args[0]);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_os_errno_obj, 0, 1, mp_os_errno);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_os_errno_obj, 0, 1, mp_os_errno);

90
ports/unix/modsocket.c
View File

@@ -82,7 +82,7 @@ static inline mp_obj_t mp_obj_from_sockaddr(const struct sockaddr *addr, socklen
return mp_obj_new_bytes((const byte *)addr, len);
}
STATIC mp_obj_socket_t *socket_new(int fd) {
static mp_obj_socket_t *socket_new(int fd) {
mp_obj_socket_t *o = mp_obj_malloc(mp_obj_socket_t, &mp_type_socket);
o->fd = fd;
o->blocking = true;
@@ -90,13 +90,13 @@ STATIC mp_obj_socket_t *socket_new(int fd) {
}
STATIC void socket_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
static void socket_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
(void)kind;
mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
mp_printf(print, "<_socket %d>", self->fd);
}
STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
static mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errcode) {
mp_obj_socket_t *o = MP_OBJ_TO_PTR(o_in);
ssize_t r;
MP_HAL_RETRY_SYSCALL(r, read(o->fd, buf, size), {
@@ -112,7 +112,7 @@ STATIC mp_uint_t socket_read(mp_obj_t o_in, void *buf, mp_uint_t size, int *errc
return (mp_uint_t)r;
}
STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
static mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, int *errcode) {
mp_obj_socket_t *o = MP_OBJ_TO_PTR(o_in);
ssize_t r;
MP_HAL_RETRY_SYSCALL(r, write(o->fd, buf, size), {
@@ -128,7 +128,7 @@ STATIC mp_uint_t socket_write(mp_obj_t o_in, const void *buf, mp_uint_t size, in
return (mp_uint_t)r;
}
STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
static mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, int *errcode) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(o_in);
(void)arg;
switch (request) {
@@ -186,13 +186,13 @@ STATIC mp_uint_t socket_ioctl(mp_obj_t o_in, mp_uint_t request, uintptr_t arg, i
}
}
STATIC mp_obj_t socket_fileno(mp_obj_t self_in) {
static mp_obj_t socket_fileno(mp_obj_t self_in) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
return MP_OBJ_NEW_SMALL_INT(self->fd);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_fileno_obj, socket_fileno);
static MP_DEFINE_CONST_FUN_OBJ_1(socket_fileno_obj, socket_fileno);
STATIC mp_obj_t socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
static mp_obj_t socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(addr_in, &bufinfo, MP_BUFFER_READ);
@@ -220,9 +220,9 @@ STATIC mp_obj_t socket_connect(mp_obj_t self_in, mp_obj_t addr_in) {
return mp_const_none;
}
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
static MP_DEFINE_CONST_FUN_OBJ_2(socket_connect_obj, socket_connect);
STATIC mp_obj_t socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
static mp_obj_t socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(addr_in, &bufinfo, MP_BUFFER_READ);
@@ -232,10 +232,10 @@ STATIC mp_obj_t socket_bind(mp_obj_t self_in, mp_obj_t addr_in) {
RAISE_ERRNO(r, errno);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_bind_obj, socket_bind);
static MP_DEFINE_CONST_FUN_OBJ_2(socket_bind_obj, socket_bind);
// method socket.listen([backlog])
STATIC mp_obj_t socket_listen(size_t n_args, const mp_obj_t *args) {
static mp_obj_t socket_listen(size_t n_args, const mp_obj_t *args) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(args[0]);
int backlog = MICROPY_PY_SOCKET_LISTEN_BACKLOG_DEFAULT;
@@ -250,9 +250,9 @@ STATIC mp_obj_t socket_listen(size_t n_args, const mp_obj_t *args) {
RAISE_ERRNO(r, errno);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_listen_obj, 1, 2, socket_listen);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_listen_obj, 1, 2, socket_listen);
STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
static mp_obj_t socket_accept(mp_obj_t self_in) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
// sockaddr_storage isn't stack-friendly (129 bytes or so)
// struct sockaddr_storage addr;
@@ -273,12 +273,12 @@ STATIC mp_obj_t socket_accept(mp_obj_t self_in) {
return MP_OBJ_FROM_PTR(t);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(socket_accept_obj, socket_accept);
static MP_DEFINE_CONST_FUN_OBJ_1(socket_accept_obj, socket_accept);
// Note: besides flag param, this differs from read() in that
// this does not swallow blocking errors (EAGAIN, EWOULDBLOCK) -
// these would be thrown as exceptions.
STATIC mp_obj_t socket_recv(size_t n_args, const mp_obj_t *args) {
static mp_obj_t socket_recv(size_t n_args, const mp_obj_t *args) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(args[0]);
int sz = MP_OBJ_SMALL_INT_VALUE(args[1]);
int flags = 0;
@@ -294,9 +294,9 @@ STATIC mp_obj_t socket_recv(size_t n_args, const mp_obj_t *args) {
m_del(char, buf, sz);
return ret;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_recv_obj, 2, 3, socket_recv);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_recv_obj, 2, 3, socket_recv);
STATIC mp_obj_t socket_recvfrom(size_t n_args, const mp_obj_t *args) {
static mp_obj_t socket_recvfrom(size_t n_args, const mp_obj_t *args) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(args[0]);
int sz = MP_OBJ_SMALL_INT_VALUE(args[1]);
int flags = 0;
@@ -321,12 +321,12 @@ STATIC mp_obj_t socket_recvfrom(size_t n_args, const mp_obj_t *args) {
return MP_OBJ_FROM_PTR(t);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_recvfrom_obj, 2, 3, socket_recvfrom);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_recvfrom_obj, 2, 3, socket_recvfrom);
// Note: besides flag param, this differs from write() in that
// this does not swallow blocking errors (EAGAIN, EWOULDBLOCK) -
// these would be thrown as exceptions.
STATIC mp_obj_t socket_send(size_t n_args, const mp_obj_t *args) {
static mp_obj_t socket_send(size_t n_args, const mp_obj_t *args) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(args[0]);
int flags = 0;
@@ -341,9 +341,9 @@ STATIC mp_obj_t socket_send(size_t n_args, const mp_obj_t *args) {
mp_raise_OSError(err));
return MP_OBJ_NEW_SMALL_INT(out_sz);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_send_obj, 2, 3, socket_send);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_send_obj, 2, 3, socket_send);
STATIC mp_obj_t socket_sendto(size_t n_args, const mp_obj_t *args) {
static mp_obj_t socket_sendto(size_t n_args, const mp_obj_t *args) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(args[0]);
int flags = 0;
@@ -361,9 +361,9 @@ STATIC mp_obj_t socket_sendto(size_t n_args, const mp_obj_t *args) {
(struct sockaddr *)addr_bi.buf, addr_bi.len), mp_raise_OSError(err));
return MP_OBJ_NEW_SMALL_INT(out_sz);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_sendto_obj, 3, 4, socket_sendto);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_sendto_obj, 3, 4, socket_sendto);
STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
static mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
(void)n_args; // always 4
mp_obj_socket_t *self = MP_OBJ_TO_PTR(args[0]);
int level = MP_OBJ_SMALL_INT_VALUE(args[1]);
@@ -388,9 +388,9 @@ STATIC mp_obj_t socket_setsockopt(size_t n_args, const mp_obj_t *args) {
RAISE_ERRNO(r, errno);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_setsockopt);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_setsockopt_obj, 4, 4, socket_setsockopt);
STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
static mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
int val = mp_obj_is_true(flag_in);
MP_THREAD_GIL_EXIT();
@@ -410,9 +410,9 @@ STATIC mp_obj_t socket_setblocking(mp_obj_t self_in, mp_obj_t flag_in) {
self->blocking = val;
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
static MP_DEFINE_CONST_FUN_OBJ_2(socket_setblocking_obj, socket_setblocking);
STATIC mp_obj_t socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
static mp_obj_t socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
mp_obj_socket_t *self = MP_OBJ_TO_PTR(self_in);
struct timeval tv = {0, };
bool new_blocking = true;
@@ -455,9 +455,9 @@ STATIC mp_obj_t socket_settimeout(mp_obj_t self_in, mp_obj_t timeout_in) {
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(socket_settimeout_obj, socket_settimeout);
static MP_DEFINE_CONST_FUN_OBJ_2(socket_settimeout_obj, socket_settimeout);
STATIC mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args) {
static mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args) {
// TODO: CPython explicitly says that closing returned object doesn't close
// the original socket (Python2 at all says that fd is dup()ed). But we
// save on the bloat.
@@ -467,9 +467,9 @@ STATIC mp_obj_t socket_makefile(size_t n_args, const mp_obj_t *args) {
new_args[0] = MP_OBJ_NEW_SMALL_INT(self->fd);
return mp_vfs_open(n_args, new_args, (mp_map_t *)&mp_const_empty_map);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 3, socket_makefile);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(socket_makefile_obj, 1, 3, socket_makefile);
STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
static mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
(void)type_in;
(void)n_kw;
@@ -497,7 +497,7 @@ STATIC mp_obj_t socket_make_new(const mp_obj_type_t *type_in, size_t n_args, siz
return MP_OBJ_FROM_PTR(socket_new(fd));
}
STATIC const mp_rom_map_elem_t socket_locals_dict_table[] = {
static const mp_rom_map_elem_t socket_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_fileno), MP_ROM_PTR(&socket_fileno_obj) },
{ MP_ROM_QSTR(MP_QSTR_makefile), MP_ROM_PTR(&socket_makefile_obj) },
{ MP_ROM_QSTR(MP_QSTR_read), MP_ROM_PTR(&mp_stream_read_obj) },
@@ -518,9 +518,9 @@ STATIC const mp_rom_map_elem_t socket_locals_dict_table[] = {
{ MP_ROM_QSTR(MP_QSTR_close), MP_ROM_PTR(&mp_stream_close_obj) },
};
STATIC MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
static MP_DEFINE_CONST_DICT(socket_locals_dict, socket_locals_dict_table);
STATIC const mp_stream_p_t socket_stream_p = {
static const mp_stream_p_t socket_stream_p = {
.read = socket_read,
.write = socket_write,
.ioctl = socket_ioctl,
@@ -537,7 +537,7 @@ MP_DEFINE_CONST_OBJ_TYPE(
);
#define BINADDR_MAX_LEN sizeof(struct in6_addr)
STATIC mp_obj_t mod_socket_inet_pton(mp_obj_t family_in, mp_obj_t addr_in) {
static mp_obj_t mod_socket_inet_pton(mp_obj_t family_in, mp_obj_t addr_in) {
int family = mp_obj_get_int(family_in);
byte binaddr[BINADDR_MAX_LEN];
int r = inet_pton(family, mp_obj_str_get_str(addr_in), binaddr);
@@ -556,9 +556,9 @@ STATIC mp_obj_t mod_socket_inet_pton(mp_obj_t family_in, mp_obj_t addr_in) {
}
return mp_obj_new_bytes(binaddr, binaddr_len);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_socket_inet_pton_obj, mod_socket_inet_pton);
static MP_DEFINE_CONST_FUN_OBJ_2(mod_socket_inet_pton_obj, mod_socket_inet_pton);
STATIC mp_obj_t mod_socket_inet_ntop(mp_obj_t family_in, mp_obj_t binaddr_in) {
static mp_obj_t mod_socket_inet_ntop(mp_obj_t family_in, mp_obj_t binaddr_in) {
int family = mp_obj_get_int(family_in);
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(binaddr_in, &bufinfo, MP_BUFFER_READ);
@@ -570,9 +570,9 @@ STATIC mp_obj_t mod_socket_inet_ntop(mp_obj_t family_in, mp_obj_t binaddr_in) {
vstr.len = strlen(vstr.buf);
return mp_obj_new_str_from_utf8_vstr(&vstr);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_2(mod_socket_inet_ntop_obj, mod_socket_inet_ntop);
static MP_DEFINE_CONST_FUN_OBJ_2(mod_socket_inet_ntop_obj, mod_socket_inet_ntop);
STATIC mp_obj_t mod_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
static mp_obj_t mod_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
const char *host = mp_obj_str_get_str(args[0]);
const char *serv = NULL;
@@ -647,9 +647,9 @@ STATIC mp_obj_t mod_socket_getaddrinfo(size_t n_args, const mp_obj_t *args) {
freeaddrinfo(addr_list);
return list;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_socket_getaddrinfo_obj, 2, 6, mod_socket_getaddrinfo);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_socket_getaddrinfo_obj, 2, 6, mod_socket_getaddrinfo);
STATIC mp_obj_t mod_socket_sockaddr(mp_obj_t sockaddr_in) {
static mp_obj_t mod_socket_sockaddr(mp_obj_t sockaddr_in) {
mp_buffer_info_t bufinfo;
mp_get_buffer_raise(sockaddr_in, &bufinfo, MP_BUFFER_READ);
switch (((struct sockaddr *)bufinfo.buf)->sa_family) {
@@ -681,9 +681,9 @@ STATIC mp_obj_t mod_socket_sockaddr(mp_obj_t sockaddr_in) {
}
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_socket_sockaddr_obj, mod_socket_sockaddr);
static MP_DEFINE_CONST_FUN_OBJ_1(mod_socket_sockaddr_obj, mod_socket_sockaddr);
STATIC const mp_rom_map_elem_t mp_module_socket_globals_table[] = {
static const mp_rom_map_elem_t mp_module_socket_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_socket) },
{ MP_ROM_QSTR(MP_QSTR_socket), MP_ROM_PTR(&mp_type_socket) },
{ MP_ROM_QSTR(MP_QSTR_getaddrinfo), MP_ROM_PTR(&mod_socket_getaddrinfo_obj) },
@@ -711,7 +711,7 @@ STATIC const mp_rom_map_elem_t mp_module_socket_globals_table[] = {
#undef C
};
STATIC MP_DEFINE_CONST_DICT(mp_module_socket_globals, mp_module_socket_globals_table);
static MP_DEFINE_CONST_DICT(mp_module_socket_globals, mp_module_socket_globals_table);
const mp_obj_module_t mp_module_socket = {
.base = { &mp_type_module },

16
ports/unix/modtermios.c
View File

@@ -35,7 +35,7 @@
#include "py/runtime.h"
#include "py/mphal.h"
STATIC mp_obj_t mod_termios_tcgetattr(mp_obj_t fd_in) {
static mp_obj_t mod_termios_tcgetattr(mp_obj_t fd_in) {
struct termios term;
int fd = mp_obj_get_int(fd_in);
@@ -65,9 +65,9 @@ STATIC mp_obj_t mod_termios_tcgetattr(mp_obj_t fd_in) {
}
return MP_OBJ_FROM_PTR(r);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_termios_tcgetattr_obj, mod_termios_tcgetattr);
static MP_DEFINE_CONST_FUN_OBJ_1(mod_termios_tcgetattr_obj, mod_termios_tcgetattr);
STATIC mp_obj_t mod_termios_tcsetattr(mp_obj_t fd_in, mp_obj_t when_in, mp_obj_t attrs_in) {
static mp_obj_t mod_termios_tcsetattr(mp_obj_t fd_in, mp_obj_t when_in, mp_obj_t attrs_in) {
struct termios term;
int fd = mp_obj_get_int(fd_in);
int when = mp_obj_get_int(when_in);
@@ -105,9 +105,9 @@ STATIC mp_obj_t mod_termios_tcsetattr(mp_obj_t fd_in, mp_obj_t when_in, mp_obj_t
RAISE_ERRNO(res, errno);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_3(mod_termios_tcsetattr_obj, mod_termios_tcsetattr);
static MP_DEFINE_CONST_FUN_OBJ_3(mod_termios_tcsetattr_obj, mod_termios_tcsetattr);
STATIC mp_obj_t mod_termios_setraw(mp_obj_t fd_in) {
static mp_obj_t mod_termios_setraw(mp_obj_t fd_in) {
struct termios term;
int fd = mp_obj_get_int(fd_in);
int res = tcgetattr(fd, &term);
@@ -123,9 +123,9 @@ STATIC mp_obj_t mod_termios_setraw(mp_obj_t fd_in) {
RAISE_ERRNO(res, errno);
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(mod_termios_setraw_obj, mod_termios_setraw);
static MP_DEFINE_CONST_FUN_OBJ_1(mod_termios_setraw_obj, mod_termios_setraw);
STATIC const mp_rom_map_elem_t mp_module_termios_globals_table[] = {
static const mp_rom_map_elem_t mp_module_termios_globals_table[] = {
{ MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_termios) },
{ MP_ROM_QSTR(MP_QSTR_tcgetattr), MP_ROM_PTR(&mod_termios_tcgetattr_obj) },
{ MP_ROM_QSTR(MP_QSTR_tcsetattr), MP_ROM_PTR(&mod_termios_tcsetattr_obj) },
@@ -144,7 +144,7 @@ STATIC const mp_rom_map_elem_t mp_module_termios_globals_table[] = {
#undef C
};
STATIC MP_DEFINE_CONST_DICT(mp_module_termios_globals, mp_module_termios_globals_table);
static MP_DEFINE_CONST_DICT(mp_module_termios_globals, mp_module_termios_globals_table);
const mp_obj_module_t mp_module_termios = {
.base = { &mp_type_module },

20
ports/unix/modtime.c
View File

@@ -61,7 +61,7 @@ static inline int msec_sleep_tv(struct timeval *tv) {
#error Unsupported clock() implementation
#endif
STATIC mp_obj_t mp_time_time_get(void) {
static mp_obj_t mp_time_time_get(void) {
#if MICROPY_PY_BUILTINS_FLOAT && MICROPY_FLOAT_IMPL == MICROPY_FLOAT_IMPL_DOUBLE
struct timeval tv;
gettimeofday(&tv, NULL);
@@ -73,7 +73,7 @@ STATIC mp_obj_t mp_time_time_get(void) {
}
// Note: this is deprecated since CPy3.3, but pystone still uses it.
STATIC mp_obj_t mod_time_clock(void) {
static mp_obj_t mod_time_clock(void) {
#if MICROPY_PY_BUILTINS_FLOAT
// float cannot represent full range of int32 precisely, so we pre-divide
// int to reduce resolution, and then actually do float division hoping
@@ -83,9 +83,9 @@ STATIC mp_obj_t mod_time_clock(void) {
return mp_obj_new_int((mp_int_t)clock());
#endif
}
STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_time_clock_obj, mod_time_clock);
static MP_DEFINE_CONST_FUN_OBJ_0(mod_time_clock_obj, mod_time_clock);
STATIC mp_obj_t mp_time_sleep(mp_obj_t arg) {
static mp_obj_t mp_time_sleep(mp_obj_t arg) {
#if MICROPY_PY_BUILTINS_FLOAT
struct timeval tv;
mp_float_t val = mp_obj_get_float(arg);
@@ -125,7 +125,7 @@ STATIC mp_obj_t mp_time_sleep(mp_obj_t arg) {
return mp_const_none;
}
STATIC mp_obj_t mod_time_gm_local_time(size_t n_args, const mp_obj_t *args, struct tm *(*time_func)(const time_t *timep)) {
static mp_obj_t mod_time_gm_local_time(size_t n_args, const mp_obj_t *args, struct tm *(*time_func)(const time_t *timep)) {
time_t t;
if (n_args == 0) {
t = time(NULL);
@@ -159,17 +159,17 @@ STATIC mp_obj_t mod_time_gm_local_time(size_t n_args, const mp_obj_t *args, stru
return ret;
}
STATIC mp_obj_t mod_time_gmtime(size_t n_args, const mp_obj_t *args) {
static mp_obj_t mod_time_gmtime(size_t n_args, const mp_obj_t *args) {
return mod_time_gm_local_time(n_args, args, gmtime);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_time_gmtime_obj, 0, 1, mod_time_gmtime);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_time_gmtime_obj, 0, 1, mod_time_gmtime);
STATIC mp_obj_t mod_time_localtime(size_t n_args, const mp_obj_t *args) {
static mp_obj_t mod_time_localtime(size_t n_args, const mp_obj_t *args) {
return mod_time_gm_local_time(n_args, args, localtime);
}
STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_time_localtime_obj, 0, 1, mod_time_localtime);
static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_time_localtime_obj, 0, 1, mod_time_localtime);
STATIC mp_obj_t mod_time_mktime(mp_obj_t tuple) {
static mp_obj_t mod_time_mktime(mp_obj_t tuple) {
size_t len;
mp_obj_t *elem;
mp_obj_get_array(tuple, &len, &elem);

16
ports/unix/mpbthciport.c
View File

@@ -54,7 +54,7 @@
uint8_t mp_bluetooth_hci_cmd_buf[4 + 256];
STATIC int uart_fd = -1;
static int uart_fd = -1;
// Must be provided by the stack bindings (e.g. mpnimbleport.c or mpbtstackport.c).
extern bool mp_bluetooth_hci_poll(void);
@@ -68,9 +68,9 @@ extern bool mp_bluetooth_hci_poll(void);
extern bool mp_bluetooth_hci_active(void);
// Prevent double-enqueuing of the scheduled task.
STATIC volatile bool events_task_is_scheduled = false;
static volatile bool events_task_is_scheduled = false;
STATIC mp_obj_t run_events_scheduled_task(mp_obj_t none_in) {
static mp_obj_t run_events_scheduled_task(mp_obj_t none_in) {
(void)none_in;
MICROPY_PY_BLUETOOTH_ENTER
events_task_is_scheduled = false;
@@ -78,14 +78,14 @@ STATIC mp_obj_t run_events_scheduled_task(mp_obj_t none_in) {
mp_bluetooth_hci_poll();
return mp_const_none;
}
STATIC MP_DEFINE_CONST_FUN_OBJ_1(run_events_scheduled_task_obj, run_events_scheduled_task);
static MP_DEFINE_CONST_FUN_OBJ_1(run_events_scheduled_task_obj, run_events_scheduled_task);
#endif // MICROPY_PY_BLUETOOTH_USE_SYNC_EVENTS
STATIC const useconds_t UART_POLL_INTERVAL_US = 1000;
STATIC pthread_t hci_poll_thread_id;
static const useconds_t UART_POLL_INTERVAL_US = 1000;
static pthread_t hci_poll_thread_id;
STATIC void *hci_poll_thread(void *arg) {
static void *hci_poll_thread(void *arg) {
(void)arg;
DEBUG_printf("hci_poll_thread: starting\n");
@@ -118,7 +118,7 @@ STATIC void *hci_poll_thread(void *arg) {
return NULL;
}
STATIC int configure_uart(void) {
static int configure_uart(void) {
struct termios toptions;
// Get existing config.

2
ports/unix/mpbtstackport_h4.c
View File

@@ -44,7 +44,7 @@
#define DEBUG_printf(...) // printf(__VA_ARGS__)
STATIC hci_transport_config_uart_t hci_transport_config_uart = {
static hci_transport_config_uart_t hci_transport_config_uart = {
.type = HCI_TRANSPORT_CONFIG_UART,
.baudrate_init = 1000000,
.baudrate_main = 0,

6
ports/unix/mpbtstackport_usb.c
View File

@@ -49,7 +49,7 @@
#error Unix btstack requires MICROPY_PY_THREAD
#endif
STATIC const useconds_t USB_POLL_INTERVAL_US = 1000;
static const useconds_t USB_POLL_INTERVAL_US = 1000;
void mp_bluetooth_btstack_port_init_usb(void) {
// MICROPYBTUSB can be a ':'' or '-' separated port list.
@@ -73,7 +73,7 @@ void mp_bluetooth_btstack_port_init_usb(void) {
hci_init(hci_transport_usb_instance(), NULL);
}
STATIC pthread_t bstack_thread_id;
static pthread_t bstack_thread_id;
void mp_bluetooth_btstack_port_deinit(void) {
hci_power_control(HCI_POWER_OFF);
@@ -86,7 +86,7 @@ void mp_bluetooth_btstack_port_deinit(void) {
// Provided by mpbstackport_common.c.
extern bool mp_bluetooth_hci_poll(void);
STATIC void *btstack_thread(void *arg) {
static void *btstack_thread(void *arg) {
(void)arg;
hci_power_control(HCI_POWER_ON);

14
ports/unix/mpthreadport.c
View File

@@ -60,21 +60,21 @@ typedef struct _mp_thread_t {
struct _mp_thread_t *next;
} mp_thread_t;
STATIC pthread_key_t tls_key;
static pthread_key_t tls_key;
// The mutex is used for any code in this port that needs to be thread safe.
// Specifically for thread management, access to the linked list is one example.
// But also, e.g. scheduler state.
STATIC pthread_mutex_t thread_mutex;
STATIC mp_thread_t *thread;
static pthread_mutex_t thread_mutex;
static mp_thread_t *thread;
// this is used to synchronise the signal handler of the thread
// it's needed because we can't use any pthread calls in a signal handler
#if defined(__APPLE__)
STATIC char thread_signal_done_name[25];
STATIC sem_t *thread_signal_done_p;
static char thread_signal_done_name[25];
static sem_t *thread_signal_done_p;
#else
STATIC sem_t thread_signal_done;
static sem_t thread_signal_done;
#endif
void mp_thread_unix_begin_atomic_section(void) {
@@ -86,7 +86,7 @@ void mp_thread_unix_end_atomic_section(void) {
}
// this signal handler is used to scan the regs and stack of a thread
STATIC void mp_thread_gc(int signo, siginfo_t *info, void *context) {
static void mp_thread_gc(int signo, siginfo_t *info, void *context) {
(void)info; // unused
(void)context; // unused
if (signo == MP_THREAD_GC_SIGNAL) {

2
ports/unix/unix_mphal.c
View File

@@ -46,7 +46,7 @@
#ifndef _WIN32
#include <signal.h>
STATIC void sighandler(int signum) {
static void sighandler(int signum) {
if (signum == SIGINT) {
#if MICROPY_ASYNC_KBD_INTR
#if MICROPY_PY_THREAD_GIL