2014-05-03 16:27:38 -06:00
|
|
|
/*
|
2017-06-30 01:22:17 -06:00
|
|
|
* This file is part of the MicroPython project, http://micropython.org/
|
2014-05-03 16:27:38 -06:00
|
|
|
*
|
|
|
|
* The MIT License (MIT)
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, 2014 Damien P. George
|
2019-05-14 06:51:57 -06:00
|
|
|
* Copyright (c) 2014-2016 Paul Sokolovsky
|
2014-05-03 16:27:38 -06:00
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*/
|
all: Unify header guard usage.
The code conventions suggest using header guards, but do not define how
those should look like and instead point to existing files. However, not
all existing files follow the same scheme, sometimes omitting header guards
altogether, sometimes using non-standard names, making it easy to
accidentally pick a "wrong" example.
This commit ensures that all header files of the MicroPython project (that
were not simply copied from somewhere else) follow the same pattern, that
was already present in the majority of files, especially in the py folder.
The rules are as follows.
Naming convention:
* start with the words MICROPY_INCLUDED
* contain the full path to the file
* replace special characters with _
In addition, there are no empty lines before #ifndef, between #ifndef and
one empty line before #endif. #endif is followed by a comment containing
the name of the guard macro.
py/grammar.h cannot use header guards by design, since it has to be
included multiple times in a single C file. Several other files also do not
need header guards as they are only used internally and guaranteed to be
included only once:
* MICROPY_MPHALPORT_H
* mpconfigboard.h
* mpconfigport.h
* mpthreadport.h
* pin_defs_*.h
* qstrdefs*.h
2017-06-29 15:14:58 -06:00
|
|
|
#ifndef MICROPY_INCLUDED_PY_STREAM_H
|
|
|
|
#define MICROPY_INCLUDED_PY_STREAM_H
|
2015-01-01 13:27:54 -07:00
|
|
|
|
|
|
|
#include "py/obj.h"
|
2016-07-26 05:48:52 -06:00
|
|
|
#include "py/mperrno.h"
|
2014-05-03 16:27:38 -06:00
|
|
|
|
2016-04-05 12:58:03 -06:00
|
|
|
#define MP_STREAM_ERROR ((mp_uint_t)-1)
|
|
|
|
|
|
|
|
// Stream ioctl request codes
|
|
|
|
#define MP_STREAM_FLUSH (1)
|
|
|
|
#define MP_STREAM_SEEK (2)
|
|
|
|
#define MP_STREAM_POLL (3)
|
2018-03-06 23:48:53 -07:00
|
|
|
#define MP_STREAM_CLOSE (4)
|
2016-04-10 03:42:41 -06:00
|
|
|
#define MP_STREAM_TIMEOUT (5) // Get/set timeout (single op)
|
|
|
|
#define MP_STREAM_GET_OPTS (6) // Get stream options
|
|
|
|
#define MP_STREAM_SET_OPTS (7) // Set stream options
|
|
|
|
#define MP_STREAM_GET_DATA_OPTS (8) // Get data/message options
|
|
|
|
#define MP_STREAM_SET_DATA_OPTS (9) // Set data/message options
|
2018-07-19 21:08:41 -06:00
|
|
|
#define MP_STREAM_GET_FILENO (10) // Get fileno of underlying file
|
2016-04-05 12:58:03 -06:00
|
|
|
|
2016-12-01 22:37:29 -07:00
|
|
|
// These poll ioctl values are compatible with Linux
|
2019-10-16 00:24:19 -06:00
|
|
|
#define MP_STREAM_POLL_RD (0x0001)
|
|
|
|
#define MP_STREAM_POLL_WR (0x0004)
|
|
|
|
#define MP_STREAM_POLL_ERR (0x0008)
|
|
|
|
#define MP_STREAM_POLL_HUP (0x0010)
|
|
|
|
#define MP_STREAM_POLL_NVAL (0x0020)
|
2016-12-01 22:37:29 -07:00
|
|
|
|
2016-04-05 12:58:03 -06:00
|
|
|
// Argument structure for MP_STREAM_SEEK
|
|
|
|
struct mp_stream_seek_t {
|
2017-08-20 12:32:17 -06:00
|
|
|
// If whence == MP_SEEK_SET, offset should be treated as unsigned.
|
|
|
|
// This allows dealing with full-width stream sizes (16, 32, 64,
|
|
|
|
// etc. bits). For other seek types, should be treated as signed.
|
2016-04-05 12:58:03 -06:00
|
|
|
mp_off_t offset;
|
|
|
|
int whence;
|
|
|
|
};
|
|
|
|
|
2017-08-20 12:32:17 -06:00
|
|
|
// seek ioctl "whence" values
|
|
|
|
#define MP_SEEK_SET (0)
|
|
|
|
#define MP_SEEK_CUR (1)
|
|
|
|
#define MP_SEEK_END (2)
|
|
|
|
|
2018-06-04 00:53:17 -06:00
|
|
|
// Stream protocol
|
|
|
|
typedef struct _mp_stream_p_t {
|
|
|
|
// On error, functions should return MP_STREAM_ERROR and fill in *errcode (values
|
|
|
|
// are implementation-dependent, but will be exposed to user, e.g. via exception).
|
|
|
|
mp_uint_t (*read)(mp_obj_t obj, void *buf, mp_uint_t size, int *errcode);
|
|
|
|
mp_uint_t (*write)(mp_obj_t obj, const void *buf, mp_uint_t size, int *errcode);
|
|
|
|
mp_uint_t (*ioctl)(mp_obj_t obj, mp_uint_t request, uintptr_t arg, int *errcode);
|
|
|
|
mp_uint_t is_text : 1; // default is bytes, set this for text stream
|
|
|
|
} mp_stream_p_t;
|
|
|
|
|
2016-10-17 18:06:20 -06:00
|
|
|
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_read_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_read1_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_readinto_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_unbuffered_readline_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_1(mp_stream_unbuffered_readlines_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_write_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_2(mp_stream_write1_obj);
|
2018-03-06 23:48:53 -07:00
|
|
|
MP_DECLARE_CONST_FUN_OBJ_1(mp_stream_close_obj);
|
2016-10-17 18:06:20 -06:00
|
|
|
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_seek_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_1(mp_stream_tell_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_1(mp_stream_flush_obj);
|
|
|
|
MP_DECLARE_CONST_FUN_OBJ_VAR_BETWEEN(mp_stream_ioctl_obj);
|
2014-01-20 09:35:32 -07:00
|
|
|
|
2015-12-08 16:34:59 -07:00
|
|
|
// these are for mp_get_stream_raise and can be or'd together
|
|
|
|
#define MP_STREAM_OP_READ (1)
|
|
|
|
#define MP_STREAM_OP_WRITE (2)
|
|
|
|
#define MP_STREAM_OP_IOCTL (4)
|
|
|
|
|
2018-06-12 19:54:44 -06:00
|
|
|
// Object is assumed to have a non-NULL stream protocol with valid r/w/ioctl methods
|
|
|
|
static inline const mp_stream_p_t *mp_get_stream(mp_const_obj_t self) {
|
2020-02-26 21:36:53 -07:00
|
|
|
return (const mp_stream_p_t *)((const mp_obj_base_t *)MP_OBJ_TO_PTR(self))->type->protocol;
|
2018-06-12 19:54:44 -06:00
|
|
|
}
|
|
|
|
|
2015-12-08 16:34:59 -07:00
|
|
|
const mp_stream_p_t *mp_get_stream_raise(mp_obj_t self_in, int flags);
|
2016-05-20 12:16:58 -06:00
|
|
|
mp_obj_t mp_stream_close(mp_obj_t stream);
|
2015-12-08 16:34:59 -07:00
|
|
|
|
2014-01-20 09:35:32 -07:00
|
|
|
// Iterator which uses mp_stream_unbuffered_readline_obj
|
|
|
|
mp_obj_t mp_stream_unbuffered_iter(mp_obj_t self);
|
2014-07-13 14:04:17 -06:00
|
|
|
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-17 17:40:03 -06:00
|
|
|
mp_obj_t mp_stream_write(mp_obj_t self_in, const void *buf, size_t len, byte flags);
|
2015-01-01 13:27:54 -07:00
|
|
|
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-17 17:40:03 -06:00
|
|
|
// C-level helper functions
|
|
|
|
#define MP_STREAM_RW_READ 0
|
|
|
|
#define MP_STREAM_RW_WRITE 2
|
|
|
|
#define MP_STREAM_RW_ONCE 1
|
|
|
|
mp_uint_t mp_stream_rw(mp_obj_t stream, void *buf, mp_uint_t size, int *errcode, byte flags);
|
2020-02-26 21:36:53 -07:00
|
|
|
#define mp_stream_write_exactly(stream, buf, size, err) mp_stream_rw(stream, (byte *)buf, size, err, MP_STREAM_RW_WRITE)
|
py/stream: Support both "exact size" and "one underlying call" operations.
Both read and write operations support variants where either a) a single
call is made to the undelying stream implementation and returned buffer
length may be less than requested, or b) calls are repeated until requested
amount of data is collected, shorter amount is returned only in case of
EOF or error.
These operations are available from the level of C support functions to be
used by other C modules to implementations of Python methods to be used in
user-facing objects.
The rationale of these changes is to allow to write concise and robust
code to work with *blocking* streams of types prone to short reads, like
serial interfaces and sockets. Particular object types may select "exact"
vs "once" types of methods depending on their needs. E.g., for sockets,
revc() and send() methods continue to be "once", while read() and write()
thus converted to "exactly" versions.
These changes don't affect non-blocking handling, e.g. trying "exact"
method on the non-blocking socket will return as much data as available
without blocking. No data available is continued to be signaled as None
return value to read() and write().
From the point of view of CPython compatibility, this model is a cross
between its io.RawIOBase and io.BufferedIOBase abstract classes. For
blocking streams, it works as io.BufferedIOBase model (guaranteeing
lack of short reads/writes), while for non-blocking - as io.RawIOBase,
returning None in case of lack of data (instead of raising expensive
exception, as required by io.BufferedIOBase). Such a cross-behavior
should be optimal for MicroPython needs.
2016-05-17 17:40:03 -06:00
|
|
|
#define mp_stream_read_exactly(stream, buf, size, err) mp_stream_rw(stream, buf, size, err, MP_STREAM_RW_READ)
|
2016-03-24 11:09:00 -06:00
|
|
|
|
2016-07-24 15:16:51 -06:00
|
|
|
void mp_stream_write_adaptor(void *self, const char *buf, size_t len);
|
|
|
|
|
2016-07-30 11:05:56 -06:00
|
|
|
#if MICROPY_STREAMS_POSIX_API
|
2016-07-29 15:25:06 -06:00
|
|
|
// Functions with POSIX-compatible signatures
|
2018-08-14 01:36:08 -06:00
|
|
|
// "stream" is assumed to be a pointer to a concrete object with the stream protocol
|
|
|
|
ssize_t mp_stream_posix_write(void *stream, const void *buf, size_t len);
|
|
|
|
ssize_t mp_stream_posix_read(void *stream, void *buf, size_t len);
|
|
|
|
off_t mp_stream_posix_lseek(void *stream, off_t offset, int whence);
|
|
|
|
int mp_stream_posix_fsync(void *stream);
|
2016-07-30 11:05:56 -06:00
|
|
|
#endif
|
2016-07-29 15:25:06 -06:00
|
|
|
|
2015-10-18 06:37:19 -06:00
|
|
|
#if MICROPY_STREAMS_NON_BLOCK
|
2018-04-24 09:43:14 -06:00
|
|
|
#define mp_is_nonblocking_error(errno) ((errno) == MP_EAGAIN || (errno) == MP_EWOULDBLOCK)
|
2015-10-18 06:37:19 -06:00
|
|
|
#else
|
|
|
|
#define mp_is_nonblocking_error(errno) (0)
|
|
|
|
#endif
|
|
|
|
|
all: Unify header guard usage.
The code conventions suggest using header guards, but do not define how
those should look like and instead point to existing files. However, not
all existing files follow the same scheme, sometimes omitting header guards
altogether, sometimes using non-standard names, making it easy to
accidentally pick a "wrong" example.
This commit ensures that all header files of the MicroPython project (that
were not simply copied from somewhere else) follow the same pattern, that
was already present in the majority of files, especially in the py folder.
The rules are as follows.
Naming convention:
* start with the words MICROPY_INCLUDED
* contain the full path to the file
* replace special characters with _
In addition, there are no empty lines before #ifndef, between #ifndef and
one empty line before #endif. #endif is followed by a comment containing
the name of the guard macro.
py/grammar.h cannot use header guards by design, since it has to be
included multiple times in a single C file. Several other files also do not
need header guards as they are only used internally and guaranteed to be
included only once:
* MICROPY_MPHALPORT_H
* mpconfigboard.h
* mpconfigport.h
* mpthreadport.h
* pin_defs_*.h
* qstrdefs*.h
2017-06-29 15:14:58 -06:00
|
|
|
#endif // MICROPY_INCLUDED_PY_STREAM_H
|