2014-05-03 23:27:38 +01:00
|
|
|
/*
|
|
|
|
* This file is part of the Micro Python project, http://micropython.org/
|
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
|
2013-10-12 14:30:21 +01:00
|
|
|
// options to control how Micro Python is built
|
|
|
|
|
2014-05-21 20:32:59 +01:00
|
|
|
#define MICROPY_ALLOC_PATH_MAX (PATH_MAX)
|
2016-02-11 22:40:03 +00:00
|
|
|
#define MICROPY_PERSISTENT_CODE_LOAD (1)
|
2014-09-03 22:40:15 +01:00
|
|
|
#if !defined(MICROPY_EMIT_X64) && defined(__x86_64__)
|
|
|
|
#define MICROPY_EMIT_X64 (1)
|
2014-07-13 11:49:51 +01:00
|
|
|
#endif
|
2014-09-06 23:06:36 +01:00
|
|
|
#if !defined(MICROPY_EMIT_X86) && defined(__i386__)
|
|
|
|
#define MICROPY_EMIT_X86 (1)
|
|
|
|
#endif
|
2014-12-14 01:24:17 +00:00
|
|
|
#if !defined(MICROPY_EMIT_THUMB) && defined(__thumb2__)
|
|
|
|
#define MICROPY_EMIT_THUMB (1)
|
2015-05-08 00:24:43 +01:00
|
|
|
#define MICROPY_MAKE_POINTER_CALLABLE(p) ((void*)((mp_uint_t)(p) | 1))
|
2014-12-14 01:24:17 +00:00
|
|
|
#endif
|
2015-05-08 00:24:43 +01:00
|
|
|
// Some compilers define __thumb2__ and __arm__ at the same time, let
|
|
|
|
// autodetected thumb2 emitter have priority.
|
|
|
|
#if !defined(MICROPY_EMIT_ARM) && defined(__arm__) && !defined(__thumb2__)
|
2014-12-14 01:24:17 +00:00
|
|
|
#define MICROPY_EMIT_ARM (1)
|
|
|
|
#endif
|
2015-01-10 14:07:24 +00:00
|
|
|
#define MICROPY_COMP_MODULE_CONST (1)
|
2015-03-14 13:11:35 +00:00
|
|
|
#define MICROPY_COMP_TRIPLE_TUPLE_ASSIGN (1)
|
2014-04-02 18:57:19 +01:00
|
|
|
#define MICROPY_ENABLE_GC (1)
|
2014-04-05 20:35:48 +01:00
|
|
|
#define MICROPY_ENABLE_FINALISER (1)
|
2015-01-09 00:10:55 +00:00
|
|
|
#define MICROPY_STACK_CHECK (1)
|
2015-02-27 09:54:12 +00:00
|
|
|
#define MICROPY_MALLOC_USES_ALLOCATED_SIZE (1)
|
2014-01-07 14:54:15 +00:00
|
|
|
#define MICROPY_MEM_STATS (1)
|
2014-01-19 11:48:48 +00:00
|
|
|
#define MICROPY_DEBUG_PRINTERS (1)
|
2016-04-13 09:46:18 +01:00
|
|
|
// Printing debug to stderr may give tests which
|
|
|
|
// check stdout a chance to pass, etc.
|
|
|
|
#define MICROPY_DEBUG_PRINTER_DEST mp_stderr_print
|
2015-03-13 07:45:42 +00:00
|
|
|
#define MICROPY_USE_READLINE_HISTORY (1)
|
2014-05-21 20:32:59 +01:00
|
|
|
#define MICROPY_HELPER_REPL (1)
|
2015-07-10 00:32:36 +01:00
|
|
|
#define MICROPY_REPL_EMACS_KEYS (1)
|
2015-08-20 10:34:22 +01:00
|
|
|
#define MICROPY_REPL_AUTO_INDENT (1)
|
2014-05-21 20:32:59 +01:00
|
|
|
#define MICROPY_HELPER_LEXER_UNIX (1)
|
2014-01-29 21:51:51 +00:00
|
|
|
#define MICROPY_ENABLE_SOURCE_LINE (1)
|
2014-03-08 15:24:39 +00:00
|
|
|
#define MICROPY_FLOAT_IMPL (MICROPY_FLOAT_IMPL_DOUBLE)
|
2014-02-22 19:25:23 +00:00
|
|
|
#define MICROPY_LONGINT_IMPL (MICROPY_LONGINT_IMPL_MPZ)
|
2014-05-07 00:23:46 +01:00
|
|
|
#define MICROPY_STREAMS_NON_BLOCK (1)
|
2014-05-21 20:32:59 +01:00
|
|
|
#define MICROPY_OPT_COMPUTED_GOTO (1)
|
2015-01-06 12:51:39 +00:00
|
|
|
#define MICROPY_OPT_CACHE_MAP_LOOKUP_IN_BYTECODE (1)
|
2014-12-09 16:19:48 +00:00
|
|
|
#define MICROPY_CAN_OVERRIDE_BUILTINS (1)
|
2015-02-14 17:44:31 +00:00
|
|
|
#define MICROPY_PY_FUNCTION_ATTRS (1)
|
2015-02-14 17:43:54 +00:00
|
|
|
#define MICROPY_PY_DESCRIPTORS (1)
|
2014-07-16 11:45:10 +01:00
|
|
|
#define MICROPY_PY_BUILTINS_STR_UNICODE (1)
|
2015-04-03 22:09:23 +01:00
|
|
|
#define MICROPY_PY_BUILTINS_STR_SPLITLINES (1)
|
2014-10-23 13:34:35 +01:00
|
|
|
#define MICROPY_PY_BUILTINS_MEMORYVIEW (1)
|
2014-06-01 13:32:54 +01:00
|
|
|
#define MICROPY_PY_BUILTINS_FROZENSET (1)
|
2014-10-25 21:59:14 +01:00
|
|
|
#define MICROPY_PY_BUILTINS_COMPILE (1)
|
2015-05-04 17:45:53 +01:00
|
|
|
#define MICROPY_PY_BUILTINS_NOTIMPLEMENTED (1)
|
2015-01-09 20:12:54 +00:00
|
|
|
#define MICROPY_PY_MICROPYTHON_MEM_INFO (1)
|
2015-01-29 23:42:49 +00:00
|
|
|
#define MICROPY_PY_ALL_SPECIAL_METHODS (1)
|
2015-02-27 20:16:05 +00:00
|
|
|
#define MICROPY_PY_ARRAY_SLICE_ASSIGN (1)
|
2015-09-11 22:31:32 +01:00
|
|
|
#define MICROPY_PY_BUILTINS_SLICE_ATTRS (1)
|
2014-05-24 23:03:12 +01:00
|
|
|
#define MICROPY_PY_SYS_EXIT (1)
|
2015-08-03 21:13:34 +01:00
|
|
|
#if defined(__APPLE__) && defined(__MACH__)
|
|
|
|
#define MICROPY_PY_SYS_PLATFORM "darwin"
|
|
|
|
#else
|
|
|
|
#define MICROPY_PY_SYS_PLATFORM "linux"
|
|
|
|
#endif
|
2014-07-03 14:50:11 +01:00
|
|
|
#define MICROPY_PY_SYS_MAXSIZE (1)
|
2014-05-24 23:03:12 +01:00
|
|
|
#define MICROPY_PY_SYS_STDFILES (1)
|
2015-04-25 01:17:41 +01:00
|
|
|
#define MICROPY_PY_SYS_EXC_INFO (1)
|
2015-03-17 23:25:04 +00:00
|
|
|
#define MICROPY_PY_COLLECTIONS_ORDEREDDICT (1)
|
2015-11-13 13:23:35 +00:00
|
|
|
#ifndef MICROPY_PY_MATH_SPECIAL_FUNCTIONS
|
2015-02-22 14:48:18 +00:00
|
|
|
#define MICROPY_PY_MATH_SPECIAL_FUNCTIONS (1)
|
2015-11-13 13:23:35 +00:00
|
|
|
#endif
|
2014-05-24 23:03:12 +01:00
|
|
|
#define MICROPY_PY_CMATH (1)
|
|
|
|
#define MICROPY_PY_IO_FILEIO (1)
|
2014-06-05 20:48:02 +01:00
|
|
|
#define MICROPY_PY_GC_COLLECT_RETVAL (1)
|
2016-01-31 22:24:16 +00:00
|
|
|
#define MICROPY_MODULE_FROZEN_STR (1)
|
2014-06-28 01:03:47 +01:00
|
|
|
|
2015-03-27 23:14:45 +00:00
|
|
|
#define MICROPY_STACKLESS (0)
|
|
|
|
#define MICROPY_STACKLESS_STRICT (0)
|
|
|
|
|
unix/modos: Add statvfs() function.
Another function (like stat) which is problematic to deal with on ABI level
(FFI), as struct statvfs layout may differ unpredictably between OSes and
even different versions of a same OS. So, implement it in C, returning a
10-element tuple of f_bsize, f_frsize, f_blocks, f_bfree, f_bavail, f_files,
f_ffree, f_favail, f_flag, f_namemax. This is exactly the order described
in Python3 docs, https://docs.python.org/3/library/os.html#os.statvfs
(but note that os.statvfs() should make these values available as
attributes).
2015-10-17 22:45:31 +01:00
|
|
|
#define MICROPY_PY_OS_STATVFS (1)
|
2014-06-28 01:03:47 +01:00
|
|
|
#define MICROPY_PY_UCTYPES (1)
|
2014-10-12 16:16:34 +01:00
|
|
|
#define MICROPY_PY_UZLIB (1)
|
2014-09-17 22:56:34 +01:00
|
|
|
#define MICROPY_PY_UJSON (1)
|
2014-09-12 16:48:07 +01:00
|
|
|
#define MICROPY_PY_URE (1)
|
2014-10-22 18:37:18 +01:00
|
|
|
#define MICROPY_PY_UHEAPQ (1)
|
2014-11-21 23:19:13 +00:00
|
|
|
#define MICROPY_PY_UHASHLIB (1)
|
2016-04-11 19:58:58 +01:00
|
|
|
#if MICROPY_PY_USSL
|
|
|
|
#define MICROPY_PY_UHASHLIB_SHA1 (1)
|
|
|
|
#endif
|
2014-11-29 04:19:30 +00:00
|
|
|
#define MICROPY_PY_UBINASCII (1)
|
2016-01-17 10:10:28 +00:00
|
|
|
#define MICROPY_PY_URANDOM (1)
|
2015-12-13 06:47:00 +00:00
|
|
|
#ifndef MICROPY_PY_USELECT
|
|
|
|
#define MICROPY_PY_USELECT (1)
|
|
|
|
#endif
|
2015-05-03 18:25:40 +01:00
|
|
|
#define MICROPY_PY_MACHINE (1)
|
2015-12-14 00:11:20 +00:00
|
|
|
#define MICROPY_MACHINE_MEM_GET_READ_ADDR mod_machine_mem_get_addr
|
|
|
|
#define MICROPY_MACHINE_MEM_GET_WRITE_ADDR mod_machine_mem_get_addr
|
2014-06-28 01:03:47 +01:00
|
|
|
|
2016-02-13 21:03:23 +00:00
|
|
|
#define MICROPY_FATFS_ENABLE_LFN (1)
|
|
|
|
#define MICROPY_FATFS_RPATH (2)
|
|
|
|
// Can't have less than 3 values because diskio.h uses volume numbers
|
|
|
|
// as volume types and PD_USER == 2.
|
|
|
|
#define MICROPY_FATFS_VOLUMES (3)
|
|
|
|
#define MICROPY_FATFS_MAX_SS (4096)
|
|
|
|
#define MICROPY_FATFS_LFN_CODE_PAGE (437) /* 1=SFN/ANSI 437=LFN/U.S.(OEM) */
|
|
|
|
#define MICROPY_FSUSERMOUNT (1)
|
|
|
|
#define MICROPY_VFS_FAT (1)
|
|
|
|
|
2014-04-30 23:35:38 +01:00
|
|
|
// Define to MICROPY_ERROR_REPORTING_DETAILED to get function, etc.
|
|
|
|
// names in exception messages (may require more RAM).
|
|
|
|
#define MICROPY_ERROR_REPORTING (MICROPY_ERROR_REPORTING_DETAILED)
|
2015-01-01 07:29:28 +00:00
|
|
|
#define MICROPY_WARNINGS (1)
|
2014-10-11 18:32:17 +01:00
|
|
|
|
|
|
|
// Define to 1 to use undertested inefficient GC helper implementation
|
2014-06-05 02:32:17 +01:00
|
|
|
// (if more efficient arch-specific one is not available).
|
2014-06-20 18:17:43 +01:00
|
|
|
#ifndef MICROPY_GCREGS_SETJMP
|
2014-09-03 22:40:15 +01:00
|
|
|
#ifdef __mips__
|
|
|
|
#define MICROPY_GCREGS_SETJMP (1)
|
|
|
|
#else
|
|
|
|
#define MICROPY_GCREGS_SETJMP (0)
|
|
|
|
#endif
|
2014-06-20 18:17:43 +01:00
|
|
|
#endif
|
2013-10-12 14:30:21 +01:00
|
|
|
|
2014-07-02 07:46:53 +01:00
|
|
|
#define MICROPY_ENABLE_EMERGENCY_EXCEPTION_BUF (1)
|
2014-10-07 08:50:20 +01:00
|
|
|
#define MICROPY_EMERGENCY_EXCEPTION_BUF_SIZE (256)
|
2015-12-22 22:06:37 +00:00
|
|
|
#define MICROPY_ASYNC_KBD_INTR (1)
|
2014-07-02 07:46:53 +01:00
|
|
|
|
2015-12-12 22:15:33 +00:00
|
|
|
extern const struct _mp_obj_module_t mp_module_machine;
|
2014-05-14 20:08:45 +01:00
|
|
|
extern const struct _mp_obj_module_t mp_module_os;
|
2015-11-16 22:35:29 +00:00
|
|
|
extern const struct _mp_obj_module_t mp_module_uselect;
|
2014-04-17 16:28:38 +01:00
|
|
|
extern const struct _mp_obj_module_t mp_module_time;
|
2014-08-19 08:23:14 +01:00
|
|
|
extern const struct _mp_obj_module_t mp_module_termios;
|
2014-04-17 18:34:04 +01:00
|
|
|
extern const struct _mp_obj_module_t mp_module_socket;
|
2014-04-17 22:00:15 +01:00
|
|
|
extern const struct _mp_obj_module_t mp_module_ffi;
|
2015-09-11 15:57:47 +01:00
|
|
|
extern const struct _mp_obj_module_t mp_module_jni;
|
2014-05-12 20:46:29 +01:00
|
|
|
|
2014-05-24 23:03:12 +01:00
|
|
|
#if MICROPY_PY_FFI
|
2015-11-27 13:38:15 +00:00
|
|
|
#define MICROPY_PY_FFI_DEF { MP_ROM_QSTR(MP_QSTR_ffi), MP_ROM_PTR(&mp_module_ffi) },
|
2014-05-12 20:46:29 +01:00
|
|
|
#else
|
2014-05-24 23:03:12 +01:00
|
|
|
#define MICROPY_PY_FFI_DEF
|
2014-05-12 20:46:29 +01:00
|
|
|
#endif
|
2015-09-11 15:57:47 +01:00
|
|
|
#if MICROPY_PY_JNI
|
2015-11-27 13:38:15 +00:00
|
|
|
#define MICROPY_PY_JNI_DEF { MP_ROM_QSTR(MP_QSTR_jni), MP_ROM_PTR(&mp_module_jni) },
|
2015-09-11 15:57:47 +01:00
|
|
|
#else
|
|
|
|
#define MICROPY_PY_JNI_DEF
|
|
|
|
#endif
|
2014-05-24 23:03:12 +01:00
|
|
|
#if MICROPY_PY_TIME
|
2015-11-27 13:38:15 +00:00
|
|
|
#define MICROPY_PY_TIME_DEF { MP_ROM_QSTR(MP_QSTR_utime), MP_ROM_PTR(&mp_module_time) },
|
2014-05-12 20:46:29 +01:00
|
|
|
#else
|
2014-05-24 23:03:12 +01:00
|
|
|
#define MICROPY_PY_TIME_DEF
|
2014-05-12 20:46:29 +01:00
|
|
|
#endif
|
2014-08-24 13:19:22 +01:00
|
|
|
#if MICROPY_PY_TERMIOS
|
2015-11-27 13:38:15 +00:00
|
|
|
#define MICROPY_PY_TERMIOS_DEF { MP_ROM_QSTR(MP_QSTR_termios), MP_ROM_PTR(&mp_module_termios) },
|
2014-08-24 13:19:22 +01:00
|
|
|
#else
|
|
|
|
#define MICROPY_PY_TERMIOS_DEF
|
|
|
|
#endif
|
2015-01-11 17:28:27 +00:00
|
|
|
#if MICROPY_PY_SOCKET
|
2015-11-27 13:38:15 +00:00
|
|
|
#define MICROPY_PY_SOCKET_DEF { MP_ROM_QSTR(MP_QSTR_usocket), MP_ROM_PTR(&mp_module_socket) },
|
2015-01-11 17:28:27 +00:00
|
|
|
#else
|
|
|
|
#define MICROPY_PY_SOCKET_DEF
|
|
|
|
#endif
|
2015-12-13 06:47:00 +00:00
|
|
|
#if MICROPY_PY_USELECT
|
|
|
|
#define MICROPY_PY_USELECT_DEF { MP_ROM_QSTR(MP_QSTR_uselect), MP_ROM_PTR(&mp_module_uselect) },
|
|
|
|
#else
|
|
|
|
#define MICROPY_PY_USELECT_DEF
|
|
|
|
#endif
|
2014-05-12 20:46:29 +01:00
|
|
|
|
2014-05-21 20:32:59 +01:00
|
|
|
#define MICROPY_PORT_BUILTIN_MODULES \
|
2014-05-24 23:03:12 +01:00
|
|
|
MICROPY_PY_FFI_DEF \
|
2015-09-11 15:57:47 +01:00
|
|
|
MICROPY_PY_JNI_DEF \
|
2014-05-24 23:03:12 +01:00
|
|
|
MICROPY_PY_TIME_DEF \
|
2015-01-11 17:28:27 +00:00
|
|
|
MICROPY_PY_SOCKET_DEF \
|
2015-12-18 00:35:33 +00:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR_umachine), MP_ROM_PTR(&mp_module_machine) }, \
|
2015-12-11 22:04:01 +00:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR_uos), MP_ROM_PTR(&mp_module_os) }, \
|
2015-12-13 06:47:00 +00:00
|
|
|
MICROPY_PY_USELECT_DEF \
|
2014-08-24 13:19:22 +01:00
|
|
|
MICROPY_PY_TERMIOS_DEF \
|
2014-04-17 16:28:38 +01:00
|
|
|
|
2013-10-12 14:30:21 +01:00
|
|
|
// type definitions for the specific machine
|
|
|
|
|
2016-01-15 11:12:08 +00:00
|
|
|
// assume that if we already defined the obj repr then we also defined types
|
|
|
|
#ifndef MICROPY_OBJ_REPR
|
2013-12-30 01:38:32 +00:00
|
|
|
#ifdef __LP64__
|
2014-07-03 13:25:24 +01:00
|
|
|
typedef long mp_int_t; // must be pointer size
|
|
|
|
typedef unsigned long mp_uint_t; // must be pointer size
|
2013-12-30 01:38:32 +00:00
|
|
|
#else
|
|
|
|
// These are definitions for machines where sizeof(int) == sizeof(void*),
|
2015-12-02 23:41:26 +00:00
|
|
|
// regardless of actual size.
|
2014-07-03 13:25:24 +01:00
|
|
|
typedef int mp_int_t; // must be pointer size
|
|
|
|
typedef unsigned int mp_uint_t; // must be pointer size
|
2013-12-30 01:38:32 +00:00
|
|
|
#endif
|
2016-01-15 11:12:08 +00:00
|
|
|
#endif
|
2013-12-30 01:38:32 +00:00
|
|
|
|
2014-07-03 13:25:24 +01:00
|
|
|
#define BYTES_PER_WORD sizeof(mp_int_t)
|
2013-10-22 16:05:47 +01:00
|
|
|
|
2014-11-16 22:16:14 +00:00
|
|
|
// Cannot include <sys/types.h>, as it may lead to symbol name clashes
|
|
|
|
#if _FILE_OFFSET_BITS == 64 && !defined(__LP64__)
|
|
|
|
typedef long long mp_off_t;
|
|
|
|
#else
|
|
|
|
typedef long mp_off_t;
|
|
|
|
#endif
|
|
|
|
|
2013-10-12 14:30:21 +01:00
|
|
|
typedef void *machine_ptr_t; // must be of pointer size
|
2013-12-21 18:17:45 +00:00
|
|
|
typedef const void *machine_const_ptr_t; // must be of pointer size
|
2014-02-14 10:02:34 +00:00
|
|
|
|
2014-09-03 15:59:33 +01:00
|
|
|
void mp_unix_alloc_exec(mp_uint_t min_size, void** ptr, mp_uint_t *size);
|
|
|
|
void mp_unix_free_exec(void *ptr, mp_uint_t size);
|
2015-01-14 00:11:09 +00:00
|
|
|
void mp_unix_mark_exec(void);
|
2014-09-03 15:59:33 +01:00
|
|
|
#define MP_PLAT_ALLOC_EXEC(min_size, ptr, size) mp_unix_alloc_exec(min_size, ptr, size)
|
|
|
|
#define MP_PLAT_FREE_EXEC(ptr, size) mp_unix_free_exec(ptr, size)
|
|
|
|
|
2016-01-28 23:05:53 +00:00
|
|
|
#ifndef MP_NOINLINE
|
|
|
|
#define MP_NOINLINE __attribute__((noinline))
|
|
|
|
#endif
|
|
|
|
|
2015-12-27 23:12:59 +00:00
|
|
|
#if MICROPY_PY_OS_DUPTERM
|
|
|
|
#define MP_PLAT_PRINT_STRN(str, len) mp_hal_stdout_tx_strn_cooked(str, len)
|
|
|
|
#else
|
2015-10-15 00:05:55 +01:00
|
|
|
#include <unistd.h>
|
2015-10-15 00:23:03 +01:00
|
|
|
#define MP_PLAT_PRINT_STRN(str, len) do { ssize_t ret = write(1, str, len); (void)ret; } while (0)
|
2015-12-27 23:12:59 +00:00
|
|
|
#endif
|
2015-04-09 23:56:15 +01:00
|
|
|
|
2015-07-05 22:08:33 +01:00
|
|
|
#ifdef __linux__
|
|
|
|
// Can access physical memory using /dev/mem
|
|
|
|
#define MICROPY_PLAT_DEV_MEM (1)
|
|
|
|
#endif
|
|
|
|
|
unix/modtime: sleep(): Automatically restart after receiving EINTR.
THis is required to deal well with signals, signals being the closest
analogue of hardware interrupts for POSIX. This is also CPython 3.5
compliant behavior (PEP 475).
The main problem implementing this is to figure out how much time was
spent in waiting so far/how much is remaining. It's well-known fact that
Linux updates select()'s timeout value when returning with EINTR to the
remaining wait time. Here's what POSIX-based standards say about this:
(http://pubs.opengroup.org/onlinepubs/9699919799/functions/pselect.html):
"Upon successful completion, the select() function may modify the object
pointed to by the timeout argument."
I.e. it allows to modify timeout value, but doesn't say how exactly it is
modified. And actually, it allows such modification only "upon successful
completion", which returning with EINTR error hardly is.
POSIX also allows to request automatic EINTR restart for system calls using
sigaction call with SA_RESTART flag, but here's what the same document says
about it:
"If SA_RESTART has been set for the interrupting signal, it is
implementation-defined whether the function restarts or returns with
[EINTR]."
In other words, POSIX doesn't leave room for both portable and efficient
handling of this matter, so the code just allows to manually select
Linux-compatible behavior with MICROPY_SELECT_REMAINING_TIME option,
or otherwise will just raise OSError. When systems with non-Linux behavior
are found, they can be handled separately.
2015-11-29 11:37:17 +00:00
|
|
|
// Assume that select() call, interrupted with a signal, and erroring
|
|
|
|
// with EINTR, updates remaining timeout value.
|
|
|
|
#define MICROPY_SELECT_REMAINING_TIME (1)
|
|
|
|
|
2015-10-14 22:10:26 +01:00
|
|
|
#ifdef __ANDROID__
|
|
|
|
#include <android/api-level.h>
|
|
|
|
#if __ANDROID_API__ < 4
|
|
|
|
// Bionic libc in Android 1.5 misses these 2 functions
|
2015-11-13 11:24:39 +00:00
|
|
|
#define MP_NEED_LOG2 (1)
|
2015-10-14 22:10:26 +01:00
|
|
|
#define nan(x) NAN
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
|
2014-05-21 20:32:59 +01:00
|
|
|
#define MICROPY_PORT_BUILTINS \
|
2015-11-27 13:38:15 +00:00
|
|
|
{ MP_ROM_QSTR(MP_QSTR_input), MP_ROM_PTR(&mp_builtin_input_obj) }, \
|
|
|
|
{ MP_ROM_QSTR(MP_QSTR_open), MP_ROM_PTR(&mp_builtin_open_obj) },
|
2014-06-07 08:36:04 +01:00
|
|
|
|
2015-05-24 22:36:31 +01:00
|
|
|
#define MP_STATE_PORT MP_STATE_VM
|
|
|
|
|
2015-01-01 23:30:53 +00:00
|
|
|
#define MICROPY_PORT_ROOT_POINTERS \
|
2015-05-24 22:36:31 +01:00
|
|
|
const char *readline_hist[50]; \
|
2015-01-14 00:11:09 +00:00
|
|
|
mp_obj_t keyboard_interrupt_obj; \
|
|
|
|
void *mmap_region_head; \
|
2015-01-01 23:30:53 +00:00
|
|
|
|
2014-06-08 13:25:33 +01:00
|
|
|
// We need to provide a declaration/definition of alloca()
|
2015-12-02 14:05:02 +00:00
|
|
|
// unless support for it is disabled.
|
|
|
|
#if !defined(MICROPY_NO_ALLOCA) || MICROPY_NO_ALLOCA == 0
|
2014-06-07 08:36:04 +01:00
|
|
|
#ifdef __FreeBSD__
|
|
|
|
#include <stdlib.h>
|
|
|
|
#else
|
|
|
|
#include <alloca.h>
|
|
|
|
#endif
|
2015-12-02 14:05:02 +00:00
|
|
|
#endif
|
2015-12-14 21:48:12 +00:00
|
|
|
|
|
|
|
// From "man readdir": "Under glibc, programs can check for the availability
|
|
|
|
// of the fields [in struct dirent] not defined in POSIX.1 by testing whether
|
|
|
|
// the macros [...], _DIRENT_HAVE_D_TYPE are defined."
|
|
|
|
// Other libc's don't define it, but proactively assume that dirent->d_type
|
|
|
|
// is available on a modern *nix system.
|
|
|
|
#ifndef _DIRENT_HAVE_D_TYPE
|
|
|
|
#define _DIRENT_HAVE_D_TYPE (1)
|
|
|
|
#endif
|
2015-12-16 14:17:56 +00:00
|
|
|
// This macro is not provided by glibc but we need it so ports that don't have
|
|
|
|
// dirent->d_ino can disable the use of this field.
|
|
|
|
#ifndef _DIRENT_HAVE_D_INO
|
|
|
|
#define _DIRENT_HAVE_D_INO (1)
|
|
|
|
#endif
|