pyfuse3-3.2.0/0000775000175000017500000000000013773156367014620 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/Changes.rst0000664000175000017500000000443613773155565016730 0ustar nikrationikratio00000000000000=========== Changelog =========== .. currentmodule:: pyfuse3 Release 3.2.0 (2020-12-30) ========================== * Fix long-standing rounding error in file date handling when the nanosecond part of file dates were > 999999500. * There is a new `pyfuse3.terminate()` function to gracefully end the main loop. Release 3.1.1 (2020-10-06) ========================== * No source changes. Regenerated Cython files with Cython 0.29.21 for Python 3.9 compatibility. Release 3.1.0 (2020-05-31) ========================== * Made compatible with newest Trio module. Release 3.0.0 (2020-05-08) ========================== * Changed `create` handler to return a `FileInfo` struct to allow for modification of certain kernel file attributes, e.g. ``direct_io``. Note that this change breaks backwards compatibility, code that depends on the old behavior needs to be changed. Release 2.0.0 ============= * Changed `open` handler to return the new `FileInfo` struct to allow for modification of certain kernel file attributes, e.g. ``direct_io``. Note that this change breaks backwards compatibility, code that depends on the old behavior needs to be changed. Release 1.3.1 (2019-07-17) ========================== * Fixed a bug in the :file:`hello_asyncio.py` example. Release 1.3 (2019-06-02) ======================== * Fixed a bug in the :file:`tmpfs.py` and :file:`passthroughfs.py` example file systems (so rename operations no longer fail). Release 1.2 (2018-12-22) ======================== * Clarified that `invalidate_inode` may block in some circumstances. * Added support for using the asyncio module instead of Trio. Release 1.1 (2018-11-02) ======================== * Fixed :file:`examples/passthroughfs.py` - was not handling readdir() correctly. * `invalidate_entry_async` now accepts an additional *ignore_enoent* parameter. When this is set, no errors are logged if the kernel is not actually aware of the entry that should have been removed. Release 1.0 (2018-10-08) ======================== * Added a new `syncfs` function. Release 0.9 (2018-09-27) ======================== * First release * pyfuse3 was forked from python-llfuse - thanks for all the work! * If you need compatibility with Python 2.x or libfuse 2.x, you may want to take a look at python-llfuse instead. pyfuse3-3.2.0/Include/0000775000175000017500000000000013773156367016203 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/Include/fuse_common.pxd0000664000175000017500000000516413350426564021226 0ustar nikrationikratio00000000000000''' fuse_common.pxd This file contains Cython definitions for fuse_common.h Copyright © 2010 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' from fuse_opt cimport * from posix.types cimport off_t from libc.stdint cimport uint64_t # Based on fuse sources, revision tag fuse_2_9_4 cdef extern from * nogil: # fuse_common.h should not be included struct fuse_file_info: int flags unsigned int direct_io unsigned int keep_cache unsigned int nonseekable uint64_t fh uint64_t lock_owner struct fuse_conn_info: unsigned proto_major unsigned proto_minor unsigned max_write unsigned max_read unsigned max_readahead unsigned capable unsigned want unsigned max_background unsigned congestion_threshold unsigned time_gran struct fuse_session: pass struct fuse_chan: pass struct fuse_loop_config: int clone_fd unsigned max_idle_threads # Capability bits for fuse_conn_info.{capable,want} enum: FUSE_CAP_ASYNC_READ FUSE_CAP_POSIX_LOCKS FUSE_CAP_ATOMIC_O_TRUNC FUSE_CAP_EXPORT_SUPPORT FUSE_CAP_DONT_MASK FUSE_CAP_SPLICE_WRITE FUSE_CAP_SPLICE_MOVE FUSE_CAP_SPLICE_READ FUSE_CAP_FLOCK_LOCKS FUSE_CAP_IOCTL_DIR FUSE_CAP_AUTO_INVAL_DATA FUSE_CAP_READDIRPLUS FUSE_CAP_READDIRPLUS_AUTO FUSE_CAP_ASYNC_DIO FUSE_CAP_WRITEBACK_CACHE FUSE_CAP_NO_OPEN_SUPPORT FUSE_CAP_PARALLEL_DIROPS FUSE_CAP_POSIX_ACL FUSE_CAP_HANDLE_KILLPRIV int fuse_set_signal_handlers(fuse_session *se) void fuse_remove_signal_handlers(fuse_session *se) # fuse_common.h declares these as enums, but they are # actually flags (i.e., FUSE_BUF_IS_FD|FUSE_BUF_FD_SEEK) # is a valid variable. Therefore, we declare the type # as integer instead. ctypedef int fuse_buf_flags enum: FUSE_BUF_IS_FD FUSE_BUF_FD_SEEK FUSE_BUF_FD_RETRY ctypedef int fuse_buf_copy_flags enum: FUSE_BUF_NO_SPLICE FUSE_BUF_FORCE_SPLICE FUSE_BUF_SPLICE_MOVE FUSE_BUF_SPLICE_NONBLOCK struct fuse_buf: size_t size fuse_buf_flags flags void *mem int fd off_t pos struct fuse_bufvec: size_t count size_t idx size_t off fuse_buf buf[1] size_t fuse_buf_size(fuse_bufvec *bufv) ssize_t fuse_buf_copy(fuse_bufvec *dst, fuse_bufvec *src, fuse_buf_copy_flags flags) pyfuse3-3.2.0/Include/fuse_lowlevel.pxd0000664000175000017500000002011613354212030021542 0ustar nikrationikratio00000000000000''' fuse_lowlevel.pxd This file contains Cython definitions for fuse_lowlevel.h Copyright © 2010 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' from fuse_common cimport * from posix.stat cimport * from posix.types cimport * from libc_extra cimport statvfs from libc.stdlib cimport const_char from libc.stdint cimport uint32_t # Based on fuse sources, revision tag fuse-3.2.6 cdef extern from "" nogil: enum: FUSE_ROOT_ID ctypedef unsigned fuse_ino_t ctypedef struct fuse_req: pass ctypedef fuse_req* fuse_req_t struct fuse_entry_param: fuse_ino_t ino uint64_t generation struct_stat attr double attr_timeout double entry_timeout struct fuse_ctx: uid_t uid gid_t gid pid_t pid mode_t umask struct fuse_forget_data: fuse_ino_t ino uint64_t nlookup ctypedef fuse_ctx const_fuse_ctx "const struct fuse_ctx" int FUSE_SET_ATTR_MODE int FUSE_SET_ATTR_UID int FUSE_SET_ATTR_GID int FUSE_SET_ATTR_SIZE int FUSE_SET_ATTR_ATIME int FUSE_SET_ATTR_MTIME int FUSE_SET_ATTR_ATIME_NOW int FUSE_SET_ATTR_MTIME_NOW int FUSE_SET_ATTR_CTIME # Request handlers struct fuse_lowlevel_ops: void (*init) (void *userdata, fuse_conn_info *conn) void (*destroy) (void *userdata) void (*lookup) (fuse_req_t req, fuse_ino_t parent, const_char *name) void (*forget) (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup) void (*getattr) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*setattr) (fuse_req_t req, fuse_ino_t ino, struct_stat *attr, int to_set, fuse_file_info *fi) void (*readlink) (fuse_req_t req, fuse_ino_t ino) void (*mknod) (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode, dev_t rdev) void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode) void (*unlink) (fuse_req_t req, fuse_ino_t parent, const_char *name) void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const_char *name) void (*symlink) (fuse_req_t req, const_char *link, fuse_ino_t parent, const_char *name) void (*rename) (fuse_req_t req, fuse_ino_t parent, const_char *name, fuse_ino_t newparent, const_char *newname, unsigned flags) void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, const_char *newname) void (*open) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi) void (*write) (fuse_req_t req, fuse_ino_t ino, const_char *buf, size_t size, off_t off, fuse_file_info *fi) void (*flush) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*release) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync, fuse_file_info *fi) void (*opendir) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi) void (*releasedir) (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi) void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync, fuse_file_info *fi) void (*statfs) (fuse_req_t req, fuse_ino_t ino) void (*setxattr) (fuse_req_t req, fuse_ino_t ino, const_char *name, const_char *value, size_t size, int flags) void (*getxattr) (fuse_req_t req, fuse_ino_t ino, const_char *name, size_t size) void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size) void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const_char *name) void (*access) (fuse_req_t req, fuse_ino_t ino, int mask) void (*create) (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode, fuse_file_info *fi) void (*write_buf) (fuse_req_t req, fuse_ino_t ino, fuse_bufvec *bufv, off_t off, fuse_file_info *fi) void (*retrieve_reply) (fuse_req_t req, void *cookie, fuse_ino_t ino, off_t offset, fuse_bufvec *bufv) void (*forget_multi) (fuse_req_t req, size_t count, fuse_forget_data *forgets) void (*fallocate) (fuse_req_t req, fuse_ino_t ino, int mode, off_t offset, off_t length, fuse_file_info *fi) void (*readdirplus) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi) # Reply functions int fuse_reply_err(fuse_req_t req, int err) void fuse_reply_none(fuse_req_t req) int fuse_reply_entry(fuse_req_t req, fuse_entry_param *e) int fuse_reply_create(fuse_req_t req, fuse_entry_param *e, fuse_file_info *fi) int fuse_reply_attr(fuse_req_t req, struct_stat *attr, double attr_timeout) int fuse_reply_readlink(fuse_req_t req, const_char *link) int fuse_reply_open(fuse_req_t req, fuse_file_info *fi) int fuse_reply_write(fuse_req_t req, size_t count) int fuse_reply_buf(fuse_req_t req, const_char *buf, size_t size) int fuse_reply_data(fuse_req_t req, fuse_bufvec *bufv, fuse_buf_copy_flags flags) int fuse_reply_statfs(fuse_req_t req, statvfs *stbuf) int fuse_reply_xattr(fuse_req_t req, size_t count) size_t fuse_add_direntry(fuse_req_t req, const_char *buf, size_t bufsize, const_char *name, struct_stat *stbuf, off_t off) size_t fuse_add_direntry_plus(fuse_req_t req, char *buf, size_t bufsize, char *name, fuse_entry_param *e, off_t off) # Notification int fuse_lowlevel_notify_inval_inode(fuse_session *se, fuse_ino_t ino, off_t off, off_t len) int fuse_lowlevel_notify_inval_entry(fuse_session *se, fuse_ino_t parent, const_char *name, size_t namelen) int fuse_lowlevel_notify_delete(fuse_session *se, fuse_ino_t parent, fuse_ino_t child, const_char *name, size_t namelen) int fuse_lowlevel_notify_store(fuse_session *se, fuse_ino_t ino, off_t offset, fuse_bufvec *bufv, fuse_buf_copy_flags flags) int fuse_lowlevel_notify_retrieve(fuse_session *se, fuse_ino_t ino, size_t size, off_t offset, void *cookie) # Utility functions void *fuse_req_userdata(fuse_req_t req) fuse_ctx *fuse_req_ctx(fuse_req_t req) int fuse_req_getgroups(fuse_req_t req, size_t size, gid_t list[]) # Inquiry functions void fuse_lowlevel_version() void fuse_lowlevel_help() # Filesystem setup & teardown fuse_session *fuse_session_new(fuse_args *args, fuse_lowlevel_ops *op, size_t op_size, void *userdata) int fuse_session_mount(fuse_session *se, char *mountpoint) int fuse_session_loop(fuse_session *se) int fuse_session_loop_mt(fuse_session *se, fuse_loop_config *config); void fuse_session_exit(fuse_session *se) void fuse_session_reset(fuse_session *se) bint fuse_session_exited(fuse_session *se) void fuse_session_unmount(fuse_session *se) void fuse_session_destroy(fuse_session *se) # Custom event loop support int fuse_session_fd(fuse_session *se) int fuse_session_receive_buf(fuse_session *se, fuse_buf *buf) void fuse_session_process_buf(fuse_session *se, fuse_buf *buf) pyfuse3-3.2.0/Include/fuse_opt.pxd0000664000175000017500000000060313347530014020521 0ustar nikrationikratio00000000000000''' fuse_opt.pxd This file contains Cython definitions for fuse_opt.h Copyright © 2010 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' # Based on fuse sources, revision tag fuse_2_8_3 cdef extern from "" nogil: struct fuse_args: int argc char **argv int allocated pyfuse3-3.2.0/Include/libc_extra.pxd0000664000175000017500000000310313354212305021005 0ustar nikrationikratio00000000000000''' libc_extra.pxd This file contains Cython definitions libc functions that are not included in the pxd files shipped with Cython. Copyright © 2010 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' from posix.time cimport timespec cdef extern from "" nogil: ctypedef struct DIR: pass cdef struct dirent: char* d_name dirent* readdir(DIR* dirp) int readdir_r(DIR *dirp, dirent *entry, dirent **result) cdef extern from "" nogil: DIR *opendir(char *name) int closedir(DIR* dirp) cdef extern from "" nogil: ctypedef int fsblkcnt_t ctypedef int fsfilcnt_t struct statvfs: unsigned long f_bsize unsigned long f_frsize fsblkcnt_t f_blocks fsblkcnt_t f_bfree fsblkcnt_t f_bavail fsfilcnt_t f_files fsfilcnt_t f_ffree fsfilcnt_t f_favail unsigned long f_namemax cdef extern from "xattr.h" nogil: int setxattr_p (char *path, char *name, void *value, int size, int namespace) ssize_t getxattr_p (char *path, char *name, void *value, int size, int namespace) enum: EXTATTR_NAMESPACE_SYSTEM EXTATTR_NAMESPACE_USER XATTR_CREATE XATTR_REPLACE XATTR_NOFOLLOW XATTR_NODEFAULT XATTR_NOSECURITY cdef extern from "gettime.h" nogil: int gettime_realtime(timespec *tp) cdef extern from "" nogil: int syncfs(int fd) pyfuse3-3.2.0/LICENSE0000664000175000017500000006255013347452777015636 0ustar nikrationikratio00000000000000This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. For reference, the full text of the GNU Lesser General Public License Version 2 is included below: GNU LIBRARY GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. [This is the first released version of the library GPL. It is numbered 2 because it goes with version 2 of the ordinary GPL.] Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public Licenses are intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This license, the Library General Public License, applies to some specially designated Free Software Foundation software, and to any other libraries whose authors decide to use it. You can use it for your libraries, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the library, or if you modify it. For example, if you distribute copies of the library, whether gratis or for a fee, you must give the recipients all the rights that we gave you. You must make sure that they, too, receive or can get the source code. If you link a program with the library, you must provide complete object files to the recipients so that they can relink them with the library, after making changes to the library and recompiling it. And you must show them these terms so they know their rights. Our method of protecting your rights has two steps: (1) copyright the library, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the library. Also, for each distributor's protection, we want to make certain that everyone understands that there is no warranty for this free library. If the library is modified by someone else and passed on, we want its recipients to know that what they have is not the original version, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that companies distributing free software will individually obtain patent licenses, thus in effect transforming the program into proprietary software. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. Most GNU software, including some libraries, is covered by the ordinary GNU General Public License, which was designed for utility programs. This license, the GNU Library General Public License, applies to certain designated libraries. This license is quite different from the ordinary one; be sure to read it in full, and don't assume that anything in it is the same as in the ordinary license. The reason we have a separate public license for some libraries is that they blur the distinction we usually make between modifying or adding to a program and simply using it. Linking a program with a library, without changing the library, is in some sense simply using the library, and is analogous to running a utility program or application program. However, in a textual and legal sense, the linked executable is a combined work, a derivative of the original library, and the ordinary General Public License treats it as such. Because of this blurred distinction, using the ordinary General Public License for libraries did not effectively promote software sharing, because most developers did not use the libraries. We concluded that weaker conditions might promote sharing better. However, unrestricted linking of non-free programs would deprive the users of those programs of all benefit from the free status of the libraries themselves. This Library General Public License is intended to permit developers of non-free programs to use free libraries, while preserving your freedom as a user of such programs to change the free libraries that are incorporated in them. (We have not seen how to achieve this as regards changes in header files, but we have achieved it as regards changes in the actual functions of the Library.) The hope is that this will lead to faster development of free libraries. The precise terms and conditions for copying, distribution and modification follow. Pay close attention to the difference between a "work based on the library" and a "work that uses the library". The former contains code derived from the library, while the latter only works together with the library. Note that it is possible for a library to be covered by the ordinary General Public License rather than by this special one. GNU LIBRARY GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License Agreement applies to any software library which contains a notice placed by the copyright holder or other authorized party saying it may be distributed under the terms of this Library General Public License (also called "this License"). Each licensee is addressed as "you". A "library" means a collection of software functions and/or data prepared so as to be conveniently linked with application programs (which use some of those functions and data) to form executables. The "Library", below, refers to any such software library or work which has been distributed under these terms. A "work based on the Library" means either the Library or any derivative work under copyright law: that is to say, a work containing the Library or a portion of it, either verbatim or with modifications and/or translated straightforwardly into another language. (Hereinafter, translation is included without limitation in the term "modification".) "Source code" for a work means the preferred form of the work for making modifications to it. For a library, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the library. Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running a program using the Library is not restricted, and output from such a program is covered only if its contents constitute a work based on the Library (independent of the use of the Library in a tool for writing it). Whether that is true depends on what the Library does and what the program that uses the Library does. 1. You may copy and distribute verbatim copies of the Library's complete source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and distribute a copy of this License along with the Library. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Library or any portion of it, thus forming a work based on the Library, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) The modified work must itself be a software library. b) You must cause the files modified to carry prominent notices stating that you changed the files and the date of any change. c) You must cause the whole of the work to be licensed at no charge to all third parties under the terms of this License. d) If a facility in the modified Library refers to a function or a table of data to be supplied by an application program that uses the facility, other than as an argument passed when the facility is invoked, then you must make a good faith effort to ensure that, in the event an application does not supply such function or table, the facility still operates, and performs whatever part of its purpose remains meaningful. (For example, a function in a library to compute square roots has a purpose that is entirely well-defined independent of the application. Therefore, Subsection 2d requires that any application-supplied function or table used by this function must be optional: if the application does not supply it, the square root function must still compute square roots.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Library, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Library, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Library. In addition, mere aggregation of another work not based on the Library with the Library (or with a work based on the Library) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may opt to apply the terms of the ordinary GNU General Public License instead of this License to a given copy of the Library. To do this, you must alter all the notices that refer to this License, so that they refer to the ordinary GNU General Public License, version 2, instead of to this License. (If a newer version than version 2 of the ordinary GNU General Public License has appeared, then you can specify that version instead if you wish.) Do not make any other change in these notices. Once this change is made in a given copy, it is irreversible for that copy, so the ordinary GNU General Public License applies to all subsequent copies and derivative works made from that copy. This option is useful when you wish to copy part of the code of the Library into a program that is not a library. 4. You may copy and distribute the Library (or a portion or derivative of it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange. If distribution of object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place satisfies the requirement to distribute the source code, even though third parties are not compelled to copy the source along with the object code. 5. A program that contains no derivative of any portion of the Library, but is designed to work with the Library by being compiled or linked with it, is called a "work that uses the Library". Such a work, in isolation, is not a derivative work of the Library, and therefore falls outside the scope of this License. However, linking a "work that uses the Library" with the Library creates an executable that is a derivative of the Library (because it contains portions of the Library), rather than a "work that uses the library". The executable is therefore covered by this License. Section 6 states terms for distribution of such executables. When a "work that uses the Library" uses material from a header file that is part of the Library, the object code for the work may be a derivative work of the Library even though the source code is not. Whether this is true is especially significant if the work can be linked without the Library, or if the work is itself a library. The threshold for this to be true is not precisely defined by law. If such an object file uses only numerical parameters, data structure layouts and accessors, and small macros and small inline functions (ten lines or less in length), then the use of the object file is unrestricted, regardless of whether it is legally a derivative work. (Executables containing this object code plus portions of the Library will still fall under Section 6.) Otherwise, if the work is a derivative of the Library, you may distribute the object code for the work under the terms of Section 6. Any executables containing that work also fall under Section 6, whether or not they are linked directly with the Library itself. 6. As an exception to the Sections above, you may also compile or link a "work that uses the Library" with the Library to produce a work containing portions of the Library, and distribute that work under terms of your choice, provided that the terms permit modification of the work for the customer's own use and reverse engineering for debugging such modifications. You must give prominent notice with each copy of the work that the Library is used in it and that the Library and its use are covered by this License. You must supply a copy of this License. If the work during execution displays copyright notices, you must include the copyright notice for the Library among them, as well as a reference directing the user to the copy of this License. Also, you must do one of these things: a) Accompany the work with the complete corresponding machine-readable source code for the Library including whatever changes were used in the work (which must be distributed under Sections 1 and 2 above); and, if the work is an executable linked with the Library, with the complete machine-readable "work that uses the Library", as object code and/or source code, so that the user can modify the Library and then relink to produce a modified executable containing the modified Library. (It is understood that the user who changes the contents of definitions files in the Library will not necessarily be able to recompile the application to use the modified definitions.) b) Accompany the work with a written offer, valid for at least three years, to give the same user the materials specified in Subsection 6a, above, for a charge no more than the cost of performing this distribution. c) If distribution of the work is made by offering access to copy from a designated place, offer equivalent access to copy the above specified materials from the same place. d) Verify that the user has already received a copy of these materials or that you have already sent this user a copy. For an executable, the required form of the "work that uses the Library" must include any data and utility programs needed for reproducing the executable from it. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. It may happen that this requirement contradicts the license restrictions of other proprietary libraries that do not normally accompany the operating system. Such a contradiction means you cannot use both them and the Library together in an executable that you distribute. 7. You may place library facilities that are a work based on the Library side-by-side in a single library together with other library facilities not covered by this License, and distribute such a combined library, provided that the separate distribution of the work based on the Library and of the other library facilities is otherwise permitted, and provided that you do these two things: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities. This must be distributed under the terms of the Sections above. b) Give prominent notice with the combined library of the fact that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 8. You may not copy, modify, sublicense, link with, or distribute the Library except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense, link with, or distribute the Library is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 9. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Library or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Library (or any work based on the Library), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Library or works based on it. 10. Each time you redistribute the Library (or any work based on the Library), the recipient automatically receives a license from the original licensor to copy, distribute, link with or modify the Library subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 11. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Library at all. For example, if a patent license would not permit royalty-free redistribution of the Library by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Library. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply, and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 12. If the distribution and/or use of the Library is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Library under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 13. The Free Software Foundation may publish revised and/or new versions of the Library General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Library does not specify a license version number, you may choose any version ever published by the Free Software Foundation. 14. If you wish to incorporate parts of the Library into other free programs whose distribution conditions are incompatible with these, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Libraries If you develop a new library, and you want it to be of the greatest possible use to the public, we recommend making it free software that everyone can redistribute and change. You can do so by permitting redistribution under these terms (or, alternatively, under the terms of the ordinary General Public License). To apply these terms, attach the following notices to the library. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Also add information on how to contact you by electronic and paper mail. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the library, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the library `Frob' (a library for tweaking knobs) written by James Random Hacker. , 1 April 1990 Ty Coon, President of Vice That's all there is to it! pyfuse3-3.2.0/PKG-INFO0000664000175000017500000000550513773156367015722 0ustar nikrationikratio00000000000000Metadata-Version: 1.2 Name: pyfuse3 Version: 3.2.0 Summary: Python 3 bindings for libfuse 3 with async I/O support Home-page: https://github.com/libfuse/pyfuse3 Author: Nikolaus Rath Author-email: Nikolaus@rath.org License: LGPL Description: .. NOTE: We cannot use sophisticated ReST syntax (like e.g. :file:`foo`) here because this isn't rendered correctly by PyPi and/or BitBucket. The pyfuse3 Module ================== .. start-intro pyfuse3 is a set of Python 3 bindings for `libfuse 3`_. It provides an asynchronous API compatible with Trio_ and asyncio_, and enables you to easily write a full-featured Linux filesystem in Python. pyfuse3 releases can be downloaded from PyPi_. The documentation can be `read online`__ and is also included in the ``doc/html`` directory of the pyfuse3 tarball. Getting Help ------------ Please report any bugs on the `issue tracker`_. For discussion and questions, please use the general `FUSE mailing list`_. A searchable `mailing list archive`_ is kindly provided by Gmane_. Development Status ------------------ pyfuse3 is in beta. Bugs are likely. pyfuse3 uses semantic versioning. This means backwards incompatible changes in the API will be reflected in an increase of the major version number. Contributing ------------ The pyfuse3 source code is available on GitHub_. .. __: http://www.rath.org/pyfuse3-docs/ .. _libfuse 3: http://github.com/libfuse/libfuse .. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel .. _issue tracker: https://github.com/libfuse/pyfuse3/issues .. _mailing list archive: http://dir.gmane.org/gmane.comp.file-systems.fuse.devel .. _Gmane: http://www.gmane.org/ .. _PyPi: https://pypi.python.org/pypi/pyfuse3/ .. _GitHub: https://github.com/libfuse/pyfuse3 .. _Trio: https://github.com/python-trio/trio .. _asyncio: https://docs.python.org/3/library/asyncio.html Keywords: FUSE,python Platform: Linux Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Filesystems Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) Classifier: Operating System :: POSIX :: Linux Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: POSIX :: BSD :: FreeBSD Provides: pyfuse3 Requires-Python: >=3.5 pyfuse3-3.2.0/README.rst0000664000175000017500000000315213714314300016262 0ustar nikrationikratio00000000000000.. NOTE: We cannot use sophisticated ReST syntax (like e.g. :file:`foo`) here because this isn't rendered correctly by PyPi and/or BitBucket. The pyfuse3 Module ================== .. start-intro pyfuse3 is a set of Python 3 bindings for `libfuse 3`_. It provides an asynchronous API compatible with Trio_ and asyncio_, and enables you to easily write a full-featured Linux filesystem in Python. pyfuse3 releases can be downloaded from PyPi_. The documentation can be `read online`__ and is also included in the ``doc/html`` directory of the pyfuse3 tarball. Getting Help ------------ Please report any bugs on the `issue tracker`_. For discussion and questions, please use the general `FUSE mailing list`_. A searchable `mailing list archive`_ is kindly provided by Gmane_. Development Status ------------------ pyfuse3 is in beta. Bugs are likely. pyfuse3 uses semantic versioning. This means backwards incompatible changes in the API will be reflected in an increase of the major version number. Contributing ------------ The pyfuse3 source code is available on GitHub_. .. __: http://www.rath.org/pyfuse3-docs/ .. _libfuse 3: http://github.com/libfuse/libfuse .. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel .. _issue tracker: https://github.com/libfuse/pyfuse3/issues .. _mailing list archive: http://dir.gmane.org/gmane.comp.file-systems.fuse.devel .. _Gmane: http://www.gmane.org/ .. _PyPi: https://pypi.python.org/pypi/pyfuse3/ .. _GitHub: https://github.com/libfuse/pyfuse3 .. _Trio: https://github.com/python-trio/trio .. _asyncio: https://docs.python.org/3/library/asyncio.html pyfuse3-3.2.0/doc/0000775000175000017500000000000013773156367015365 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/doc/html/0000775000175000017500000000000013773156367016331 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/doc/html/.buildinfo0000664000175000017500000000034613773155703020301 0ustar nikrationikratio00000000000000# Sphinx build info version 1 # This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. config: eb00a7d29c6865557a0e37183f4f3fca tags: 645f666f9bcd5a90fca523b33c5a78b7 pyfuse3-3.2.0/doc/html/_sources/0000775000175000017500000000000013773156367020153 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/doc/html/_sources/about.rst.txt0000664000175000017500000000012013347452777022627 0ustar nikrationikratio00000000000000======= About ======= .. include:: ../README.rst :start-after: start-intro pyfuse3-3.2.0/doc/html/_sources/asyncio.rst.txt0000664000175000017500000000074513403544526023162 0ustar nikrationikratio00000000000000.. _asyncio: ================= asyncio Support ================= By default, pyfuse3 uses asynchronous I/O using Trio_ (and most of the documentation assumes that you are using Trio). If you'd rather use asyncio, import the *pyfuse3_asyncio* module and call its *enable()* function before using *pyfuse3*. For example:: import pyfuse3 import pyfuse3_asyncio pyfuse3_asyncio.enable() # Use pyfuse3 as usual from here on. .. _Trio: https://github.com/python-trio/trio pyfuse3-3.2.0/doc/html/_sources/changes.rst.txt0000664000175000017500000000003413347452777023131 0ustar nikrationikratio00000000000000.. include:: ../Changes.rst pyfuse3-3.2.0/doc/html/_sources/data.rst.txt0000664000175000017500000000756113636701554022435 0ustar nikrationikratio00000000000000================= Data Structures ================= .. currentmodule:: pyfuse3 .. py:data:: ENOATTR This errorcode is unfortunately missing in the `errno` module, so it is provided by pyfuse3 instead. .. py:data:: ROOT_INODE The inode of the root directory, i.e. the mount point of the file system. .. py:data:: RENAME_EXCHANGE A flag that may be passed to the `~Operations.rename` handler. When passed, the handler must atomically exchange the two paths (which must both exist). .. py:data:: RENAME_NOREPLACE A flag that may be passed to the `~Operations.rename` handler. When passed, the handler must not replace an existing target. .. py:data:: default_options This is a recommended set of options that should be passed to `pyfuse3.init` to get reasonable behavior and performance. pyfuse3 is compatible with any other combination of options as well, but you should only deviate from the defaults with good reason. (The :samp:`fsname=` option is guaranteed never to be included in the default options, so you can always safely add it to the set). The default options are: * ``default_permissions`` enables permission checking by kernel. Without this any umask (or uid/gid) would not have an effect. .. autoexception:: FUSEError .. autoclass:: RequestContext .. attribute:: pid .. attribute:: uid .. attribute:: gid .. attribute:: umask .. autoclass:: StatvfsData .. attribute:: f_bsize .. attribute:: f_frsize .. attribute:: f_blocks .. attribute:: f_bfree .. attribute:: f_bavail .. attribute:: f_files .. attribute:: f_ffree .. attribute:: f_favail .. attribute:: f_namemax .. autoclass:: EntryAttributes .. autoattribute:: st_ino .. autoattribute:: generation .. autoattribute:: entry_timeout .. autoattribute:: attr_timeout .. autoattribute:: st_mode .. autoattribute:: st_nlink .. autoattribute:: st_uid .. autoattribute:: st_gid .. autoattribute:: st_rdev .. autoattribute:: st_size .. autoattribute:: st_blksize .. autoattribute:: st_blocks .. autoattribute:: st_atime_ns .. autoattribute:: st_ctime_ns .. autoattribute:: st_mtime_ns .. autoclass:: FileInfo .. autoattribute:: fh This attribute must be set to the file handle to be returned from `Operations.open`. .. autoattribute:: direct_io If true, signals to the kernel that this file should not be cached or buffered. .. autoattribute:: keep_cache If true, signals to the kernel that previously cached data for this inode is still valid, and should not be invalidated. .. autoattribute:: nonseekable If true, indicates that the file does not support seeking. .. autoclass:: SetattrFields .. attribute:: update_atime If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_atime_ns` field contains an updated value. .. attribute:: update_mtime If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_mtime_ns` field contains an updated value. .. attribute:: update_mode If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_mode` field contains an updated value. .. attribute:: update_uid If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_uid` field contains an updated value. .. attribute:: update_gid If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_gid` field contains an updated value. .. attribute:: update_size If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_size` field contains an updated value. pyfuse3-3.2.0/doc/html/_sources/example.rst.txt0000664000175000017500000000145113403544476023147 0ustar nikrationikratio00000000000000.. _example file system: ====================== Example File Systems ====================== pyfuse3 comes with several example file systems in the :file:`examples` directory of the release tarball. For completeness, these examples are also included here. Single-file, Read-only File System ================================== (shipped as :file:`examples/lltest.py`) .. literalinclude:: ../examples/hello.py :linenos: :language: python In-memory File System ===================== (shipped as :file:`examples/tmpfs.py`) .. literalinclude:: ../examples/tmpfs.py :linenos: :language: python Passthrough / Overlay File System ================================= (shipped as :file:`examples/passthroughfs.py`) .. literalinclude:: ../examples/passthroughfs.py :linenos: :language: python pyfuse3-3.2.0/doc/html/_sources/fuse_api.rst.txt0000664000175000017500000000110713772376363023314 0ustar nikrationikratio00000000000000==================== FUSE API Functions ==================== .. currentmodule:: pyfuse3 .. autofunction:: init .. autocofunction:: main .. autofunction:: terminate .. autofunction:: close .. autofunction:: invalidate_inode .. autofunction:: invalidate_entry .. autofunction:: invalidate_entry_async .. autofunction:: notify_store .. autofunction:: readdir_reply .. py:data:: trio_token Set to the value returned by `trio.lowlevel.current_trio_token()` while `main()` is running. Can be used by other threads to run code in the main loop through `trio.from_thread.run`. pyfuse3-3.2.0/doc/html/_sources/general.rst.txt0000664000175000017500000000717613403544474023141 0ustar nikrationikratio00000000000000===================== General Information ===================== .. currentmodule:: pyfuse3 .. _getting_started: Getting started =============== A file system is implemented by subclassing the `pyfuse3.Operations` class and implementing the various request handlers. The handlers respond to requests received from the FUSE kernel module and perform functions like looking up the inode given a file name, looking up attributes of an inode, opening a (file) inode for reading or writing or listing the contents of a (directory) inode. By default, pyfuse3 uses asynchronous I/O using Trio_, and most of the documentation assumes that you are using Trio. If you'd rather use asyncio, take a look at :ref:`asyncio Support `. If you would like to use Trio (which is recommended) but you have not yet used Trio before, please read the `Trio tutorial`_ first. An instance of the operations class is passed to `pyfuse3.init` to mount the file system. To enter the request handling loop, run `pyfuse3.main` in a trio event loop. This function will return when the file system should be unmounted again, which is done by calling `pyfuse3.close`. All character data (directory entry names, extended attribute names and values, symbolic link targets etc) are passed as `bytes` and must be returned as `bytes`. For easier debugging, it is strongly recommended that applications using pyfuse3 also make use of the faulthandler_ module. .. _faulthandler: http://docs.python.org/3/library/faulthandler.html .. _Trio tutorial: https://trio.readthedocs.io/en/latest/tutorial.html .. _Trio: https://github.com/python-trio/trio Lookup Counts ============= Most file systems need to keep track which inodes are currently known to the kernel. This is, for example, necessary to correctly implement the *unlink* system call: when unlinking a directory entry whose associated inode is currently opened, the file system must defer removal of the inode (and thus the file contents) until it is no longer in use by any process. FUSE file systems achieve this by using "lookup counts". A lookup count is a number that's associated with an inode. An inode with a lookup count of zero is currently not known to the kernel. This means that if there are no directory entries referring to such an inode it can be safely removed, or (if a file system implements dynamic inode numbers), the inode number can be safely recycled. The lookup count of an inode is increased by every operation that could make the inode "known" to the kernel. This includes e.g. `~Operations.lookup`, `~Operations.create` and `~Operations.readdir` (to determine if a given request handler affects the lookup count, please refer to its description in the `Operations` class). The lookup count is decreased by calls to the `~Operations.forget` handler. FUSE and VFS Locking ==================== FUSE and the kernel's VFS layer provide some basic locking that FUSE file systems automatically take advantage of. Specifically: * Calls to `~Operations.rename`, `~Operations.create`, `~Operations.symlink`, `~Operations.mknod`, `~Operations.link` and `~Operations.mkdir` acquire a write-lock on the inode of the directory in which the respective operation takes place (two in case of rename). * Calls to `~Operations.lookup` acquire a read-lock on the inode of the parent directory (meaning that lookups in the same directory may run concurrently, but never at the same time as e.g. a rename or mkdir operation). * Unless writeback caching is enabled, calls to `~Operations.write` for the same inode are automatically serialized (i.e., there are never concurrent calls for the same inode even when multithreading is enabled). pyfuse3-3.2.0/doc/html/_sources/gotchas.rst.txt0000664000175000017500000000154513347530014023136 0ustar nikrationikratio00000000000000================ Common Gotchas ================ .. currentmodule:: pyfuse3 This chapter lists some common gotchas that should be avoided. Removing inodes in unlink handler ================================= If your file system is mounted at :file:`mnt`, the following code should complete without errors:: with open('mnt/file_one', 'w+') as fh1: fh1.write('foo') fh1.flush() with open('mnt/file_one', 'a') as fh2: os.unlink('mnt/file_one') assert 'file_one' not in os.listdir('mnt') fh2.write('bar') os.close(os.dup(fh1.fileno())) fh1.seek(0) assert fh1.read() == 'foobar' If you're getting an error, then you probably did a mistake when implementing the `~Operations.unlink` handler and are removing the file contents when you should be deferring removal to the `~Operations.forget` handler. pyfuse3-3.2.0/doc/html/_sources/index.rst.txt0000664000175000017500000000062713403544112022612 0ustar nikrationikratio00000000000000============================= pyfuse3 Documentation ============================= Table of Contents ----------------- .. module:: pyfuse3 .. toctree:: :maxdepth: 1 about.rst install.rst general.rst asyncio.rst fuse_api.rst data.rst operations.rst util.rst gotchas.rst example.rst changes.rst Indices and tables ------------------ * :ref:`genindex` * :ref:`search` pyfuse3-3.2.0/doc/html/_sources/install.rst.txt0000664000175000017500000000426213350426565023164 0ustar nikrationikratio00000000000000============== Installation ============== .. highlight:: sh Dependencies ============ In order to build and run pyfuse3 you need the following software: * Linux kernel 3.9 or newer. * Version 3.3.0 or newer of the libfuse_ library, including development headers (typically distributions provide them in a *libfuse3-devel* or *libfuse3-dev* package). * Python_ 3.5 or newer installed with development headers * The Trio_ Python module, version 0.7 or newer. * The `setuptools`_ Python module, version 1.0 or newer. * the `pkg-config`_ tool * the `attr`_ library * A C compiler (only for building) To run the unit tests, you will need * The `py.test`_ Python module, version 3.3.0 or newer Stable releases =============== To install a stable pyfuse3 release: 1. Download and unpack the release tarball from https://pypi.python.org/pypi/pyfuse3/ 2. Run ``python3 setup.py build_ext --inplace`` to build the C extension 3. Run ``python3 -m pytest test/`` to run a self-test. If this fails, ask for help on the `FUSE mailing list`_ or report a bug in the `issue tracker `_. 4. To install system-wide for all users, run ``sudo python setup.py install``. To install into :file:`~/.local`, run ``python3 setup.py install --user``. Development Version =================== If you have checked out the unstable development version, a bit more effort is required. You need to also have Cython_ (0.28.1 or newer) and Sphinx_ (1.1 or newer) installed, and the necessary commands are:: python3 setup.py build_cython python3 setup.py build_ext --inplace python3 -m pytest test/ python3 setup.py build_sphinx python3 setup.py install .. _Cython: http://www.cython.org/ .. _Sphinx: http://sphinx.pocoo.org/ .. _Python: http://www.python.org/ .. _Trio: https://github.com/python-trio/trio .. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel .. _`py.test`: https://pypi.python.org/pypi/pytest/ .. _libfuse: http://github.com/libfuse/libfuse .. _attr: http://savannah.nongnu.org/projects/attr/ .. _`pkg-config`: http://www.freedesktop.org/wiki/Software/pkg-config .. _setuptools: https://pypi.python.org/pypi/setuptools pyfuse3-3.2.0/doc/html/_sources/operations.rst.txt0000664000175000017500000000235113350426564023675 0ustar nikrationikratio00000000000000================== Request Handlers ================== (You can use the :ref:`genindex` to directly jump to a specific handler). .. currentmodule:: pyfuse3 .. autoclass:: Operations :members: .. attribute:: supports_dot_lookup = True If set, indicates that the filesystem supports lookup of the ``.`` and ``..`` entries. This is required if the file system will be shared over NFS. .. attribute:: enable_writeback_cache = True Enables write-caching in the kernel if available. This means that individual write request may be buffered and merged in the kernel before they are send to the filesystem. .. attribute:: enable_acl = False Enable ACL support. When enabled, the kernel will cache and have responsibility for enforcing ACLs. ACL will be stored as xattrs and passed to userspace, which is responsible for updating the ACLs in the filesystem, keeping the file mode in sync with the ACL, and ensuring inheritance of default ACLs when new filesystem nodes are created. Note that this requires that the file system is able to parse and interpret the xattr representation of ACLs. Enabling this feature implicitly turns on the ``default_permissions`` option. pyfuse3-3.2.0/doc/html/_sources/util.rst.txt0000664000175000017500000000062713354207241022464 0ustar nikrationikratio00000000000000==================== Utility Functions ==================== The following functions do not necessarily translate to calls to the FUSE library. They are provided because they're potentially useful when implementing file systems in Python. .. currentmodule:: pyfuse3 .. autofunction:: setxattr .. autofunction:: getxattr .. autofunction:: listdir .. autofunction:: get_sup_groups .. autofunction:: syncfs pyfuse3-3.2.0/doc/html/_static/0000775000175000017500000000000013773156367017757 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/doc/html/_static/ajax-loader.gif0000664000175000017500000000124113425573275022626 0ustar nikrationikratio00000000000000GIF89aU|NU|l!Created with ajaxload.info! ! NETSCAPE2.0,30Ikc:Nf E1º.`q-[9ݦ9 JkH! ,4N!  DqBQT`1 `LE[|ua C%$*! ,62#+AȐ̔V/cNIBap ̳ƨ+Y2d! ,3b%+2V_ ! 1DaFbR]=08,Ȥr9L! ,2r'+JdL &v`\bThYB)@<&,ȤR! ,3 9tڞ0!.BW1  sa50 m)J! ,2 ٜU]qp`a4AF0` @1Α! ,20IeBԜ) q10ʰPaVڥ ub[;pyfuse3-3.2.0/doc/html/_static/basic.css0000664000175000017500000002524013773155703021546 0ustar nikrationikratio00000000000000/* * basic.css * ~~~~~~~~~ * * Sphinx stylesheet -- basic theme. * * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ /* -- main layout ----------------------------------------------------------- */ div.clearer { clear: both; } /* -- relbar ---------------------------------------------------------------- */ div.related { width: 100%; font-size: 90%; } div.related h3 { display: none; } div.related ul { margin: 0; padding: 0 0 0 10px; list-style: none; } div.related li { display: inline; } div.related li.right { float: right; margin-right: 5px; } /* -- sidebar --------------------------------------------------------------- */ div.sphinxsidebarwrapper { padding: 10px 5px 0 10px; } div.sphinxsidebar { float: left; width: 230px; margin-left: -100%; font-size: 90%; word-wrap: break-word; overflow-wrap : break-word; } div.sphinxsidebar ul { list-style: none; } div.sphinxsidebar ul ul, div.sphinxsidebar ul.want-points { margin-left: 20px; list-style: square; } div.sphinxsidebar ul ul { margin-top: 0; margin-bottom: 0; } div.sphinxsidebar form { margin-top: 10px; } div.sphinxsidebar input { border: 1px solid #98dbcc; font-family: sans-serif; font-size: 1em; } div.sphinxsidebar #searchbox form.search { overflow: hidden; } div.sphinxsidebar #searchbox input[type="text"] { float: left; width: 80%; padding: 0.25em; box-sizing: border-box; } div.sphinxsidebar #searchbox input[type="submit"] { float: left; width: 20%; border-left: none; padding: 0.25em; box-sizing: border-box; } img { border: 0; max-width: 100%; } /* -- search page ----------------------------------------------------------- */ ul.search { margin: 10px 0 0 20px; padding: 0; } ul.search li { padding: 5px 0 5px 20px; background-image: url(file.png); background-repeat: no-repeat; background-position: 0 7px; } ul.search li a { font-weight: bold; } ul.search li div.context { color: #888; margin: 2px 0 0 30px; text-align: left; } ul.keywordmatches li.goodmatch a { font-weight: bold; } /* -- index page ------------------------------------------------------------ */ table.contentstable { width: 90%; margin-left: auto; margin-right: auto; } table.contentstable p.biglink { line-height: 150%; } a.biglink { font-size: 1.3em; } span.linkdescr { font-style: italic; padding-top: 5px; font-size: 90%; } /* -- general index --------------------------------------------------------- */ table.indextable { width: 100%; } table.indextable td { text-align: left; vertical-align: top; } table.indextable ul { margin-top: 0; margin-bottom: 0; list-style-type: none; } table.indextable > tbody > tr > td > ul { padding-left: 0em; } table.indextable tr.pcap { height: 10px; } table.indextable tr.cap { margin-top: 10px; background-color: #f2f2f2; } img.toggler { margin-right: 3px; margin-top: 3px; cursor: pointer; } div.modindex-jumpbox { border-top: 1px solid #ddd; border-bottom: 1px solid #ddd; margin: 1em 0 1em 0; padding: 0.4em; } div.genindex-jumpbox { border-top: 1px solid #ddd; border-bottom: 1px solid #ddd; margin: 1em 0 1em 0; padding: 0.4em; } /* -- domain module index --------------------------------------------------- */ table.modindextable td { padding: 2px; border-collapse: collapse; } /* -- general body styles --------------------------------------------------- */ div.body { min-width: 450px; max-width: 800px; } div.body p, div.body dd, div.body li, div.body blockquote { -moz-hyphens: auto; -ms-hyphens: auto; -webkit-hyphens: auto; hyphens: auto; } a.headerlink { visibility: hidden; } h1:hover > a.headerlink, h2:hover > a.headerlink, h3:hover > a.headerlink, h4:hover > a.headerlink, h5:hover > a.headerlink, h6:hover > a.headerlink, dt:hover > a.headerlink, caption:hover > a.headerlink, p.caption:hover > a.headerlink, div.code-block-caption:hover > a.headerlink { visibility: visible; } div.body p.caption { text-align: inherit; } div.body td { text-align: left; } .first { margin-top: 0 !important; } p.rubric { margin-top: 30px; font-weight: bold; } img.align-left, .figure.align-left, object.align-left { clear: left; float: left; margin-right: 1em; } img.align-right, .figure.align-right, object.align-right { clear: right; float: right; margin-left: 1em; } img.align-center, .figure.align-center, object.align-center { display: block; margin-left: auto; margin-right: auto; } .align-left { text-align: left; } .align-center { text-align: center; } .align-right { text-align: right; } /* -- sidebars -------------------------------------------------------------- */ div.sidebar { margin: 0 0 0.5em 1em; border: 1px solid #ddb; padding: 7px 7px 0 7px; background-color: #ffe; width: 40%; float: right; } p.sidebar-title { font-weight: bold; } /* -- topics ---------------------------------------------------------------- */ div.topic { border: 1px solid #ccc; padding: 7px 7px 0 7px; margin: 10px 0 10px 0; } p.topic-title { font-size: 1.1em; font-weight: bold; margin-top: 10px; } /* -- admonitions ----------------------------------------------------------- */ div.admonition { margin-top: 10px; margin-bottom: 10px; padding: 7px; } div.admonition dt { font-weight: bold; } div.admonition dl { margin-bottom: 0; } p.admonition-title { margin: 0px 10px 5px 0px; font-weight: bold; } div.body p.centered { text-align: center; margin-top: 25px; } /* -- tables ---------------------------------------------------------------- */ table.docutils { border: 0; border-collapse: collapse; } table.align-center { margin-left: auto; margin-right: auto; } table caption span.caption-number { font-style: italic; } table caption span.caption-text { } table.docutils td, table.docutils th { padding: 1px 8px 1px 5px; border-top: 0; border-left: 0; border-right: 0; border-bottom: 1px solid #aaa; } table.footnote td, table.footnote th { border: 0 !important; } th { text-align: left; padding-right: 5px; } table.citation { border-left: solid 1px gray; margin-left: 1px; } table.citation td { border-bottom: none; } /* -- figures --------------------------------------------------------------- */ div.figure { margin: 0.5em; padding: 0.5em; } div.figure p.caption { padding: 0.3em; } div.figure p.caption span.caption-number { font-style: italic; } div.figure p.caption span.caption-text { } /* -- field list styles ----------------------------------------------------- */ table.field-list td, table.field-list th { border: 0 !important; } .field-list ul { margin: 0; padding-left: 1em; } .field-list p { margin: 0; } .field-name { -moz-hyphens: manual; -ms-hyphens: manual; -webkit-hyphens: manual; hyphens: manual; } /* -- hlist styles ---------------------------------------------------------- */ table.hlist td { vertical-align: top; } /* -- other body styles ----------------------------------------------------- */ ol.arabic { list-style: decimal; } ol.loweralpha { list-style: lower-alpha; } ol.upperalpha { list-style: upper-alpha; } ol.lowerroman { list-style: lower-roman; } ol.upperroman { list-style: upper-roman; } dl { margin-bottom: 15px; } dd p { margin-top: 0px; } dd ul, dd table { margin-bottom: 10px; } dd { margin-top: 3px; margin-bottom: 10px; margin-left: 30px; } dt:target, span.highlighted { background-color: #fbe54e; } rect.highlighted { fill: #fbe54e; } dl.glossary dt { font-weight: bold; font-size: 1.1em; } .optional { font-size: 1.3em; } .sig-paren { font-size: larger; } .versionmodified { font-style: italic; } .system-message { background-color: #fda; padding: 5px; border: 3px solid red; } .footnote:target { background-color: #ffa; } .line-block { display: block; margin-top: 1em; margin-bottom: 1em; } .line-block .line-block { margin-top: 0; margin-bottom: 0; margin-left: 1.5em; } .guilabel, .menuselection { font-family: sans-serif; } .accelerator { text-decoration: underline; } .classifier { font-style: oblique; } abbr, acronym { border-bottom: dotted 1px; cursor: help; } /* -- code displays --------------------------------------------------------- */ pre { overflow: auto; overflow-y: hidden; /* fixes display issues on Chrome browsers */ } span.pre { -moz-hyphens: none; -ms-hyphens: none; -webkit-hyphens: none; hyphens: none; } td.linenos pre { padding: 5px 0px; border: 0; background-color: transparent; color: #aaa; } table.highlighttable { margin-left: 0.5em; } table.highlighttable td { padding: 0 0.5em 0 0.5em; } div.code-block-caption { padding: 2px 5px; font-size: small; } div.code-block-caption code { background-color: transparent; } div.code-block-caption + div > div.highlight > pre { margin-top: 0; } div.code-block-caption span.caption-number { padding: 0.1em 0.3em; font-style: italic; } div.code-block-caption span.caption-text { } div.literal-block-wrapper { padding: 1em 1em 0; } div.literal-block-wrapper div.highlight { margin: 0; } code.descname { background-color: transparent; font-weight: bold; font-size: 1.2em; } code.descclassname { background-color: transparent; } code.xref, a code { background-color: transparent; font-weight: bold; } h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { background-color: transparent; } .viewcode-link { float: right; } .viewcode-back { float: right; font-family: sans-serif; } div.viewcode-block:target { margin: -1px -10px; padding: 0 10px; } /* -- math display ---------------------------------------------------------- */ img.math { vertical-align: middle; } div.body div.math p { text-align: center; } span.eqno { float: right; } span.eqno a.headerlink { position: relative; left: 0px; z-index: 1; } div.math:hover a.headerlink { visibility: visible; } /* -- printout stylesheet --------------------------------------------------- */ @media print { div.document, div.documentwrapper, div.bodywrapper { margin: 0 !important; width: 100%; } div.sphinxsidebar, div.related, div.footer, #top-link { display: none; } }pyfuse3-3.2.0/doc/html/_static/classic.css0000664000175000017500000001006213773155703022102 0ustar nikrationikratio00000000000000/* * classic.css_t * ~~~~~~~~~~~~~ * * Sphinx stylesheet -- classic theme. * * :copyright: Copyright 2007-2019 by the Sphinx team, see AUTHORS. * :license: BSD, see LICENSE for details. * */ @import url("basic.css"); /* -- page layout ----------------------------------------------------------- */ body { font-family: sans-serif; font-size: 100%; background-color: #11303d; color: #000; margin: 0; padding: 0; } div.document { background-color: #1c4e63; } div.documentwrapper { float: left; width: 100%; } div.bodywrapper { margin: 0 0 0 230px; } div.body { background-color: #ffffff; color: #000000; padding: 0 20px 30px 20px; } div.footer { color: #ffffff; width: 100%; padding: 9px 0 9px 0; text-align: center; font-size: 75%; } div.footer a { color: #ffffff; text-decoration: underline; } div.related { background-color: #133f52; line-height: 30px; color: #ffffff; } div.related a { color: #ffffff; } div.sphinxsidebar { } div.sphinxsidebar h3 { font-family: 'Trebuchet MS', sans-serif; color: #ffffff; font-size: 1.4em; font-weight: normal; margin: 0; padding: 0; } div.sphinxsidebar h3 a { color: #ffffff; } div.sphinxsidebar h4 { font-family: 'Trebuchet MS', sans-serif; color: #ffffff; font-size: 1.3em; font-weight: normal; margin: 5px 0 0 0; padding: 0; } div.sphinxsidebar p { color: #ffffff; } div.sphinxsidebar p.topless { margin: 5px 10px 10px 10px; } div.sphinxsidebar ul { margin: 10px; padding: 0; color: #ffffff; } div.sphinxsidebar a { color: #98dbcc; } div.sphinxsidebar input { border: 1px solid #98dbcc; font-family: sans-serif; font-size: 1em; } /* -- hyperlink styles ------------------------------------------------------ */ a { color: #355f7c; text-decoration: none; } a:visited { color: #355f7c; text-decoration: none; } a:hover { text-decoration: underline; } /* -- body styles ----------------------------------------------------------- */ div.body h1, div.body h2, div.body h3, div.body h4, div.body h5, div.body h6 { font-family: 'Trebuchet MS', sans-serif; background-color: #f2f2f2; font-weight: normal; color: #20435c; border-bottom: 1px solid #ccc; margin: 20px -20px 10px -20px; padding: 3px 0 3px 10px; } div.body h1 { margin-top: 0; font-size: 200%; } div.body h2 { font-size: 160%; } div.body h3 { font-size: 140%; } div.body h4 { font-size: 120%; } div.body h5 { font-size: 110%; } div.body h6 { font-size: 100%; } a.headerlink { color: #c60f0f; font-size: 0.8em; padding: 0 4px 0 4px; text-decoration: none; } a.headerlink:hover { background-color: #c60f0f; color: white; } div.body p, div.body dd, div.body li, div.body blockquote { text-align: justify; line-height: 130%; } div.admonition p.admonition-title + p { display: inline; } div.admonition p { margin-bottom: 5px; } div.admonition pre { margin-bottom: 5px; } div.admonition ul, div.admonition ol { margin-bottom: 5px; } div.note { background-color: #eee; border: 1px solid #ccc; } div.seealso { background-color: #ffc; border: 1px solid #ff6; } div.topic { background-color: #eee; } div.warning { background-color: #ffe4e4; border: 1px solid #f66; } p.admonition-title { display: inline; } p.admonition-title:after { content: ":"; } pre { padding: 5px; background-color: #eeffcc; color: #333333; line-height: 120%; border: 1px solid #ac9; border-left: none; border-right: none; } code { background-color: #ecf0f3; padding: 0 1px 0 1px; font-size: 0.95em; } th { background-color: #ede; } .warning code { background: #efc2c2; } .note code { background: #d6d6d6; } .viewcode-back { font-family: sans-serif; } div.viewcode-block:target { background-color: #f4debf; border-top: 1px solid #ac9; border-bottom: 1px solid #ac9; } div.code-block-caption { color: #efefef; background-color: #1c4e63; }pyfuse3-3.2.0/doc/html/_static/comment-bright.png0000664000175000017500000000136413425573275023403 0ustar nikrationikratio00000000000000PNG  IHDRaIDATx<ߙm۶m۶qm۶m۶mM=D8tٍ\{56j>Qn~3sD{oS+ٻ؀=nnW?XumAHI%pHscYoo_{Z)48sڳۗ8YüYsj34s^#ǒtˋqkZܜwݿߵ>!8pVn{շ=n$p\^;=;wPIENDB`pyfuse3-3.2.0/doc/html/_static/comment-close.png0000664000175000017500000000147513425573275023234 0ustar nikrationikratio00000000000000PNG  IHDRaIDATxm8$km۶m۶m۶m۶AMfp:O'e$Qq aO[B3U9Og+ł-81dw=7q1CKa~ ʏ lϕ]O4l!A@@wny^xa*;1uSWݦO<*7g>b~yޞ mN\(t:+tU&>9Z}Ok=wԈ=ehjo OSd̳m#(2ڮ&!Q&$|~\>&nMK<+W 7zɫ ?w!8_O ާ4& MS'/қ=rּ`V0!?t'$#'P`iawP?Dãqف.`Ž lZ%9A {EҺ !;e`fT]P]ZCDX2e)ןryOZs߂Ј {1<*Bx `(B42|k@=PAȚe; HͭU`B@(IϚR F"a(. |R*wZB/bZ fMQ+d!!065.9Eq+@3ىVSËd8;&KpHh0f;hY,]|Lcne!fKcJFiySOhמ%ws vaJ{ڣ;/S3 ?qcC\qHxsemk2n= 0 && !jQuery(node.parentNode).hasClass(className) && !jQuery(node.parentNode).hasClass("nohighlight")) { var span; var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); if (isInSVG) { span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); } else { span = document.createElement("span"); span.className = className; } span.appendChild(document.createTextNode(val.substr(pos, text.length))); node.parentNode.insertBefore(span, node.parentNode.insertBefore( document.createTextNode(val.substr(pos + text.length)), node.nextSibling)); node.nodeValue = val.substr(0, pos); if (isInSVG) { var bbox = span.getBBox(); var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); rect.x.baseVal.value = bbox.x; rect.y.baseVal.value = bbox.y; rect.width.baseVal.value = bbox.width; rect.height.baseVal.value = bbox.height; rect.setAttribute('class', className); var parentOfText = node.parentNode.parentNode; addItems.push({ "parent": node.parentNode, "target": rect}); } } } else if (!jQuery(node).is("button, select, textarea")) { jQuery.each(node.childNodes, function() { highlight(this, addItems); }); } } var addItems = []; var result = this.each(function() { highlight(this, addItems); }); for (var i = 0; i < addItems.length; ++i) { jQuery(addItems[i].parent).before(addItems[i].target); } return result; }; /* * backward compatibility for jQuery.browser * This will be supported until firefox bug is fixed. */ if (!jQuery.browser) { jQuery.uaMatch = function(ua) { ua = ua.toLowerCase(); var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || /(webkit)[ \/]([\w.]+)/.exec(ua) || /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || /(msie) ([\w.]+)/.exec(ua) || ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || []; return { browser: match[ 1 ] || "", version: match[ 2 ] || "0" }; }; jQuery.browser = {}; jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; } /** * Small JavaScript module for the documentation. */ var Documentation = { init : function() { this.fixFirefoxAnchorBug(); this.highlightSearchWords(); this.initIndexTable(); if (DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) { this.initOnKeyListeners(); } }, /** * i18n support */ TRANSLATIONS : {}, PLURAL_EXPR : function(n) { return n === 1 ? 0 : 1; }, LOCALE : 'unknown', // gettext and ngettext don't access this so that the functions // can safely bound to a different name (_ = Documentation.gettext) gettext : function(string) { var translated = Documentation.TRANSLATIONS[string]; if (typeof translated === 'undefined') return string; return (typeof translated === 'string') ? translated : translated[0]; }, ngettext : function(singular, plural, n) { var translated = Documentation.TRANSLATIONS[singular]; if (typeof translated === 'undefined') return (n == 1) ? singular : plural; return translated[Documentation.PLURALEXPR(n)]; }, addTranslations : function(catalog) { for (var key in catalog.messages) this.TRANSLATIONS[key] = catalog.messages[key]; this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')'); this.LOCALE = catalog.locale; }, /** * add context elements like header anchor links */ addContextElements : function() { $('div[id] > :header:first').each(function() { $('\u00B6'). attr('href', '#' + this.id). attr('title', _('Permalink to this headline')). appendTo(this); }); $('dt[id]').each(function() { $('\u00B6'). attr('href', '#' + this.id). attr('title', _('Permalink to this definition')). appendTo(this); }); }, /** * workaround a firefox stupidity * see: https://bugzilla.mozilla.org/show_bug.cgi?id=645075 */ fixFirefoxAnchorBug : function() { if (document.location.hash && $.browser.mozilla) window.setTimeout(function() { document.location.href += ''; }, 10); }, /** * highlight the search words provided in the url in the text */ highlightSearchWords : function() { var params = $.getQueryParameters(); var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : []; if (terms.length) { var body = $('div.body'); if (!body.length) { body = $('body'); } window.setTimeout(function() { $.each(terms, function() { body.highlightText(this.toLowerCase(), 'highlighted'); }); }, 10); $('

' + _('Hide Search Matches') + '

') .appendTo($('#searchbox')); } }, /** * init the domain index toggle buttons */ initIndexTable : function() { var togglers = $('img.toggler').click(function() { var src = $(this).attr('src'); var idnum = $(this).attr('id').substr(7); $('tr.cg-' + idnum).toggle(); if (src.substr(-9) === 'minus.png') $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); else $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); }).css('display', ''); if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { togglers.click(); } }, /** * helper function to hide the search marks again */ hideSearchWords : function() { $('#searchbox .highlight-link').fadeOut(300); $('span.highlighted').removeClass('highlighted'); }, /** * make the url absolute */ makeURL : function(relativeURL) { return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; }, /** * get the current relative url */ getCurrentURL : function() { var path = document.location.pathname; var parts = path.split(/\//); $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { if (this === '..') parts.pop(); }); var url = parts.join('/'); return path.substring(url.lastIndexOf('/') + 1, path.length - 1); }, initOnKeyListeners: function() { $(document).keyup(function(event) { var activeElementType = document.activeElement.tagName; // don't navigate when in search box or textarea if (activeElementType !== 'TEXTAREA' && activeElementType !== 'INPUT' && activeElementType !== 'SELECT') { switch (event.keyCode) { case 37: // left var prevHref = $('link[rel="prev"]').prop('href'); if (prevHref) { window.location.href = prevHref; return false; } case 39: // right var nextHref = $('link[rel="next"]').prop('href'); if (nextHref) { window.location.href = nextHref; return false; } } } }); } }; // quick alias for translations _ = Documentation.gettext; $(document).ready(function() { Documentation.init(); }); pyfuse3-3.2.0/doc/html/_static/documentation_options.js0000664000175000017500000000046513773155703024737 0ustar nikrationikratio00000000000000var DOCUMENTATION_OPTIONS = { URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'), VERSION: '3.2.0', LANGUAGE: 'None', COLLAPSE_INDEX: false, FILE_SUFFIX: '.html', HAS_SOURCE: true, SOURCELINK_SUFFIX: '.txt', NAVIGATION_WITH_KEYS: false, };pyfuse3-3.2.0/doc/html/_static/down-pressed.png0000664000175000017500000000033613425573275023074 0ustar nikrationikratio00000000000000PNG  IHDRaIDATxc@J@lKf[^g%_  HK ĿD Ab3CGhr.x/`X Wʱ 2 eF+,.xEJ lAR $WT?0i)1maUIENDB`pyfuse3-3.2.0/doc/html/_static/down.png0000664000175000017500000000031213425573275021423 0ustar nikrationikratio00000000000000PNG  IHDR7IDATxP@ @Iߗ`&"z6xK@kbϢxs]M :/+gPd2GeÐ~߸J_c S_ S%exdU](UH>&;4i$n3> ycdIENDB`pyfuse3-3.2.0/doc/html/_static/file.png0000664000175000017500000000043613425201454021365 0ustar nikrationikratio00000000000000PNG  IHDRaIDATxR){l ۶f=@ :3~箄rX$AX-D ~ lj(P%8<<9:: PO&$ l~X&EW^4wQ}^ͣ i0/H/@F)Dzq+j[SU5h/oY G&Lfs|{3%U+S`AFIENDB`pyfuse3-3.2.0/doc/html/_static/jquery.js0000664000175000017500000102270113456270063021623 0ustar nikrationikratio00000000000000/*! * jQuery JavaScript Library v3.3.1-dfsg * https://jquery.com/ * * Includes Sizzle.js * https://sizzlejs.com/ * * Copyright JS Foundation and other contributors * Released under the MIT license * https://jquery.org/license * * Date: 2019-04-19T06:52Z */ ( function( global, factory ) { "use strict"; if ( typeof module === "object" && typeof module.exports === "object" ) { // For CommonJS and CommonJS-like environments where a proper `window` // is present, execute the factory and get jQuery. // For environments that do not have a `window` with a `document` // (such as Node.js), expose a factory as module.exports. // This accentuates the need for the creation of a real `window`. // e.g. var jQuery = require("jquery")(window); // See ticket #14549 for more info. module.exports = global.document ? factory( global, true ) : function( w ) { if ( !w.document ) { throw new Error( "jQuery requires a window with a document" ); } return factory( w ); }; } else { factory( global ); } // Pass this if window is not defined yet } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common // enough that all such attempts are guarded in a try block. var arr = []; var document = window.document; var getProto = Object.getPrototypeOf; var slice = arr.slice; var concat = arr.concat; var push = arr.push; var indexOf = arr.indexOf; var class2type = {}; var toString = class2type.toString; var hasOwn = class2type.hasOwnProperty; var fnToString = hasOwn.toString; var ObjectFunctionString = fnToString.call( Object ); var support = {}; var isFunction = function isFunction( obj ) { // Support: Chrome <=57, Firefox <=52 // In some browsers, typeof returns "function" for HTML elements // (i.e., `typeof document.createElement( "object" ) === "function"`). // We don't want to classify *any* DOM node as a function. return typeof obj === "function" && typeof obj.nodeType !== "number"; }; var isWindow = function isWindow( obj ) { return obj != null && obj === obj.window; }; var preservedScriptAttributes = { type: true, src: true, noModule: true }; function DOMEval( code, doc, node ) { doc = doc || document; var i, script = doc.createElement( "script" ); script.text = code; if ( node ) { for ( i in preservedScriptAttributes ) { if ( node[ i ] ) { script[ i ] = node[ i ]; } } } doc.head.appendChild( script ).parentNode.removeChild( script ); } function toType( obj ) { if ( obj == null ) { return obj + ""; } // Support: Android <=2.3 only (functionish RegExp) return typeof obj === "object" || typeof obj === "function" ? class2type[ toString.call( obj ) ] || "object" : typeof obj; } /* global Symbol */ // Defining this global in .eslintrc.json would create a danger of using the global // unguarded in another place, it seems safer to define global only for this module var version = "3.3.1", // Define a local copy of jQuery jQuery = function( selector, context ) { // The jQuery object is actually just the init constructor 'enhanced' // Need init if jQuery is called (just allow error to be thrown if not included) return new jQuery.fn.init( selector, context ); }, // Support: Android <=4.0 only // Make sure we trim BOM and NBSP rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g; jQuery.fn = jQuery.prototype = { // The current version of jQuery being used jquery: version, constructor: jQuery, // The default length of a jQuery object is 0 length: 0, toArray: function() { return slice.call( this ); }, // Get the Nth element in the matched element set OR // Get the whole matched element set as a clean array get: function( num ) { // Return all the elements in a clean array if ( num == null ) { return slice.call( this ); } // Return just the one element from the set return num < 0 ? this[ num + this.length ] : this[ num ]; }, // Take an array of elements and push it onto the stack // (returning the new matched element set) pushStack: function( elems ) { // Build a new jQuery matched element set var ret = jQuery.merge( this.constructor(), elems ); // Add the old object onto the stack (as a reference) ret.prevObject = this; // Return the newly-formed element set return ret; }, // Execute a callback for every element in the matched set. each: function( callback ) { return jQuery.each( this, callback ); }, map: function( callback ) { return this.pushStack( jQuery.map( this, function( elem, i ) { return callback.call( elem, i, elem ); } ) ); }, slice: function() { return this.pushStack( slice.apply( this, arguments ) ); }, first: function() { return this.eq( 0 ); }, last: function() { return this.eq( -1 ); }, eq: function( i ) { var len = this.length, j = +i + ( i < 0 ? len : 0 ); return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); }, end: function() { return this.prevObject || this.constructor(); }, // For internal use only. // Behaves like an Array's method, not like a jQuery method. push: push, sort: arr.sort, splice: arr.splice }; jQuery.extend = jQuery.fn.extend = function() { var options, name, src, copy, copyIsArray, clone, target = arguments[ 0 ] || {}, i = 1, length = arguments.length, deep = false; // Handle a deep copy situation if ( typeof target === "boolean" ) { deep = target; // Skip the boolean and the target target = arguments[ i ] || {}; i++; } // Handle case when target is a string or something (possible in deep copy) if ( typeof target !== "object" && !isFunction( target ) ) { target = {}; } // Extend jQuery itself if only one argument is passed if ( i === length ) { target = this; i--; } for ( ; i < length; i++ ) { // Only deal with non-null/undefined values if ( ( options = arguments[ i ] ) != null ) { // Extend the base object for ( name in options ) { src = target[ name ]; copy = options[ name ]; // Prevent Object.prototype pollution // Prevent never-ending loop if ( name === "__proto__" || target === copy ) { continue; } // Recurse if we're merging plain objects or arrays if ( deep && copy && ( jQuery.isPlainObject( copy ) || ( copyIsArray = Array.isArray( copy ) ) ) ) { if ( copyIsArray ) { copyIsArray = false; clone = src && Array.isArray( src ) ? src : []; } else { clone = src && jQuery.isPlainObject( src ) ? src : {}; } // Never move original objects, clone them target[ name ] = jQuery.extend( deep, clone, copy ); // Don't bring in undefined values } else if ( copy !== undefined ) { target[ name ] = copy; } } } } // Return the modified object return target; }; jQuery.extend( { // Unique for each copy of jQuery on the page expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), // Assume jQuery is ready without the ready module isReady: true, error: function( msg ) { throw new Error( msg ); }, noop: function() {}, isPlainObject: function( obj ) { var proto, Ctor; // Detect obvious negatives // Use toString instead of jQuery.type to catch host objects if ( !obj || toString.call( obj ) !== "[object Object]" ) { return false; } proto = getProto( obj ); // Objects with no prototype (e.g., `Object.create( null )`) are plain if ( !proto ) { return true; } // Objects with prototype are plain iff they were constructed by a global Object function Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; }, isEmptyObject: function( obj ) { /* eslint-disable no-unused-vars */ // See https://github.com/eslint/eslint/issues/6125 var name; for ( name in obj ) { return false; } return true; }, // Evaluates a script in a global context globalEval: function( code ) { DOMEval( code ); }, each: function( obj, callback ) { var length, i = 0; if ( isArrayLike( obj ) ) { length = obj.length; for ( ; i < length; i++ ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; } } } else { for ( i in obj ) { if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { break; } } } return obj; }, // Support: Android <=4.0 only trim: function( text ) { return text == null ? "" : ( text + "" ).replace( rtrim, "" ); }, // results is for internal usage only makeArray: function( arr, results ) { var ret = results || []; if ( arr != null ) { if ( isArrayLike( Object( arr ) ) ) { jQuery.merge( ret, typeof arr === "string" ? [ arr ] : arr ); } else { push.call( ret, arr ); } } return ret; }, inArray: function( elem, arr, i ) { return arr == null ? -1 : indexOf.call( arr, elem, i ); }, // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit merge: function( first, second ) { var len = +second.length, j = 0, i = first.length; for ( ; j < len; j++ ) { first[ i++ ] = second[ j ]; } first.length = i; return first; }, grep: function( elems, callback, invert ) { var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert; // Go through the array, only saving the items // that pass the validator function for ( ; i < length; i++ ) { callbackInverse = !callback( elems[ i ], i ); if ( callbackInverse !== callbackExpect ) { matches.push( elems[ i ] ); } } return matches; }, // arg is for internal usage only map: function( elems, callback, arg ) { var length, value, i = 0, ret = []; // Go through the array, translating each of the items to their new values if ( isArrayLike( elems ) ) { length = elems.length; for ( ; i < length; i++ ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret.push( value ); } } // Go through every key on the object, } else { for ( i in elems ) { value = callback( elems[ i ], i, arg ); if ( value != null ) { ret.push( value ); } } } // Flatten any nested arrays return concat.apply( [], ret ); }, // A global GUID counter for objects guid: 1, // jQuery.support is not used in Core but other projects attach their // properties to it so it needs to exist. support: support } ); if ( typeof Symbol === "function" ) { jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; } // Populate the class2type map jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), function( i, name ) { class2type[ "[object " + name + "]" ] = name.toLowerCase(); } ); function isArrayLike( obj ) { // Support: real iOS 8.2 only (not reproducible in simulator) // `in` check used to prevent JIT error (gh-2145) // hasOwn isn't used here due to false negatives // regarding Nodelist length in IE var length = !!obj && "length" in obj && obj.length, type = toType( obj ); if ( isFunction( obj ) || isWindow( obj ) ) { return false; } return type === "array" || length === 0 || typeof length === "number" && length > 0 && ( length - 1 ) in obj; } var Sizzle = /*! * Sizzle CSS Selector Engine v2.3.3 * https://sizzlejs.com/ * * Copyright jQuery Foundation and other contributors * Released under the MIT license * http://jquery.org/license * * Date: 2016-08-08 */ (function( window ) { var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate, // Local document vars setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains, // Instance-specific data expando = "sizzle" + 1 * new Date(), preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function( a, b ) { if ( a === b ) { hasDuplicate = true; } return 0; }, // Instance methods hasOwn = ({}).hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice, // Use a stripped-down indexOf as it's faster than native // https://jsperf.com/thor-indexof-vs-for/5 indexOf = function( list, elem ) { var i = 0, len = list.length; for ( ; i < len; i++ ) { if ( list[i] === elem ) { return i; } } return -1; }, booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", // Regular expressions // http://www.w3.org/TR/css3-selectors/#whitespace whitespace = "[\\x20\\t\\r\\n\\f]", // http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+", // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + // Operator (capture 2) "*([*^$|!~]?=)" + whitespace + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]", pseudos = ":(" + identifier + ")(?:\\((" + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: // 1. quoted (capture 3; capture 4 or capture 5) "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + // 2. simple (capture 6) "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + // 3. anything else (capture 2) ".*" + ")\\)|)", // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter rwhitespace = new RegExp( whitespace + "+", "g" ), rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ), rpseudo = new RegExp( pseudos ), ridentifier = new RegExp( "^" + identifier + "$" ), matchExpr = { "ID": new RegExp( "^#(" + identifier + ")" ), "CLASS": new RegExp( "^\\.(" + identifier + ")" ), "TAG": new RegExp( "^(" + identifier + "|[*])" ), "ATTR": new RegExp( "^" + attributes ), "PSEUDO": new RegExp( "^" + pseudos ), "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), // For use in libraries implementing .is() // We use this for POS matching in `select` "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) }, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rnative = /^[^{]+\{\s*\[native \w/, // Easily-parseable/retrievable ID or TAG or CLASS selectors rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, // CSS escapes // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), funescape = function( _, escaped, escapedWhitespace ) { var high = "0x" + escaped - 0x10000; // NaN means non-codepoint // Support: Firefox<24 // Workaround erroneous numeric interpretation of +"0x" return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint String.fromCharCode( high + 0x10000 ) : // Supplemental Plane codepoint (surrogate pair) String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); }, // CSS string/identifier serialization // https://drafts.csswg.org/cssom/#common-serializing-idioms rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g, fcssescape = function( ch, asCodePoint ) { if ( asCodePoint ) { // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER if ( ch === "\0" ) { return "\uFFFD"; } // Control characters and (dependent upon position) numbers get escaped as code points return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; } // Other potentially-special ASCII characters get backslash-escaped return "\\" + ch; }, // Used for iframes // See setDocument() // Removing the function wrapper causes a "Permission Denied" // error in IE unloadHandler = function() { setDocument(); }, disabledAncestor = addCombinator( function( elem ) { return elem.disabled === true && ("form" in elem || "label" in elem); }, { dir: "parentNode", next: "legend" } ); // Optimize for push.apply( _, NodeList ) try { push.apply( (arr = slice.call( preferredDoc.childNodes )), preferredDoc.childNodes ); // Support: Android<4.0 // Detect silently failing push.apply arr[ preferredDoc.childNodes.length ].nodeType; } catch ( e ) { push = { apply: arr.length ? // Leverage slice if possible function( target, els ) { push_native.apply( target, slice.call(els) ); } : // Support: IE<9 // Otherwise append directly function( target, els ) { var j = target.length, i = 0; // Can't trust NodeList.length while ( (target[j++] = els[i++]) ) {} target.length = j - 1; } }; } function Sizzle( selector, context, results, seed ) { var m, i, elem, nid, match, groups, newSelector, newContext = context && context.ownerDocument, // nodeType defaults to 9, since context defaults to document nodeType = context ? context.nodeType : 9; results = results || []; // Return early from calls with invalid selector or context if ( typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { return results; } // Try to shortcut find operations (as opposed to filters) in HTML documents if ( !seed ) { if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { setDocument( context ); } context = context || document; if ( documentIsHTML ) { // If the selector is sufficiently simple, try using a "get*By*" DOM method // (excepting DocumentFragment context, where the methods don't exist) if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { // ID selector if ( (m = match[1]) ) { // Document context if ( nodeType === 9 ) { if ( (elem = context.getElementById( m )) ) { // Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID if ( elem.id === m ) { results.push( elem ); return results; } } else { return results; } // Element context } else { // Support: IE, Opera, Webkit // TODO: identify versions // getElementById can match elements by name instead of ID if ( newContext && (elem = newContext.getElementById( m )) && contains( context, elem ) && elem.id === m ) { results.push( elem ); return results; } } // Type selector } else if ( match[2] ) { push.apply( results, context.getElementsByTagName( selector ) ); return results; // Class selector } else if ( (m = match[3]) && support.getElementsByClassName && context.getElementsByClassName ) { push.apply( results, context.getElementsByClassName( m ) ); return results; } } // Take advantage of querySelectorAll if ( support.qsa && !compilerCache[ selector + " " ] && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { if ( nodeType !== 1 ) { newContext = context; newSelector = selector; // qSA looks outside Element context, which is not what we want // Thanks to Andrew Dupont for this workaround technique // Support: IE <=8 // Exclude object elements } else if ( context.nodeName.toLowerCase() !== "object" ) { // Capture the context ID, setting it first if necessary if ( (nid = context.getAttribute( "id" )) ) { nid = nid.replace( rcssescape, fcssescape ); } else { context.setAttribute( "id", (nid = expando) ); } // Prefix every selector in the list groups = tokenize( selector ); i = groups.length; while ( i-- ) { groups[i] = "#" + nid + " " + toSelector( groups[i] ); } newSelector = groups.join( "," ); // Expand context for sibling selectors newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context; } if ( newSelector ) { try { push.apply( results, newContext.querySelectorAll( newSelector ) ); return results; } catch ( qsaError ) { } finally { if ( nid === expando ) { context.removeAttribute( "id" ); } } } } } } // All others return select( selector.replace( rtrim, "$1" ), context, results, seed ); } /** * Create key-value caches of limited size * @returns {function(string, object)} Returns the Object data after storing it on itself with * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) * deleting the oldest entry */ function createCache() { var keys = []; function cache( key, value ) { // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) if ( keys.push( key + " " ) > Expr.cacheLength ) { // Only keep the most recent entries delete cache[ keys.shift() ]; } return (cache[ key + " " ] = value); } return cache; } /** * Mark a function for special use by Sizzle * @param {Function} fn The function to mark */ function markFunction( fn ) { fn[ expando ] = true; return fn; } /** * Support testing using an element * @param {Function} fn Passed the created element and returns a boolean result */ function assert( fn ) { var el = document.createElement("fieldset"); try { return !!fn( el ); } catch (e) { return false; } finally { // Remove from its parent by default if ( el.parentNode ) { el.parentNode.removeChild( el ); } // release memory in IE el = null; } } /** * Adds the same handler for all of the specified attrs * @param {String} attrs Pipe-separated list of attributes * @param {Function} handler The method that will be applied */ function addHandle( attrs, handler ) { var arr = attrs.split("|"), i = arr.length; while ( i-- ) { Expr.attrHandle[ arr[i] ] = handler; } } /** * Checks document order of two siblings * @param {Element} a * @param {Element} b * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b */ function siblingCheck( a, b ) { var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 && a.sourceIndex - b.sourceIndex; // Use IE sourceIndex if available on both nodes if ( diff ) { return diff; } // Check if b follows a if ( cur ) { while ( (cur = cur.nextSibling) ) { if ( cur === b ) { return -1; } } } return a ? 1 : -1; } /** * Returns a function to use in pseudos for input types * @param {String} type */ function createInputPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && elem.type === type; }; } /** * Returns a function to use in pseudos for buttons * @param {String} type */ function createButtonPseudo( type ) { return function( elem ) { var name = elem.nodeName.toLowerCase(); return (name === "input" || name === "button") && elem.type === type; }; } /** * Returns a function to use in pseudos for :enabled/:disabled * @param {Boolean} disabled true for :disabled; false for :enabled */ function createDisabledPseudo( disabled ) { // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable return function( elem ) { // Only certain elements can match :enabled or :disabled // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled if ( "form" in elem ) { // Check for inherited disabledness on relevant non-disabled elements: // * listed form-associated elements in a disabled fieldset // https://html.spec.whatwg.org/multipage/forms.html#category-listed // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled // * option elements in a disabled optgroup // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled // All such elements have a "form" property. if ( elem.parentNode && elem.disabled === false ) { // Option elements defer to a parent optgroup if present if ( "label" in elem ) { if ( "label" in elem.parentNode ) { return elem.parentNode.disabled === disabled; } else { return elem.disabled === disabled; } } // Support: IE 6 - 11 // Use the isDisabled shortcut property to check for disabled fieldset ancestors return elem.isDisabled === disabled || // Where there is no isDisabled, check manually /* jshint -W018 */ elem.isDisabled !== !disabled && disabledAncestor( elem ) === disabled; } return elem.disabled === disabled; // Try to winnow out elements that can't be disabled before trusting the disabled property. // Some victims get caught in our net (label, legend, menu, track), but it shouldn't // even exist on them, let alone have a boolean value. } else if ( "label" in elem ) { return elem.disabled === disabled; } // Remaining elements are neither :enabled nor :disabled return false; }; } /** * Returns a function to use in pseudos for positionals * @param {Function} fn */ function createPositionalPseudo( fn ) { return markFunction(function( argument ) { argument = +argument; return markFunction(function( seed, matches ) { var j, matchIndexes = fn( [], seed.length, argument ), i = matchIndexes.length; // Match elements found at the specified indexes while ( i-- ) { if ( seed[ (j = matchIndexes[i]) ] ) { seed[j] = !(matches[j] = seed[j]); } } }); }); } /** * Checks a node for validity as a Sizzle context * @param {Element|Object=} context * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value */ function testContext( context ) { return context && typeof context.getElementsByTagName !== "undefined" && context; } // Expose support vars for convenience support = Sizzle.support = {}; /** * Detects XML nodes * @param {Element|Object} elem An element or a document * @returns {Boolean} True iff elem is a non-HTML XML node */ isXML = Sizzle.isXML = function( elem ) { // documentElement is verified for cases where it doesn't yet exist // (such as loading iframes in IE - #4833) var documentElement = elem && (elem.ownerDocument || elem).documentElement; return documentElement ? documentElement.nodeName !== "HTML" : false; }; /** * Sets document-related variables once based on the current document * @param {Element|Object} [doc] An element or document object to use to set the document * @returns {Object} Returns the current document */ setDocument = Sizzle.setDocument = function( node ) { var hasCompare, subWindow, doc = node ? node.ownerDocument || node : preferredDoc; // Return early if doc is invalid or already selected if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { return document; } // Update global variables document = doc; docElem = document.documentElement; documentIsHTML = !isXML( document ); // Support: IE 9-11, Edge // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936) if ( preferredDoc !== document && (subWindow = document.defaultView) && subWindow.top !== subWindow ) { // Support: IE 11, Edge if ( subWindow.addEventListener ) { subWindow.addEventListener( "unload", unloadHandler, false ); // Support: IE 9 - 10 only } else if ( subWindow.attachEvent ) { subWindow.attachEvent( "onunload", unloadHandler ); } } /* Attributes ---------------------------------------------------------------------- */ // Support: IE<8 // Verify that getAttribute really returns attributes and not properties // (excepting IE8 booleans) support.attributes = assert(function( el ) { el.className = "i"; return !el.getAttribute("className"); }); /* getElement(s)By* ---------------------------------------------------------------------- */ // Check if getElementsByTagName("*") returns only elements support.getElementsByTagName = assert(function( el ) { el.appendChild( document.createComment("") ); return !el.getElementsByTagName("*").length; }); // Support: IE<9 support.getElementsByClassName = rnative.test( document.getElementsByClassName ); // Support: IE<10 // Check if getElementById returns elements by name // The broken getElementById methods don't pick up programmatically-set names, // so use a roundabout getElementsByName test support.getById = assert(function( el ) { docElem.appendChild( el ).id = expando; return !document.getElementsByName || !document.getElementsByName( expando ).length; }); // ID filter and find if ( support.getById ) { Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { return elem.getAttribute("id") === attrId; }; }; Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var elem = context.getElementById( id ); return elem ? [ elem ] : []; } }; } else { Expr.filter["ID"] = function( id ) { var attrId = id.replace( runescape, funescape ); return function( elem ) { var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); return node && node.value === attrId; }; }; // Support: IE 6 - 7 only // getElementById is not reliable as a find shortcut Expr.find["ID"] = function( id, context ) { if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { var node, i, elems, elem = context.getElementById( id ); if ( elem ) { // Verify the id attribute node = elem.getAttributeNode("id"); if ( node && node.value === id ) { return [ elem ]; } // Fall back on getElementsByName elems = context.getElementsByName( id ); i = 0; while ( (elem = elems[i++]) ) { node = elem.getAttributeNode("id"); if ( node && node.value === id ) { return [ elem ]; } } } return []; } }; } // Tag Expr.find["TAG"] = support.getElementsByTagName ? function( tag, context ) { if ( typeof context.getElementsByTagName !== "undefined" ) { return context.getElementsByTagName( tag ); // DocumentFragment nodes don't have gEBTN } else if ( support.qsa ) { return context.querySelectorAll( tag ); } } : function( tag, context ) { var elem, tmp = [], i = 0, // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too results = context.getElementsByTagName( tag ); // Filter out possible comments if ( tag === "*" ) { while ( (elem = results[i++]) ) { if ( elem.nodeType === 1 ) { tmp.push( elem ); } } return tmp; } return results; }; // Class Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { return context.getElementsByClassName( className ); } }; /* QSA/matchesSelector ---------------------------------------------------------------------- */ // QSA and matchesSelector support // matchesSelector(:active) reports false when true (IE9/Opera 11.5) rbuggyMatches = []; // qSa(:focus) reports false when true (Chrome 21) // We allow this because of a bug in IE8/9 that throws an error // whenever `document.activeElement` is accessed on an iframe // So, we allow :focus to pass through QSA all the time to avoid the IE error // See https://bugs.jquery.com/ticket/13378 rbuggyQSA = []; if ( (support.qsa = rnative.test( document.querySelectorAll )) ) { // Build QSA regex // Regex strategy adopted from Diego Perini assert(function( el ) { // Select is set to empty string on purpose // This is to test IE's treatment of not explicitly // setting a boolean content attribute, // since its presence should be enough // https://bugs.jquery.com/ticket/12359 docElem.appendChild( el ).innerHTML = "" + ""; // Support: IE8, Opera 11-12.16 // Nothing should be selected when empty strings follow ^= or $= or *= // The test attribute must be unknown in Opera but "safe" for WinRT // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section if ( el.querySelectorAll("[msallowcapture^='']").length ) { rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); } // Support: IE8 // Boolean attributes and "value" are not treated correctly if ( !el.querySelectorAll("[selected]").length ) { rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); } // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+ if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { rbuggyQSA.push("~="); } // Webkit/Opera - :checked should return selected option elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked // IE8 throws error here and will not see later tests if ( !el.querySelectorAll(":checked").length ) { rbuggyQSA.push(":checked"); } // Support: Safari 8+, iOS 8+ // https://bugs.webkit.org/show_bug.cgi?id=136851 // In-page `selector#id sibling-combinator selector` fails if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { rbuggyQSA.push(".#.+[+~]"); } }); assert(function( el ) { el.innerHTML = "" + ""; // Support: Windows 8 Native Apps // The type and name attributes are restricted during .innerHTML assignment var input = document.createElement("input"); input.setAttribute( "type", "hidden" ); el.appendChild( input ).setAttribute( "name", "D" ); // Support: IE8 // Enforce case-sensitivity of name attribute if ( el.querySelectorAll("[name=d]").length ) { rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); } // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) // IE8 throws error here and will not see later tests if ( el.querySelectorAll(":enabled").length !== 2 ) { rbuggyQSA.push( ":enabled", ":disabled" ); } // Support: IE9-11+ // IE's :disabled selector does not pick up the children of disabled fieldsets docElem.appendChild( el ).disabled = true; if ( el.querySelectorAll(":disabled").length !== 2 ) { rbuggyQSA.push( ":enabled", ":disabled" ); } // Opera 10-11 does not throw on post-comma invalid pseudos el.querySelectorAll("*,:x"); rbuggyQSA.push(",.*:"); }); } if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector) )) ) { assert(function( el ) { // Check to see if it's possible to do matchesSelector // on a disconnected node (IE 9) support.disconnectedMatch = matches.call( el, "*" ); // This should fail with an exception // Gecko does not error, returns false instead matches.call( el, "[s!='']:x" ); rbuggyMatches.push( "!=", pseudos ); }); } rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); /* Contains ---------------------------------------------------------------------- */ hasCompare = rnative.test( docElem.compareDocumentPosition ); // Element contains another // Purposefully self-exclusive // As in, an element does not contain itself contains = hasCompare || rnative.test( docElem.contains ) ? function( a, b ) { var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode; return a === bup || !!( bup && bup.nodeType === 1 && ( adown.contains ? adown.contains( bup ) : a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 )); } : function( a, b ) { if ( b ) { while ( (b = b.parentNode) ) { if ( b === a ) { return true; } } } return false; }; /* Sorting ---------------------------------------------------------------------- */ // Document order sorting sortOrder = hasCompare ? function( a, b ) { // Flag for duplicate removal if ( a === b ) { hasDuplicate = true; return 0; } // Sort on method existence if only one input has compareDocumentPosition var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; if ( compare ) { return compare; } // Calculate position if both inputs belong to the same document compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? a.compareDocumentPosition( b ) : // Otherwise we know they are disconnected 1; // Disconnected nodes if ( compare & 1 || (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { // Choose the first element that is related to our preferred document if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { return -1; } if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { return 1; } // Maintain original order return sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; } return compare & 4 ? -1 : 1; } : function( a, b ) { // Exit early if the nodes are identical if ( a === b ) { hasDuplicate = true; return 0; } var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [ a ], bp = [ b ]; // Parentless nodes are either documents or disconnected if ( !aup || !bup ) { return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : 0; // If the nodes are siblings, we can do a quick check } else if ( aup === bup ) { return siblingCheck( a, b ); } // Otherwise we need full lists of their ancestors for comparison cur = a; while ( (cur = cur.parentNode) ) { ap.unshift( cur ); } cur = b; while ( (cur = cur.parentNode) ) { bp.unshift( cur ); } // Walk down the tree looking for a discrepancy while ( ap[i] === bp[i] ) { i++; } return i ? // Do a sibling check if the nodes have a common ancestor siblingCheck( ap[i], bp[i] ) : // Otherwise nodes in our document sort first ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0; }; return document; }; Sizzle.matches = function( expr, elements ) { return Sizzle( expr, null, null, elements ); }; Sizzle.matchesSelector = function( elem, expr ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); } // Make sure that attribute selectors are quoted expr = expr.replace( rattributeQuotes, "='$1']" ); if ( support.matchesSelector && documentIsHTML && !compilerCache[ expr + " " ] && ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { try { var ret = matches.call( elem, expr ); // IE 9's matchesSelector returns false on disconnected nodes if ( ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document // fragment in IE 9 elem.document && elem.document.nodeType !== 11 ) { return ret; } } catch (e) {} } return Sizzle( expr, document, null, [ elem ] ).length > 0; }; Sizzle.contains = function( context, elem ) { // Set document vars if needed if ( ( context.ownerDocument || context ) !== document ) { setDocument( context ); } return contains( context, elem ); }; Sizzle.attr = function( elem, name ) { // Set document vars if needed if ( ( elem.ownerDocument || elem ) !== document ) { setDocument( elem ); } var fn = Expr.attrHandle[ name.toLowerCase() ], // Don't get fooled by Object.prototype properties (jQuery #13807) val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? fn( elem, name, !documentIsHTML ) : undefined; return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute( name ) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null; }; Sizzle.escape = function( sel ) { return (sel + "").replace( rcssescape, fcssescape ); }; Sizzle.error = function( msg ) { throw new Error( "Syntax error, unrecognized expression: " + msg ); }; /** * Document sorting and removing duplicates * @param {ArrayLike} results */ Sizzle.uniqueSort = function( results ) { var elem, duplicates = [], j = 0, i = 0; // Unless we *know* we can detect duplicates, assume their presence hasDuplicate = !support.detectDuplicates; sortInput = !support.sortStable && results.slice( 0 ); results.sort( sortOrder ); if ( hasDuplicate ) { while ( (elem = results[i++]) ) { if ( elem === results[ i ] ) { j = duplicates.push( i ); } } while ( j-- ) { results.splice( duplicates[ j ], 1 ); } } // Clear input after sorting to release objects // See https://github.com/jquery/sizzle/pull/225 sortInput = null; return results; }; /** * Utility function for retrieving the text value of an array of DOM nodes * @param {Array|Element} elem */ getText = Sizzle.getText = function( elem ) { var node, ret = "", i = 0, nodeType = elem.nodeType; if ( !nodeType ) { // If no nodeType, this is expected to be an array while ( (node = elem[i++]) ) { // Do not traverse comment nodes ret += getText( node ); } } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { // Use textContent for elements // innerText usage removed for consistency of new lines (jQuery #11153) if ( typeof elem.textContent === "string" ) { return elem.textContent; } else { // Traverse its children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { ret += getText( elem ); } } } else if ( nodeType === 3 || nodeType === 4 ) { return elem.nodeValue; } // Do not include comment or processing instruction nodes return ret; }; Expr = Sizzle.selectors = { // Can be adjusted by the user cacheLength: 50, createPseudo: markFunction, match: matchExpr, attrHandle: {}, find: {}, relative: { ">": { dir: "parentNode", first: true }, " ": { dir: "parentNode" }, "+": { dir: "previousSibling", first: true }, "~": { dir: "previousSibling" } }, preFilter: { "ATTR": function( match ) { match[1] = match[1].replace( runescape, funescape ); // Move the given value to match[3] whether quoted or unquoted match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape ); if ( match[2] === "~=" ) { match[3] = " " + match[3] + " "; } return match.slice( 0, 4 ); }, "CHILD": function( match ) { /* matches from matchExpr["CHILD"] 1 type (only|nth|...) 2 what (child|of-type) 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 4 xn-component of xn+y argument ([+-]?\d*n|) 5 sign of xn-component 6 x of xn-component 7 sign of y-component 8 y of y-component */ match[1] = match[1].toLowerCase(); if ( match[1].slice( 0, 3 ) === "nth" ) { // nth-* requires argument if ( !match[3] ) { Sizzle.error( match[0] ); } // numeric x and y parameters for Expr.filter.CHILD // remember that false/true cast respectively to 0/1 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); // other types prohibit arguments } else if ( match[3] ) { Sizzle.error( match[0] ); } return match; }, "PSEUDO": function( match ) { var excess, unquoted = !match[6] && match[2]; if ( matchExpr["CHILD"].test( match[0] ) ) { return null; } // Accept quoted arguments as-is if ( match[3] ) { match[2] = match[4] || match[5] || ""; // Strip excess characters from unquoted arguments } else if ( unquoted && rpseudo.test( unquoted ) && // Get excess from tokenize (recursively) (excess = tokenize( unquoted, true )) && // advance to the next closing parenthesis (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { // excess is a negative index match[0] = match[0].slice( 0, excess ); match[2] = unquoted.slice( 0, excess ); } // Return only captures needed by the pseudo filter method (type and argument) return match.slice( 0, 3 ); } }, filter: { "TAG": function( nodeNameSelector ) { var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); return nodeNameSelector === "*" ? function() { return true; } : function( elem ) { return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; }; }, "CLASS": function( className ) { var pattern = classCache[ className + " " ]; return pattern || (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && classCache( className, function( elem ) { return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" ); }); }, "ATTR": function( name, operator, check ) { return function( elem ) { var result = Sizzle.attr( elem, name ); if ( result == null ) { return operator === "!="; } if ( !operator ) { return true; } result += ""; return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf( check ) === 0 : operator === "*=" ? check && result.indexOf( check ) > -1 : operator === "$=" ? check && result.slice( -check.length ) === check : operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : false; }; }, "CHILD": function( type, what, argument, first, last ) { var simple = type.slice( 0, 3 ) !== "nth", forward = type.slice( -4 ) !== "last", ofType = what === "of-type"; return first === 1 && last === 0 ? // Shortcut for :nth-*(n) function( elem ) { return !!elem.parentNode; } : function( elem, context, xml ) { var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? "nextSibling" : "previousSibling", parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false; if ( parent ) { // :(first|last|only)-(child|of-type) if ( simple ) { while ( dir ) { node = elem; while ( (node = node[ dir ]) ) { if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { return false; } } // Reverse direction for :only-* (if we haven't yet done so) start = dir = type === "only" && !start && "nextSibling"; } return true; } start = [ forward ? parent.firstChild : parent.lastChild ]; // non-xml :nth-child(...) stores cache data on `parent` if ( forward && useCache ) { // Seek `elem` from a previously-cached index // ...in a gzip-friendly way node = parent; outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex && cache[ 2 ]; node = nodeIndex && parent.childNodes[ nodeIndex ]; while ( (node = ++nodeIndex && node && node[ dir ] || // Fallback to seeking `elem` from the start (diff = nodeIndex = 0) || start.pop()) ) { // When found, cache indexes on `parent` and break if ( node.nodeType === 1 && ++diff && node === elem ) { uniqueCache[ type ] = [ dirruns, nodeIndex, diff ]; break; } } } else { // Use previously-cached element index if available if ( useCache ) { // ...in a gzip-friendly way node = elem; outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); cache = uniqueCache[ type ] || []; nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; diff = nodeIndex; } // xml :nth-child(...) // or :nth-last-child(...) or :nth(-last)?-of-type(...) if ( diff === false ) { // Use the same loop as above to seek `elem` from the start while ( (node = ++nodeIndex && node && node[ dir ] || (diff = nodeIndex = 0) || start.pop()) ) { if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { // Cache the index of each encountered element if ( useCache ) { outerCache = node[ expando ] || (node[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ node.uniqueID ] || (outerCache[ node.uniqueID ] = {}); uniqueCache[ type ] = [ dirruns, diff ]; } if ( node === elem ) { break; } } } } } // Incorporate the offset, then check against cycle size diff -= last; return diff === first || ( diff % first === 0 && diff / first >= 0 ); } }; }, "PSEUDO": function( pseudo, argument ) { // pseudo-class names are case-insensitive // http://www.w3.org/TR/selectors/#pseudo-classes // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters // Remember that setFilters inherits from pseudos var args, fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || Sizzle.error( "unsupported pseudo: " + pseudo ); // The user may use createPseudo to indicate that // arguments are needed to create the filter function // just as Sizzle does if ( fn[ expando ] ) { return fn( argument ); } // But maintain support for old signatures if ( fn.length > 1 ) { args = [ pseudo, pseudo, "", argument ]; return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? markFunction(function( seed, matches ) { var idx, matched = fn( seed, argument ), i = matched.length; while ( i-- ) { idx = indexOf( seed, matched[i] ); seed[ idx ] = !( matches[ idx ] = matched[i] ); } }) : function( elem ) { return fn( elem, 0, args ); }; } return fn; } }, pseudos: { // Potentially complex pseudos "not": markFunction(function( selector ) { // Trim the selector passed to compile // to avoid treating leading and trailing // spaces as combinators var input = [], results = [], matcher = compile( selector.replace( rtrim, "$1" ) ); return matcher[ expando ] ? markFunction(function( seed, matches, context, xml ) { var elem, unmatched = matcher( seed, null, xml, [] ), i = seed.length; // Match elements unmatched by `matcher` while ( i-- ) { if ( (elem = unmatched[i]) ) { seed[i] = !(matches[i] = elem); } } }) : function( elem, context, xml ) { input[0] = elem; matcher( input, null, xml, results ); // Don't keep the element (issue #299) input[0] = null; return !results.pop(); }; }), "has": markFunction(function( selector ) { return function( elem ) { return Sizzle( selector, elem ).length > 0; }; }), "contains": markFunction(function( text ) { text = text.replace( runescape, funescape ); return function( elem ) { return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; }; }), // "Whether an element is represented by a :lang() selector // is based solely on the element's language value // being equal to the identifier C, // or beginning with the identifier C immediately followed by "-". // The matching of C against the element's language value is performed case-insensitively. // The identifier C does not have to be a valid language name." // http://www.w3.org/TR/selectors/#lang-pseudo "lang": markFunction( function( lang ) { // lang value must be a valid identifier if ( !ridentifier.test(lang || "") ) { Sizzle.error( "unsupported lang: " + lang ); } lang = lang.replace( runescape, funescape ).toLowerCase(); return function( elem ) { var elemLang; do { if ( (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { elemLang = elemLang.toLowerCase(); return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; } } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); return false; }; }), // Miscellaneous "target": function( elem ) { var hash = window.location && window.location.hash; return hash && hash.slice( 1 ) === elem.id; }, "root": function( elem ) { return elem === docElem; }, "focus": function( elem ) { return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); }, // Boolean properties "enabled": createDisabledPseudo( false ), "disabled": createDisabledPseudo( true ), "checked": function( elem ) { // In CSS3, :checked should return both checked and selected elements // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked var nodeName = elem.nodeName.toLowerCase(); return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); }, "selected": function( elem ) { // Accessing this property makes selected-by-default // options in Safari work properly if ( elem.parentNode ) { elem.parentNode.selectedIndex; } return elem.selected === true; }, // Contents "empty": function( elem ) { // http://www.w3.org/TR/selectors/#empty-pseudo // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), // but not by others (comment: 8; processing instruction: 7; etc.) // nodeType < 6 works because attributes (2) do not appear as children for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { if ( elem.nodeType < 6 ) { return false; } } return true; }, "parent": function( elem ) { return !Expr.pseudos["empty"]( elem ); }, // Element/input types "header": function( elem ) { return rheader.test( elem.nodeName ); }, "input": function( elem ) { return rinputs.test( elem.nodeName ); }, "button": function( elem ) { var name = elem.nodeName.toLowerCase(); return name === "input" && elem.type === "button" || name === "button"; }, "text": function( elem ) { var attr; return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && // Support: IE<8 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); }, // Position-in-collection "first": createPositionalPseudo(function() { return [ 0 ]; }), "last": createPositionalPseudo(function( matchIndexes, length ) { return [ length - 1 ]; }), "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { return [ argument < 0 ? argument + length : argument ]; }), "even": createPositionalPseudo(function( matchIndexes, length ) { var i = 0; for ( ; i < length; i += 2 ) { matchIndexes.push( i ); } return matchIndexes; }), "odd": createPositionalPseudo(function( matchIndexes, length ) { var i = 1; for ( ; i < length; i += 2 ) { matchIndexes.push( i ); } return matchIndexes; }), "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { var i = argument < 0 ? argument + length : argument; for ( ; --i >= 0; ) { matchIndexes.push( i ); } return matchIndexes; }), "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { var i = argument < 0 ? argument + length : argument; for ( ; ++i < length; ) { matchIndexes.push( i ); } return matchIndexes; }) } }; Expr.pseudos["nth"] = Expr.pseudos["eq"]; // Add button/input type pseudos for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { Expr.pseudos[ i ] = createInputPseudo( i ); } for ( i in { submit: true, reset: true } ) { Expr.pseudos[ i ] = createButtonPseudo( i ); } // Easy API for creating new setFilters function setFilters() {} setFilters.prototype = Expr.filters = Expr.pseudos; Expr.setFilters = new setFilters(); tokenize = Sizzle.tokenize = function( selector, parseOnly ) { var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[ selector + " " ]; if ( cached ) { return parseOnly ? 0 : cached.slice( 0 ); } soFar = selector; groups = []; preFilters = Expr.preFilter; while ( soFar ) { // Comma and first run if ( !matched || (match = rcomma.exec( soFar )) ) { if ( match ) { // Don't consume trailing commas as valid soFar = soFar.slice( match[0].length ) || soFar; } groups.push( (tokens = []) ); } matched = false; // Combinators if ( (match = rcombinators.exec( soFar )) ) { matched = match.shift(); tokens.push({ value: matched, // Cast descendant combinators to space type: match[0].replace( rtrim, " " ) }); soFar = soFar.slice( matched.length ); } // Filters for ( type in Expr.filter ) { if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || (match = preFilters[ type ]( match ))) ) { matched = match.shift(); tokens.push({ value: matched, type: type, matches: match }); soFar = soFar.slice( matched.length ); } } if ( !matched ) { break; } } // Return the length of the invalid excess // if we're just parsing // Otherwise, throw an error or return tokens return parseOnly ? soFar.length : soFar ? Sizzle.error( selector ) : // Cache the tokens tokenCache( selector, groups ).slice( 0 ); }; function toSelector( tokens ) { var i = 0, len = tokens.length, selector = ""; for ( ; i < len; i++ ) { selector += tokens[i].value; } return selector; } function addCombinator( matcher, combinator, base ) { var dir = combinator.dir, skip = combinator.next, key = skip || dir, checkNonElements = base && key === "parentNode", doneName = done++; return combinator.first ? // Check against closest ancestor/preceding element function( elem, context, xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { return matcher( elem, context, xml ); } } return false; } : // Check against all ancestor/preceding elements function( elem, context, xml ) { var oldCache, uniqueCache, outerCache, newCache = [ dirruns, doneName ]; // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching if ( xml ) { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { if ( matcher( elem, context, xml ) ) { return true; } } } } else { while ( (elem = elem[ dir ]) ) { if ( elem.nodeType === 1 || checkNonElements ) { outerCache = elem[ expando ] || (elem[ expando ] = {}); // Support: IE <9 only // Defend against cloned attroperties (jQuery gh-1709) uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {}); if ( skip && skip === elem.nodeName.toLowerCase() ) { elem = elem[ dir ] || elem; } else if ( (oldCache = uniqueCache[ key ]) && oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { // Assign to newCache so results back-propagate to previous elements return (newCache[ 2 ] = oldCache[ 2 ]); } else { // Reuse newcache so results back-propagate to previous elements uniqueCache[ key ] = newCache; // A match means we're done; a fail means we have to keep checking if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { return true; } } } } } return false; }; } function elementMatcher( matchers ) { return matchers.length > 1 ? function( elem, context, xml ) { var i = matchers.length; while ( i-- ) { if ( !matchers[i]( elem, context, xml ) ) { return false; } } return true; } : matchers[0]; } function multipleContexts( selector, contexts, results ) { var i = 0, len = contexts.length; for ( ; i < len; i++ ) { Sizzle( selector, contexts[i], results ); } return results; } function condense( unmatched, map, filter, context, xml ) { var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null; for ( ; i < len; i++ ) { if ( (elem = unmatched[i]) ) { if ( !filter || filter( elem, context, xml ) ) { newUnmatched.push( elem ); if ( mapped ) { map.push( i ); } } } } return newUnmatched; } function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { if ( postFilter && !postFilter[ expando ] ) { postFilter = setMatcher( postFilter ); } if ( postFinder && !postFinder[ expando ] ) { postFinder = setMatcher( postFinder, postSelector ); } return markFunction(function( seed, results, context, xml ) { var temp, i, elem, preMap = [], postMap = [], preexisting = results.length, // Get initial elements from seed or context elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), // Prefilter to get matcher input, preserving a map for seed-results synchronization matcherIn = preFilter && ( seed || !selector ) ? condense( elems, preMap, preFilter, context, xml ) : elems, matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, postFinder || ( seed ? preFilter : preexisting || postFilter ) ? // ...intermediate processing is necessary [] : // ...otherwise use results directly results : matcherIn; // Find primary matches if ( matcher ) { matcher( matcherIn, matcherOut, context, xml ); } // Apply postFilter if ( postFilter ) { temp = condense( matcherOut, postMap ); postFilter( temp, [], context, xml ); // Un-match failing elements by moving them back to matcherIn i = temp.length; while ( i-- ) { if ( (elem = temp[i]) ) { matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); } } } if ( seed ) { if ( postFinder || preFilter ) { if ( postFinder ) { // Get the final matcherOut by condensing this intermediate into postFinder contexts temp = []; i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) ) { // Restore matcherIn since elem is not yet a final match temp.push( (matcherIn[i] = elem) ); } } postFinder( null, (matcherOut = []), temp, xml ); } // Move matched elements from seed to results to keep them synchronized i = matcherOut.length; while ( i-- ) { if ( (elem = matcherOut[i]) && (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) { seed[temp] = !(results[temp] = elem); } } } // Add elements to results, through postFinder if defined } else { matcherOut = condense( matcherOut === results ? matcherOut.splice( preexisting, matcherOut.length ) : matcherOut ); if ( postFinder ) { postFinder( null, results, matcherOut, xml ); } else { push.apply( results, matcherOut ); } } }); } function matcherFromTokens( tokens ) { var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[ tokens[0].type ], implicitRelative = leadingRelative || Expr.relative[" "], i = leadingRelative ? 1 : 0, // The foundational matcher ensures that elements are reachable from top-level context(s) matchContext = addCombinator( function( elem ) { return elem === checkContext; }, implicitRelative, true ), matchAnyContext = addCombinator( function( elem ) { return indexOf( checkContext, elem ) > -1; }, implicitRelative, true ), matchers = [ function( elem, context, xml ) { var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( (checkContext = context).nodeType ? matchContext( elem, context, xml ) : matchAnyContext( elem, context, xml ) ); // Avoid hanging onto element (issue #299) checkContext = null; return ret; } ]; for ( ; i < len; i++ ) { if ( (matcher = Expr.relative[ tokens[i].type ]) ) { matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; } else { matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); // Return special upon seeing a positional matcher if ( matcher[ expando ] ) { // Find the next relative operator (if any) for proper handling j = ++i; for ( ; j < len; j++ ) { if ( Expr.relative[ tokens[j].type ] ) { break; } } return setMatcher( i > 1 && elementMatcher( matchers ), i > 1 && toSelector( // If the preceding token was a descendant combinator, insert an implicit any-element `*` tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) ).replace( rtrim, "$1" ), matcher, i < j && matcherFromTokens( tokens.slice( i, j ) ), j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), j < len && toSelector( tokens ) ); } matchers.push( matcher ); } } return elementMatcher( matchers ); } function matcherFromGroupMatchers( elementMatchers, setMatchers ) { var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function( seed, context, xml, results, outermost ) { var elem, j, matcher, matchedCount = 0, i = "0", unmatched = seed && [], setMatched = [], contextBackup = outermostContext, // We must always have either seed elements or outermost context elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), // Use integer dirruns iff this is the outermost matcher dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), len = elems.length; if ( outermost ) { outermostContext = context === document || context || outermost; } // Add elements passing elementMatchers directly to results // Support: IE<9, Safari // Tolerate NodeList properties (IE: "length"; Safari: ) matching elements by id for ( ; i !== len && (elem = elems[i]) != null; i++ ) { if ( byElement && elem ) { j = 0; if ( !context && elem.ownerDocument !== document ) { setDocument( elem ); xml = !documentIsHTML; } while ( (matcher = elementMatchers[j++]) ) { if ( matcher( elem, context || document, xml) ) { results.push( elem ); break; } } if ( outermost ) { dirruns = dirrunsUnique; } } // Track unmatched elements for set filters if ( bySet ) { // They will have gone through all possible matchers if ( (elem = !matcher && elem) ) { matchedCount--; } // Lengthen the array for every element, matched or not if ( seed ) { unmatched.push( elem ); } } } // `i` is now the count of elements visited above, and adding it to `matchedCount` // makes the latter nonnegative. matchedCount += i; // Apply set filters to unmatched elements // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` // equals `i`), unless we didn't visit _any_ elements in the above loop because we have // no element matchers and no seed. // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that // case, which will result in a "00" `matchedCount` that differs from `i` but is also // numerically zero. if ( bySet && i !== matchedCount ) { j = 0; while ( (matcher = setMatchers[j++]) ) { matcher( unmatched, setMatched, context, xml ); } if ( seed ) { // Reintegrate element matches to eliminate the need for sorting if ( matchedCount > 0 ) { while ( i-- ) { if ( !(unmatched[i] || setMatched[i]) ) { setMatched[i] = pop.call( results ); } } } // Discard index placeholder values to get only actual matches setMatched = condense( setMatched ); } // Add matches to results push.apply( results, setMatched ); // Seedless set matches succeeding multiple successful matchers stipulate sorting if ( outermost && !seed && setMatched.length > 0 && ( matchedCount + setMatchers.length ) > 1 ) { Sizzle.uniqueSort( results ); } } // Override manipulation of globals by nested matchers if ( outermost ) { dirruns = dirrunsUnique; outermostContext = contextBackup; } return unmatched; }; return bySet ? markFunction( superMatcher ) : superMatcher; } compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { var i, setMatchers = [], elementMatchers = [], cached = compilerCache[ selector + " " ]; if ( !cached ) { // Generate a function of recursive functions that can be used to check each element if ( !match ) { match = tokenize( selector ); } i = match.length; while ( i-- ) { cached = matcherFromTokens( match[i] ); if ( cached[ expando ] ) { setMatchers.push( cached ); } else { elementMatchers.push( cached ); } } // Cache the compiled function cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); // Save selector and tokenization cached.selector = selector; } return cached; }; /** * A low-level selection function that works with Sizzle's compiled * selector functions * @param {String|Function} selector A selector or a pre-compiled * selector function built with Sizzle.compile * @param {Element} context * @param {Array} [results] * @param {Array} [seed] A set of elements to match against */ select = Sizzle.select = function( selector, context, results, seed ) { var i, tokens, token, type, find, compiled = typeof selector === "function" && selector, match = !seed && tokenize( (selector = compiled.selector || selector) ); results = results || []; // Try to minimize operations if there is only one selector in the list and no seed // (the latter of which guarantees us context) if ( match.length === 1 ) { // Reduce context if the leading compound selector is an ID tokens = match[0] = match[0].slice( 0 ); if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) { context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; if ( !context ) { return results; // Precompiled matchers will still verify ancestry, so step up a level } else if ( compiled ) { context = context.parentNode; } selector = selector.slice( tokens.shift().value.length ); } // Fetch a seed set for right-to-left matching i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; while ( i-- ) { token = tokens[i]; // Abort if we hit a combinator if ( Expr.relative[ (type = token.type) ] ) { break; } if ( (find = Expr.find[ type ]) ) { // Search, expanding context for leading sibling combinators if ( (seed = find( token.matches[0].replace( runescape, funescape ), rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context )) ) { // If seed is empty or no tokens remain, we can return early tokens.splice( i, 1 ); selector = seed.length && toSelector( tokens ); if ( !selector ) { push.apply( results, seed ); return results; } break; } } } } // Compile and execute a filtering function if one is not provided // Provide `match` to avoid retokenization if we modified the selector above ( compiled || compile( selector, match ) )( seed, context, !documentIsHTML, results, !context || rsibling.test( selector ) && testContext( context.parentNode ) || context ); return results; }; // One-time assignments // Sort stability support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; // Support: Chrome 14-35+ // Always assume duplicates if they aren't passed to the comparison function support.detectDuplicates = !!hasDuplicate; // Initialize against the default document setDocument(); // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) // Detached nodes confoundingly follow *each other* support.sortDetached = assert(function( el ) { // Should return 1, but returns 4 (following) return el.compareDocumentPosition( document.createElement("fieldset") ) & 1; }); // Support: IE<8 // Prevent attribute/property "interpolation" // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx if ( !assert(function( el ) { el.innerHTML = ""; return el.firstChild.getAttribute("href") === "#" ; }) ) { addHandle( "type|href|height|width", function( elem, name, isXML ) { if ( !isXML ) { return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); } }); } // Support: IE<9 // Use defaultValue in place of getAttribute("value") if ( !support.attributes || !assert(function( el ) { el.innerHTML = ""; el.firstChild.setAttribute( "value", "" ); return el.firstChild.getAttribute( "value" ) === ""; }) ) { addHandle( "value", function( elem, name, isXML ) { if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { return elem.defaultValue; } }); } // Support: IE<9 // Use getAttributeNode to fetch booleans when getAttribute lies if ( !assert(function( el ) { return el.getAttribute("disabled") == null; }) ) { addHandle( booleans, function( elem, name, isXML ) { var val; if ( !isXML ) { return elem[ name ] === true ? name.toLowerCase() : (val = elem.getAttributeNode( name )) && val.specified ? val.value : null; } }); } return Sizzle; })( window ); jQuery.find = Sizzle; jQuery.expr = Sizzle.selectors; // Deprecated jQuery.expr[ ":" ] = jQuery.expr.pseudos; jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort; jQuery.text = Sizzle.getText; jQuery.isXMLDoc = Sizzle.isXML; jQuery.contains = Sizzle.contains; jQuery.escapeSelector = Sizzle.escape; var dir = function( elem, dir, until ) { var matched = [], truncate = until !== undefined; while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { if ( elem.nodeType === 1 ) { if ( truncate && jQuery( elem ).is( until ) ) { break; } matched.push( elem ); } } return matched; }; var siblings = function( n, elem ) { var matched = []; for ( ; n; n = n.nextSibling ) { if ( n.nodeType === 1 && n !== elem ) { matched.push( n ); } } return matched; }; var rneedsContext = jQuery.expr.match.needsContext; function nodeName( elem, name ) { return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); }; var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); // Implement the identical functionality for filter and not function winnow( elements, qualifier, not ) { if ( isFunction( qualifier ) ) { return jQuery.grep( elements, function( elem, i ) { return !!qualifier.call( elem, i, elem ) !== not; } ); } // Single element if ( qualifier.nodeType ) { return jQuery.grep( elements, function( elem ) { return ( elem === qualifier ) !== not; } ); } // Arraylike of elements (jQuery, arguments, Array) if ( typeof qualifier !== "string" ) { return jQuery.grep( elements, function( elem ) { return ( indexOf.call( qualifier, elem ) > -1 ) !== not; } ); } // Filtered directly for both simple and complex selectors return jQuery.filter( qualifier, elements, not ); } jQuery.filter = function( expr, elems, not ) { var elem = elems[ 0 ]; if ( not ) { expr = ":not(" + expr + ")"; } if ( elems.length === 1 && elem.nodeType === 1 ) { return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; } return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { return elem.nodeType === 1; } ) ); }; jQuery.fn.extend( { find: function( selector ) { var i, ret, len = this.length, self = this; if ( typeof selector !== "string" ) { return this.pushStack( jQuery( selector ).filter( function() { for ( i = 0; i < len; i++ ) { if ( jQuery.contains( self[ i ], this ) ) { return true; } } } ) ); } ret = this.pushStack( [] ); for ( i = 0; i < len; i++ ) { jQuery.find( selector, self[ i ], ret ); } return len > 1 ? jQuery.uniqueSort( ret ) : ret; }, filter: function( selector ) { return this.pushStack( winnow( this, selector || [], false ) ); }, not: function( selector ) { return this.pushStack( winnow( this, selector || [], true ) ); }, is: function( selector ) { return !!winnow( this, // If this is a positional/relative selector, check membership in the returned set // so $("p:first").is("p:last") won't return true for a doc with two "p". typeof selector === "string" && rneedsContext.test( selector ) ? jQuery( selector ) : selector || [], false ).length; } } ); // Initialize a jQuery object // A central reference to the root jQuery(document) var rootjQuery, // A simple way to check for HTML strings // Prioritize #id over to avoid XSS via location.hash (#9521) // Strict HTML recognition (#11290: must start with <) // Shortcut simple #id case for speed rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, init = jQuery.fn.init = function( selector, context, root ) { var match, elem; // HANDLE: $(""), $(null), $(undefined), $(false) if ( !selector ) { return this; } // Method init() accepts an alternate rootjQuery // so migrate can support jQuery.sub (gh-2101) root = root || rootjQuery; // Handle HTML strings if ( typeof selector === "string" ) { if ( selector[ 0 ] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) { // Assume that strings that start and end with <> are HTML and skip the regex check match = [ null, selector, null ]; } else { match = rquickExpr.exec( selector ); } // Match html or make sure no context is specified for #id if ( match && ( match[ 1 ] || !context ) ) { // HANDLE: $(html) -> $(array) if ( match[ 1 ] ) { context = context instanceof jQuery ? context[ 0 ] : context; // Option to run scripts is true for back-compat // Intentionally let the error be thrown if parseHTML is not present jQuery.merge( this, jQuery.parseHTML( match[ 1 ], context && context.nodeType ? context.ownerDocument || context : document, true ) ); // HANDLE: $(html, props) if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { for ( match in context ) { // Properties of context are called as methods if possible if ( isFunction( this[ match ] ) ) { this[ match ]( context[ match ] ); // ...and otherwise set as attributes } else { this.attr( match, context[ match ] ); } } } return this; // HANDLE: $(#id) } else { elem = document.getElementById( match[ 2 ] ); if ( elem ) { // Inject the element directly into the jQuery object this[ 0 ] = elem; this.length = 1; } return this; } // HANDLE: $(expr, $(...)) } else if ( !context || context.jquery ) { return ( context || root ).find( selector ); // HANDLE: $(expr, context) // (which is just equivalent to: $(context).find(expr) } else { return this.constructor( context ).find( selector ); } // HANDLE: $(DOMElement) } else if ( selector.nodeType ) { this[ 0 ] = selector; this.length = 1; return this; // HANDLE: $(function) // Shortcut for document ready } else if ( isFunction( selector ) ) { return root.ready !== undefined ? root.ready( selector ) : // Execute immediately if ready is not present selector( jQuery ); } return jQuery.makeArray( selector, this ); }; // Give the init function the jQuery prototype for later instantiation init.prototype = jQuery.fn; // Initialize central reference rootjQuery = jQuery( document ); var rparentsprev = /^(?:parents|prev(?:Until|All))/, // Methods guaranteed to produce a unique set when starting from a unique set guaranteedUnique = { children: true, contents: true, next: true, prev: true }; jQuery.fn.extend( { has: function( target ) { var targets = jQuery( target, this ), l = targets.length; return this.filter( function() { var i = 0; for ( ; i < l; i++ ) { if ( jQuery.contains( this, targets[ i ] ) ) { return true; } } } ); }, closest: function( selectors, context ) { var cur, i = 0, l = this.length, matched = [], targets = typeof selectors !== "string" && jQuery( selectors ); // Positional selectors never match, since there's no _selection_ context if ( !rneedsContext.test( selectors ) ) { for ( ; i < l; i++ ) { for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { // Always skip document fragments if ( cur.nodeType < 11 && ( targets ? targets.index( cur ) > -1 : // Don't pass non-elements to Sizzle cur.nodeType === 1 && jQuery.find.matchesSelector( cur, selectors ) ) ) { matched.push( cur ); break; } } } } return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); }, // Determine the position of an element within the set index: function( elem ) { // No argument, return index in parent if ( !elem ) { return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; } // Index in selector if ( typeof elem === "string" ) { return indexOf.call( jQuery( elem ), this[ 0 ] ); } // Locate the position of the desired element return indexOf.call( this, // If it receives a jQuery object, the first element is used elem.jquery ? elem[ 0 ] : elem ); }, add: function( selector, context ) { return this.pushStack( jQuery.uniqueSort( jQuery.merge( this.get(), jQuery( selector, context ) ) ) ); }, addBack: function( selector ) { return this.add( selector == null ? this.prevObject : this.prevObject.filter( selector ) ); } } ); function sibling( cur, dir ) { while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} return cur; } jQuery.each( { parent: function( elem ) { var parent = elem.parentNode; return parent && parent.nodeType !== 11 ? parent : null; }, parents: function( elem ) { return dir( elem, "parentNode" ); }, parentsUntil: function( elem, i, until ) { return dir( elem, "parentNode", until ); }, next: function( elem ) { return sibling( elem, "nextSibling" ); }, prev: function( elem ) { return sibling( elem, "previousSibling" ); }, nextAll: function( elem ) { return dir( elem, "nextSibling" ); }, prevAll: function( elem ) { return dir( elem, "previousSibling" ); }, nextUntil: function( elem, i, until ) { return dir( elem, "nextSibling", until ); }, prevUntil: function( elem, i, until ) { return dir( elem, "previousSibling", until ); }, siblings: function( elem ) { return siblings( ( elem.parentNode || {} ).firstChild, elem ); }, children: function( elem ) { return siblings( elem.firstChild ); }, contents: function( elem ) { if ( nodeName( elem, "iframe" ) ) { return elem.contentDocument; } // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only // Treat the template element as a regular one in browsers that // don't support it. if ( nodeName( elem, "template" ) ) { elem = elem.content || elem; } return jQuery.merge( [], elem.childNodes ); } }, function( name, fn ) { jQuery.fn[ name ] = function( until, selector ) { var matched = jQuery.map( this, fn, until ); if ( name.slice( -5 ) !== "Until" ) { selector = until; } if ( selector && typeof selector === "string" ) { matched = jQuery.filter( selector, matched ); } if ( this.length > 1 ) { // Remove duplicates if ( !guaranteedUnique[ name ] ) { jQuery.uniqueSort( matched ); } // Reverse order for parents* and prev-derivatives if ( rparentsprev.test( name ) ) { matched.reverse(); } } return this.pushStack( matched ); }; } ); var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); // Convert String-formatted options into Object-formatted ones function createOptions( options ) { var object = {}; jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { object[ flag ] = true; } ); return object; } /* * Create a callback list using the following parameters: * * options: an optional list of space-separated options that will change how * the callback list behaves or a more traditional option object * * By default a callback list will act like an event callback list and can be * "fired" multiple times. * * Possible options: * * once: will ensure the callback list can only be fired once (like a Deferred) * * memory: will keep track of previous values and will call any callback added * after the list has been fired right away with the latest "memorized" * values (like a Deferred) * * unique: will ensure a callback can only be added once (no duplicate in the list) * * stopOnFalse: interrupt callings when a callback returns false * */ jQuery.Callbacks = function( options ) { // Convert options from String-formatted to Object-formatted if needed // (we check in cache first) options = typeof options === "string" ? createOptions( options ) : jQuery.extend( {}, options ); var // Flag to know if list is currently firing firing, // Last fire value for non-forgettable lists memory, // Flag to know if list was already fired fired, // Flag to prevent firing locked, // Actual callback list list = [], // Queue of execution data for repeatable lists queue = [], // Index of currently firing callback (modified by add/remove as needed) firingIndex = -1, // Fire callbacks fire = function() { // Enforce single-firing locked = locked || options.once; // Execute callbacks for all pending executions, // respecting firingIndex overrides and runtime changes fired = firing = true; for ( ; queue.length; firingIndex = -1 ) { memory = queue.shift(); while ( ++firingIndex < list.length ) { // Run callback and check for early termination if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && options.stopOnFalse ) { // Jump to end and forget the data so .add doesn't re-fire firingIndex = list.length; memory = false; } } } // Forget the data if we're done with it if ( !options.memory ) { memory = false; } firing = false; // Clean up if we're done firing for good if ( locked ) { // Keep an empty list if we have data for future add calls if ( memory ) { list = []; // Otherwise, this object is spent } else { list = ""; } } }, // Actual Callbacks object self = { // Add a callback or a collection of callbacks to the list add: function() { if ( list ) { // If we have memory from a past run, we should fire after adding if ( memory && !firing ) { firingIndex = list.length - 1; queue.push( memory ); } ( function add( args ) { jQuery.each( args, function( _, arg ) { if ( isFunction( arg ) ) { if ( !options.unique || !self.has( arg ) ) { list.push( arg ); } } else if ( arg && arg.length && toType( arg ) !== "string" ) { // Inspect recursively add( arg ); } } ); } )( arguments ); if ( memory && !firing ) { fire(); } } return this; }, // Remove a callback from the list remove: function() { jQuery.each( arguments, function( _, arg ) { var index; while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { list.splice( index, 1 ); // Handle firing indexes if ( index <= firingIndex ) { firingIndex--; } } } ); return this; }, // Check if a given callback is in the list. // If no argument is given, return whether or not list has callbacks attached. has: function( fn ) { return fn ? jQuery.inArray( fn, list ) > -1 : list.length > 0; }, // Remove all callbacks from the list empty: function() { if ( list ) { list = []; } return this; }, // Disable .fire and .add // Abort any current/pending executions // Clear all callbacks and values disable: function() { locked = queue = []; list = memory = ""; return this; }, disabled: function() { return !list; }, // Disable .fire // Also disable .add unless we have memory (since it would have no effect) // Abort any pending executions lock: function() { locked = queue = []; if ( !memory && !firing ) { list = memory = ""; } return this; }, locked: function() { return !!locked; }, // Call all callbacks with the given context and arguments fireWith: function( context, args ) { if ( !locked ) { args = args || []; args = [ context, args.slice ? args.slice() : args ]; queue.push( args ); if ( !firing ) { fire(); } } return this; }, // Call all the callbacks with the given arguments fire: function() { self.fireWith( this, arguments ); return this; }, // To know if the callbacks have already been called at least once fired: function() { return !!fired; } }; return self; }; function Identity( v ) { return v; } function Thrower( ex ) { throw ex; } function adoptValue( value, resolve, reject, noValue ) { var method; try { // Check for promise aspect first to privilege synchronous behavior if ( value && isFunction( ( method = value.promise ) ) ) { method.call( value ).done( resolve ).fail( reject ); // Other thenables } else if ( value && isFunction( ( method = value.then ) ) ) { method.call( value, resolve, reject ); // Other non-thenables } else { // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: // * false: [ value ].slice( 0 ) => resolve( value ) // * true: [ value ].slice( 1 ) => resolve() resolve.apply( undefined, [ value ].slice( noValue ) ); } // For Promises/A+, convert exceptions into rejections // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in // Deferred#then to conditionally suppress rejection. } catch ( value ) { // Support: Android 4.0 only // Strict mode functions invoked without .call/.apply get global-object context reject.apply( undefined, [ value ] ); } } jQuery.extend( { Deferred: function( func ) { var tuples = [ // action, add listener, callbacks, // ... .then handlers, argument index, [final state] [ "notify", "progress", jQuery.Callbacks( "memory" ), jQuery.Callbacks( "memory" ), 2 ], [ "resolve", "done", jQuery.Callbacks( "once memory" ), jQuery.Callbacks( "once memory" ), 0, "resolved" ], [ "reject", "fail", jQuery.Callbacks( "once memory" ), jQuery.Callbacks( "once memory" ), 1, "rejected" ] ], state = "pending", promise = { state: function() { return state; }, always: function() { deferred.done( arguments ).fail( arguments ); return this; }, "catch": function( fn ) { return promise.then( null, fn ); }, // Keep pipe for back-compat pipe: function( /* fnDone, fnFail, fnProgress */ ) { var fns = arguments; return jQuery.Deferred( function( newDefer ) { jQuery.each( tuples, function( i, tuple ) { // Map tuples (progress, done, fail) to arguments (done, fail, progress) var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; // deferred.progress(function() { bind to newDefer or newDefer.notify }) // deferred.done(function() { bind to newDefer or newDefer.resolve }) // deferred.fail(function() { bind to newDefer or newDefer.reject }) deferred[ tuple[ 1 ] ]( function() { var returned = fn && fn.apply( this, arguments ); if ( returned && isFunction( returned.promise ) ) { returned.promise() .progress( newDefer.notify ) .done( newDefer.resolve ) .fail( newDefer.reject ); } else { newDefer[ tuple[ 0 ] + "With" ]( this, fn ? [ returned ] : arguments ); } } ); } ); fns = null; } ).promise(); }, then: function( onFulfilled, onRejected, onProgress ) { var maxDepth = 0; function resolve( depth, deferred, handler, special ) { return function() { var that = this, args = arguments, mightThrow = function() { var returned, then; // Support: Promises/A+ section 2.3.3.3.3 // https://promisesaplus.com/#point-59 // Ignore double-resolution attempts if ( depth < maxDepth ) { return; } returned = handler.apply( that, args ); // Support: Promises/A+ section 2.3.1 // https://promisesaplus.com/#point-48 if ( returned === deferred.promise() ) { throw new TypeError( "Thenable self-resolution" ); } // Support: Promises/A+ sections 2.3.3.1, 3.5 // https://promisesaplus.com/#point-54 // https://promisesaplus.com/#point-75 // Retrieve `then` only once then = returned && // Support: Promises/A+ section 2.3.4 // https://promisesaplus.com/#point-64 // Only check objects and functions for thenability ( typeof returned === "object" || typeof returned === "function" ) && returned.then; // Handle a returned thenable if ( isFunction( then ) ) { // Special processors (notify) just wait for resolution if ( special ) { then.call( returned, resolve( maxDepth, deferred, Identity, special ), resolve( maxDepth, deferred, Thrower, special ) ); // Normal processors (resolve) also hook into progress } else { // ...and disregard older resolution values maxDepth++; then.call( returned, resolve( maxDepth, deferred, Identity, special ), resolve( maxDepth, deferred, Thrower, special ), resolve( maxDepth, deferred, Identity, deferred.notifyWith ) ); } // Handle all other returned values } else { // Only substitute handlers pass on context // and multiple values (non-spec behavior) if ( handler !== Identity ) { that = undefined; args = [ returned ]; } // Process the value(s) // Default process is resolve ( special || deferred.resolveWith )( that, args ); } }, // Only normal processors (resolve) catch and reject exceptions process = special ? mightThrow : function() { try { mightThrow(); } catch ( e ) { if ( jQuery.Deferred.exceptionHook ) { jQuery.Deferred.exceptionHook( e, process.stackTrace ); } // Support: Promises/A+ section 2.3.3.3.4.1 // https://promisesaplus.com/#point-61 // Ignore post-resolution exceptions if ( depth + 1 >= maxDepth ) { // Only substitute handlers pass on context // and multiple values (non-spec behavior) if ( handler !== Thrower ) { that = undefined; args = [ e ]; } deferred.rejectWith( that, args ); } } }; // Support: Promises/A+ section 2.3.3.3.1 // https://promisesaplus.com/#point-57 // Re-resolve promises immediately to dodge false rejection from // subsequent errors if ( depth ) { process(); } else { // Call an optional hook to record the stack, in case of exception // since it's otherwise lost when execution goes async if ( jQuery.Deferred.getStackHook ) { process.stackTrace = jQuery.Deferred.getStackHook(); } window.setTimeout( process ); } }; } return jQuery.Deferred( function( newDefer ) { // progress_handlers.add( ... ) tuples[ 0 ][ 3 ].add( resolve( 0, newDefer, isFunction( onProgress ) ? onProgress : Identity, newDefer.notifyWith ) ); // fulfilled_handlers.add( ... ) tuples[ 1 ][ 3 ].add( resolve( 0, newDefer, isFunction( onFulfilled ) ? onFulfilled : Identity ) ); // rejected_handlers.add( ... ) tuples[ 2 ][ 3 ].add( resolve( 0, newDefer, isFunction( onRejected ) ? onRejected : Thrower ) ); } ).promise(); }, // Get a promise for this deferred // If obj is provided, the promise aspect is added to the object promise: function( obj ) { return obj != null ? jQuery.extend( obj, promise ) : promise; } }, deferred = {}; // Add list-specific methods jQuery.each( tuples, function( i, tuple ) { var list = tuple[ 2 ], stateString = tuple[ 5 ]; // promise.progress = list.add // promise.done = list.add // promise.fail = list.add promise[ tuple[ 1 ] ] = list.add; // Handle state if ( stateString ) { list.add( function() { // state = "resolved" (i.e., fulfilled) // state = "rejected" state = stateString; }, // rejected_callbacks.disable // fulfilled_callbacks.disable tuples[ 3 - i ][ 2 ].disable, // rejected_handlers.disable // fulfilled_handlers.disable tuples[ 3 - i ][ 3 ].disable, // progress_callbacks.lock tuples[ 0 ][ 2 ].lock, // progress_handlers.lock tuples[ 0 ][ 3 ].lock ); } // progress_handlers.fire // fulfilled_handlers.fire // rejected_handlers.fire list.add( tuple[ 3 ].fire ); // deferred.notify = function() { deferred.notifyWith(...) } // deferred.resolve = function() { deferred.resolveWith(...) } // deferred.reject = function() { deferred.rejectWith(...) } deferred[ tuple[ 0 ] ] = function() { deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); return this; }; // deferred.notifyWith = list.fireWith // deferred.resolveWith = list.fireWith // deferred.rejectWith = list.fireWith deferred[ tuple[ 0 ] + "With" ] = list.fireWith; } ); // Make the deferred a promise promise.promise( deferred ); // Call given func if any if ( func ) { func.call( deferred, deferred ); } // All done! return deferred; }, // Deferred helper when: function( singleValue ) { var // count of uncompleted subordinates remaining = arguments.length, // count of unprocessed arguments i = remaining, // subordinate fulfillment data resolveContexts = Array( i ), resolveValues = slice.call( arguments ), // the master Deferred master = jQuery.Deferred(), // subordinate callback factory updateFunc = function( i ) { return function( value ) { resolveContexts[ i ] = this; resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; if ( !( --remaining ) ) { master.resolveWith( resolveContexts, resolveValues ); } }; }; // Single- and empty arguments are adopted like Promise.resolve if ( remaining <= 1 ) { adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject, !remaining ); // Use .then() to unwrap secondary thenables (cf. gh-3000) if ( master.state() === "pending" || isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { return master.then(); } } // Multiple arguments are aggregated like Promise.all array elements while ( i-- ) { adoptValue( resolveValues[ i ], updateFunc( i ), master.reject ); } return master.promise(); } } ); // These usually indicate a programmer mistake during development, // warn about them ASAP rather than swallowing them by default. var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; jQuery.Deferred.exceptionHook = function( error, stack ) { // Support: IE 8 - 9 only // Console exists when dev tools are open, which can happen at any time if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack ); } }; jQuery.readyException = function( error ) { window.setTimeout( function() { throw error; } ); }; // The deferred used on DOM ready var readyList = jQuery.Deferred(); jQuery.fn.ready = function( fn ) { readyList .then( fn ) // Wrap jQuery.readyException in a function so that the lookup // happens at the time of error handling instead of callback // registration. .catch( function( error ) { jQuery.readyException( error ); } ); return this; }; jQuery.extend( { // Is the DOM ready to be used? Set to true once it occurs. isReady: false, // A counter to track how many items to wait for before // the ready event fires. See #6781 readyWait: 1, // Handle when the DOM is ready ready: function( wait ) { // Abort if there are pending holds or we're already ready if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { return; } // Remember that the DOM is ready jQuery.isReady = true; // If a normal DOM Ready event fired, decrement, and wait if need be if ( wait !== true && --jQuery.readyWait > 0 ) { return; } // If there are functions bound, to execute readyList.resolveWith( document, [ jQuery ] ); } } ); jQuery.ready.then = readyList.then; // The ready event handler and self cleanup method function completed() { document.removeEventListener( "DOMContentLoaded", completed ); window.removeEventListener( "load", completed ); jQuery.ready(); } // Catch cases where $(document).ready() is called // after the browser event has already occurred. // Support: IE <=9 - 10 only // Older IE sometimes signals "interactive" too soon if ( document.readyState === "complete" || ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { // Handle it asynchronously to allow scripts the opportunity to delay ready window.setTimeout( jQuery.ready ); } else { // Use the handy event callback document.addEventListener( "DOMContentLoaded", completed ); // A fallback to window.onload, that will always work window.addEventListener( "load", completed ); } // Multifunctional method to get and set values of a collection // The value/s can optionally be executed if it's a function var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { var i = 0, len = elems.length, bulk = key == null; // Sets many values if ( toType( key ) === "object" ) { chainable = true; for ( i in key ) { access( elems, fn, i, key[ i ], true, emptyGet, raw ); } // Sets one value } else if ( value !== undefined ) { chainable = true; if ( !isFunction( value ) ) { raw = true; } if ( bulk ) { // Bulk operations run against the entire set if ( raw ) { fn.call( elems, value ); fn = null; // ...except when executing function values } else { bulk = fn; fn = function( elem, key, value ) { return bulk.call( jQuery( elem ), value ); }; } } if ( fn ) { for ( ; i < len; i++ ) { fn( elems[ i ], key, raw ? value : value.call( elems[ i ], i, fn( elems[ i ], key ) ) ); } } } if ( chainable ) { return elems; } // Gets if ( bulk ) { return fn.call( elems ); } return len ? fn( elems[ 0 ], key ) : emptyGet; }; // Matches dashed string for camelizing var rmsPrefix = /^-ms-/, rdashAlpha = /-([a-z])/g; // Used by camelCase as callback to replace() function fcamelCase( all, letter ) { return letter.toUpperCase(); } // Convert dashed to camelCase; used by the css and data modules // Support: IE <=9 - 11, Edge 12 - 15 // Microsoft forgot to hump their vendor prefix (#9572) function camelCase( string ) { return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); } var acceptData = function( owner ) { // Accepts only: // - Node // - Node.ELEMENT_NODE // - Node.DOCUMENT_NODE // - Object // - Any return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); }; function Data() { this.expando = jQuery.expando + Data.uid++; } Data.uid = 1; Data.prototype = { cache: function( owner ) { // Check if the owner object already has a cache var value = owner[ this.expando ]; // If not, create one if ( !value ) { value = {}; // We can accept data for non-element nodes in modern browsers, // but we should not, see #8335. // Always return an empty object. if ( acceptData( owner ) ) { // If it is a node unlikely to be stringify-ed or looped over // use plain assignment if ( owner.nodeType ) { owner[ this.expando ] = value; // Otherwise secure it in a non-enumerable property // configurable must be true to allow the property to be // deleted when data is removed } else { Object.defineProperty( owner, this.expando, { value: value, configurable: true } ); } } } return value; }, set: function( owner, data, value ) { var prop, cache = this.cache( owner ); // Handle: [ owner, key, value ] args // Always use camelCase key (gh-2257) if ( typeof data === "string" ) { cache[ camelCase( data ) ] = value; // Handle: [ owner, { properties } ] args } else { // Copy the properties one-by-one to the cache object for ( prop in data ) { cache[ camelCase( prop ) ] = data[ prop ]; } } return cache; }, get: function( owner, key ) { return key === undefined ? this.cache( owner ) : // Always use camelCase key (gh-2257) owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; }, access: function( owner, key, value ) { // In cases where either: // // 1. No key was specified // 2. A string key was specified, but no value provided // // Take the "read" path and allow the get method to determine // which value to return, respectively either: // // 1. The entire cache object // 2. The data stored at the key // if ( key === undefined || ( ( key && typeof key === "string" ) && value === undefined ) ) { return this.get( owner, key ); } // When the key is not a string, or both a key and value // are specified, set or extend (existing objects) with either: // // 1. An object of properties // 2. A key and value // this.set( owner, key, value ); // Since the "set" path can have two possible entry points // return the expected data based on which path was taken[*] return value !== undefined ? value : key; }, remove: function( owner, key ) { var i, cache = owner[ this.expando ]; if ( cache === undefined ) { return; } if ( key !== undefined ) { // Support array or space separated string of keys if ( Array.isArray( key ) ) { // If key is an array of keys... // We always set camelCase keys, so remove that. key = key.map( camelCase ); } else { key = camelCase( key ); // If a key with the spaces exists, use it. // Otherwise, create an array by matching non-whitespace key = key in cache ? [ key ] : ( key.match( rnothtmlwhite ) || [] ); } i = key.length; while ( i-- ) { delete cache[ key[ i ] ]; } } // Remove the expando if there's no more data if ( key === undefined || jQuery.isEmptyObject( cache ) ) { // Support: Chrome <=35 - 45 // Webkit & Blink performance suffers when deleting properties // from DOM nodes, so set to undefined instead // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) if ( owner.nodeType ) { owner[ this.expando ] = undefined; } else { delete owner[ this.expando ]; } } }, hasData: function( owner ) { var cache = owner[ this.expando ]; return cache !== undefined && !jQuery.isEmptyObject( cache ); } }; var dataPriv = new Data(); var dataUser = new Data(); // Implementation Summary // // 1. Enforce API surface and semantic compatibility with 1.9.x branch // 2. Improve the module's maintainability by reducing the storage // paths to a single mechanism. // 3. Use the same single mechanism to support "private" and "user" data. // 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) // 5. Avoid exposing implementation details on user objects (eg. expando properties) // 6. Provide a clear path for implementation upgrade to WeakMap in 2014 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /[A-Z]/g; function getData( data ) { if ( data === "true" ) { return true; } if ( data === "false" ) { return false; } if ( data === "null" ) { return null; } // Only convert to a number if it doesn't change the string if ( data === +data + "" ) { return +data; } if ( rbrace.test( data ) ) { return JSON.parse( data ); } return data; } function dataAttr( elem, key, data ) { var name; // If nothing was found internally, try to fetch any // data from the HTML5 data-* attribute if ( data === undefined && elem.nodeType === 1 ) { name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); data = elem.getAttribute( name ); if ( typeof data === "string" ) { try { data = getData( data ); } catch ( e ) {} // Make sure we set the data so it isn't changed later dataUser.set( elem, key, data ); } else { data = undefined; } } return data; } jQuery.extend( { hasData: function( elem ) { return dataUser.hasData( elem ) || dataPriv.hasData( elem ); }, data: function( elem, name, data ) { return dataUser.access( elem, name, data ); }, removeData: function( elem, name ) { dataUser.remove( elem, name ); }, // TODO: Now that all calls to _data and _removeData have been replaced // with direct calls to dataPriv methods, these can be deprecated. _data: function( elem, name, data ) { return dataPriv.access( elem, name, data ); }, _removeData: function( elem, name ) { dataPriv.remove( elem, name ); } } ); jQuery.fn.extend( { data: function( key, value ) { var i, name, data, elem = this[ 0 ], attrs = elem && elem.attributes; // Gets all values if ( key === undefined ) { if ( this.length ) { data = dataUser.get( elem ); if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { i = attrs.length; while ( i-- ) { // Support: IE 11 only // The attrs elements can be null (#14894) if ( attrs[ i ] ) { name = attrs[ i ].name; if ( name.indexOf( "data-" ) === 0 ) { name = camelCase( name.slice( 5 ) ); dataAttr( elem, name, data[ name ] ); } } } dataPriv.set( elem, "hasDataAttrs", true ); } } return data; } // Sets multiple values if ( typeof key === "object" ) { return this.each( function() { dataUser.set( this, key ); } ); } return access( this, function( value ) { var data; // The calling jQuery object (element matches) is not empty // (and therefore has an element appears at this[ 0 ]) and the // `value` parameter was not undefined. An empty jQuery object // will result in `undefined` for elem = this[ 0 ] which will // throw an exception if an attempt to read a data cache is made. if ( elem && value === undefined ) { // Attempt to get data from the cache // The key will always be camelCased in Data data = dataUser.get( elem, key ); if ( data !== undefined ) { return data; } // Attempt to "discover" the data in // HTML5 custom data-* attrs data = dataAttr( elem, key ); if ( data !== undefined ) { return data; } // We tried really hard, but the data doesn't exist. return; } // Set the data... this.each( function() { // We always store the camelCased key dataUser.set( this, key, value ); } ); }, null, value, arguments.length > 1, null, true ); }, removeData: function( key ) { return this.each( function() { dataUser.remove( this, key ); } ); } } ); jQuery.extend( { queue: function( elem, type, data ) { var queue; if ( elem ) { type = ( type || "fx" ) + "queue"; queue = dataPriv.get( elem, type ); // Speed up dequeue by getting out quickly if this is just a lookup if ( data ) { if ( !queue || Array.isArray( data ) ) { queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); } else { queue.push( data ); } } return queue || []; } }, dequeue: function( elem, type ) { type = type || "fx"; var queue = jQuery.queue( elem, type ), startLength = queue.length, fn = queue.shift(), hooks = jQuery._queueHooks( elem, type ), next = function() { jQuery.dequeue( elem, type ); }; // If the fx queue is dequeued, always remove the progress sentinel if ( fn === "inprogress" ) { fn = queue.shift(); startLength--; } if ( fn ) { // Add a progress sentinel to prevent the fx queue from being // automatically dequeued if ( type === "fx" ) { queue.unshift( "inprogress" ); } // Clear up the last queue stop function delete hooks.stop; fn.call( elem, next, hooks ); } if ( !startLength && hooks ) { hooks.empty.fire(); } }, // Not public - generate a queueHooks object, or return the current one _queueHooks: function( elem, type ) { var key = type + "queueHooks"; return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { empty: jQuery.Callbacks( "once memory" ).add( function() { dataPriv.remove( elem, [ type + "queue", key ] ); } ) } ); } } ); jQuery.fn.extend( { queue: function( type, data ) { var setter = 2; if ( typeof type !== "string" ) { data = type; type = "fx"; setter--; } if ( arguments.length < setter ) { return jQuery.queue( this[ 0 ], type ); } return data === undefined ? this : this.each( function() { var queue = jQuery.queue( this, type, data ); // Ensure a hooks for this queue jQuery._queueHooks( this, type ); if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { jQuery.dequeue( this, type ); } } ); }, dequeue: function( type ) { return this.each( function() { jQuery.dequeue( this, type ); } ); }, clearQueue: function( type ) { return this.queue( type || "fx", [] ); }, // Get a promise resolved when queues of a certain type // are emptied (fx is the type by default) promise: function( type, obj ) { var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function() { if ( !( --count ) ) { defer.resolveWith( elements, [ elements ] ); } }; if ( typeof type !== "string" ) { obj = type; type = undefined; } type = type || "fx"; while ( i-- ) { tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); if ( tmp && tmp.empty ) { count++; tmp.empty.add( resolve ); } } resolve(); return defer.promise( obj ); } } ); var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; var isHiddenWithinTree = function( elem, el ) { // isHiddenWithinTree might be called from jQuery#filter function; // in that case, element will be second argument elem = el || elem; // Inline style trumps all return elem.style.display === "none" || elem.style.display === "" && // Otherwise, check computed style // Support: Firefox <=43 - 45 // Disconnected elements can have computed display: none, so first confirm that elem is // in the document. jQuery.contains( elem.ownerDocument, elem ) && jQuery.css( elem, "display" ) === "none"; }; var swap = function( elem, options, callback, args ) { var ret, name, old = {}; // Remember the old values, and insert the new ones for ( name in options ) { old[ name ] = elem.style[ name ]; elem.style[ name ] = options[ name ]; } ret = callback.apply( elem, args || [] ); // Revert the old values for ( name in options ) { elem.style[ name ] = old[ name ]; } return ret; }; function adjustCSS( elem, prop, valueParts, tween ) { var adjusted, scale, maxIterations = 20, currentValue = tween ? function() { return tween.cur(); } : function() { return jQuery.css( elem, prop, "" ); }, initial = currentValue(), unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), // Starting value computation is required for potential unit mismatches initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && rcssNum.exec( jQuery.css( elem, prop ) ); if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { // Support: Firefox <=54 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) initial = initial / 2; // Trust units reported by jQuery.css unit = unit || initialInUnit[ 3 ]; // Iteratively approximate from a nonzero starting point initialInUnit = +initial || 1; while ( maxIterations-- ) { // Evaluate and update our best guess (doubling guesses that zero out). // Finish if the scale equals or crosses 1 (making the old*new product non-positive). jQuery.style( elem, prop, initialInUnit + unit ); if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { maxIterations = 0; } initialInUnit = initialInUnit / scale; } initialInUnit = initialInUnit * 2; jQuery.style( elem, prop, initialInUnit + unit ); // Make sure we update the tween properties later on valueParts = valueParts || []; } if ( valueParts ) { initialInUnit = +initialInUnit || +initial || 0; // Apply relative offset (+=/-=) if specified adjusted = valueParts[ 1 ] ? initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : +valueParts[ 2 ]; if ( tween ) { tween.unit = unit; tween.start = initialInUnit; tween.end = adjusted; } } return adjusted; } var defaultDisplayMap = {}; function getDefaultDisplay( elem ) { var temp, doc = elem.ownerDocument, nodeName = elem.nodeName, display = defaultDisplayMap[ nodeName ]; if ( display ) { return display; } temp = doc.body.appendChild( doc.createElement( nodeName ) ); display = jQuery.css( temp, "display" ); temp.parentNode.removeChild( temp ); if ( display === "none" ) { display = "block"; } defaultDisplayMap[ nodeName ] = display; return display; } function showHide( elements, show ) { var display, elem, values = [], index = 0, length = elements.length; // Determine new display value for elements that need to change for ( ; index < length; index++ ) { elem = elements[ index ]; if ( !elem.style ) { continue; } display = elem.style.display; if ( show ) { // Since we force visibility upon cascade-hidden elements, an immediate (and slow) // check is required in this first loop unless we have a nonempty display value (either // inline or about-to-be-restored) if ( display === "none" ) { values[ index ] = dataPriv.get( elem, "display" ) || null; if ( !values[ index ] ) { elem.style.display = ""; } } if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { values[ index ] = getDefaultDisplay( elem ); } } else { if ( display !== "none" ) { values[ index ] = "none"; // Remember what we're overwriting dataPriv.set( elem, "display", display ); } } } // Set the display of the elements in a second loop to avoid constant reflow for ( index = 0; index < length; index++ ) { if ( values[ index ] != null ) { elements[ index ].style.display = values[ index ]; } } return elements; } jQuery.fn.extend( { show: function() { return showHide( this, true ); }, hide: function() { return showHide( this ); }, toggle: function( state ) { if ( typeof state === "boolean" ) { return state ? this.show() : this.hide(); } return this.each( function() { if ( isHiddenWithinTree( this ) ) { jQuery( this ).show(); } else { jQuery( this ).hide(); } } ); } } ); var rcheckableType = ( /^(?:checkbox|radio)$/i ); var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i ); var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); // We have to close these tags to support XHTML (#13200) var wrapMap = { // Support: IE <=9 only option: [ 1, "" ], // XHTML parsers do not magically insert elements in the // same way that tag soup parsers do. So we cannot shorten // this by omitting or other required elements. thead: [ 1, "", "
" ], col: [ 2, "", "
" ], tr: [ 2, "", "
" ], td: [ 3, "", "
" ], _default: [ 0, "", "" ] }; // Support: IE <=9 only wrapMap.optgroup = wrapMap.option; wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; wrapMap.th = wrapMap.td; function getAll( context, tag ) { // Support: IE <=9 - 11 only // Use typeof to avoid zero-argument method invocation on host objects (#15151) var ret; if ( typeof context.getElementsByTagName !== "undefined" ) { ret = context.getElementsByTagName( tag || "*" ); } else if ( typeof context.querySelectorAll !== "undefined" ) { ret = context.querySelectorAll( tag || "*" ); } else { ret = []; } if ( tag === undefined || tag && nodeName( context, tag ) ) { return jQuery.merge( [ context ], ret ); } return ret; } // Mark scripts as having already been evaluated function setGlobalEval( elems, refElements ) { var i = 0, l = elems.length; for ( ; i < l; i++ ) { dataPriv.set( elems[ i ], "globalEval", !refElements || dataPriv.get( refElements[ i ], "globalEval" ) ); } } var rhtml = /<|&#?\w+;/; function buildFragment( elems, context, scripts, selection, ignored ) { var elem, tmp, tag, wrap, contains, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length; for ( ; i < l; i++ ) { elem = elems[ i ]; if ( elem || elem === 0 ) { // Add nodes directly if ( toType( elem ) === "object" ) { // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); // Convert non-html into a text node } else if ( !rhtml.test( elem ) ) { nodes.push( context.createTextNode( elem ) ); // Convert html into DOM nodes } else { tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); // Deserialize a standard representation tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); wrap = wrapMap[ tag ] || wrapMap._default; tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; // Descend through wrappers to the right content j = wrap[ 0 ]; while ( j-- ) { tmp = tmp.lastChild; } // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( nodes, tmp.childNodes ); // Remember the top-level container tmp = fragment.firstChild; // Ensure the created nodes are orphaned (#12392) tmp.textContent = ""; } } } // Remove wrapper from fragment fragment.textContent = ""; i = 0; while ( ( elem = nodes[ i++ ] ) ) { // Skip elements already in the context collection (trac-4087) if ( selection && jQuery.inArray( elem, selection ) > -1 ) { if ( ignored ) { ignored.push( elem ); } continue; } contains = jQuery.contains( elem.ownerDocument, elem ); // Append to fragment tmp = getAll( fragment.appendChild( elem ), "script" ); // Preserve script evaluation history if ( contains ) { setGlobalEval( tmp ); } // Capture executables if ( scripts ) { j = 0; while ( ( elem = tmp[ j++ ] ) ) { if ( rscriptType.test( elem.type || "" ) ) { scripts.push( elem ); } } } } return fragment; } ( function() { var fragment = document.createDocumentFragment(), div = fragment.appendChild( document.createElement( "div" ) ), input = document.createElement( "input" ); // Support: Android 4.0 - 4.3 only // Check state lost if the name is set (#11217) // Support: Windows Web Apps (WWA) // `name` and `type` must use .setAttribute for WWA (#14901) input.setAttribute( "type", "radio" ); input.setAttribute( "checked", "checked" ); input.setAttribute( "name", "t" ); div.appendChild( input ); // Support: Android <=4.1 only // Older WebKit doesn't clone checked state correctly in fragments support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; // Support: IE <=11 only // Make sure textarea (and checkbox) defaultValue is properly cloned div.innerHTML = ""; support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; } )(); var documentElement = document.documentElement; var rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/; function returnTrue() { return true; } function returnFalse() { return false; } // Support: IE <=9 only // See #13393 for more info function safeActiveElement() { try { return document.activeElement; } catch ( err ) { } } function on( elem, types, selector, data, fn, one ) { var origFn, type; // Types can be a map of types/handlers if ( typeof types === "object" ) { // ( types-Object, selector, data ) if ( typeof selector !== "string" ) { // ( types-Object, data ) data = data || selector; selector = undefined; } for ( type in types ) { on( elem, type, selector, data, types[ type ], one ); } return elem; } if ( data == null && fn == null ) { // ( types, fn ) fn = selector; data = selector = undefined; } else if ( fn == null ) { if ( typeof selector === "string" ) { // ( types, selector, fn ) fn = data; data = undefined; } else { // ( types, data, fn ) fn = data; data = selector; selector = undefined; } } if ( fn === false ) { fn = returnFalse; } else if ( !fn ) { return elem; } if ( one === 1 ) { origFn = fn; fn = function( event ) { // Can use an empty set, since event contains the info jQuery().off( event ); return origFn.apply( this, arguments ); }; // Use same guid so caller can remove using origFn fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); } return elem.each( function() { jQuery.event.add( this, types, fn, data, selector ); } ); } /* * Helper functions for managing events -- not part of the public interface. * Props to Dean Edwards' addEvent library for many of the ideas. */ jQuery.event = { global: {}, add: function( elem, types, handler, data, selector ) { var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get( elem ); // Don't attach events to noData or text/comment nodes (but allow plain objects) if ( !elemData ) { return; } // Caller can pass in an object of custom data in lieu of the handler if ( handler.handler ) { handleObjIn = handler; handler = handleObjIn.handler; selector = handleObjIn.selector; } // Ensure that invalid selectors throw exceptions at attach time // Evaluate against documentElement in case elem is a non-element node (e.g., document) if ( selector ) { jQuery.find.matchesSelector( documentElement, selector ); } // Make sure that the handler has a unique ID, used to find/remove it later if ( !handler.guid ) { handler.guid = jQuery.guid++; } // Init the element's event structure and main handler, if this is the first if ( !( events = elemData.events ) ) { events = elemData.events = {}; } if ( !( eventHandle = elemData.handle ) ) { eventHandle = elemData.handle = function( e ) { // Discard the second event of a jQuery.event.trigger() and // when an event is called after a page has unloaded return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply( elem, arguments ) : undefined; }; } // Handle multiple events separated by a space types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; t = types.length; while ( t-- ) { tmp = rtypenamespace.exec( types[ t ] ) || []; type = origType = tmp[ 1 ]; namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); // There *must* be a type, no attaching namespace-only handlers if ( !type ) { continue; } // If event changes its type, use the special event handlers for the changed type special = jQuery.event.special[ type ] || {}; // If selector defined, determine special event api type, otherwise given type type = ( selector ? special.delegateType : special.bindType ) || type; // Update special based on newly reset type special = jQuery.event.special[ type ] || {}; // handleObj is passed to all event handlers handleObj = jQuery.extend( { type: type, origType: origType, data: data, handler: handler, guid: handler.guid, selector: selector, needsContext: selector && jQuery.expr.match.needsContext.test( selector ), namespace: namespaces.join( "." ) }, handleObjIn ); // Init the event handler queue if we're the first if ( !( handlers = events[ type ] ) ) { handlers = events[ type ] = []; handlers.delegateCount = 0; // Only use addEventListener if the special events handler returns false if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { if ( elem.addEventListener ) { elem.addEventListener( type, eventHandle ); } } } if ( special.add ) { special.add.call( elem, handleObj ); if ( !handleObj.handler.guid ) { handleObj.handler.guid = handler.guid; } } // Add to the element's handler list, delegates in front if ( selector ) { handlers.splice( handlers.delegateCount++, 0, handleObj ); } else { handlers.push( handleObj ); } // Keep track of which events have ever been used, for event optimization jQuery.event.global[ type ] = true; } }, // Detach an event or set of events from an element remove: function( elem, types, handler, selector, mappedTypes ) { var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); if ( !elemData || !( events = elemData.events ) ) { return; } // Once for each type.namespace in types; type may be omitted types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; t = types.length; while ( t-- ) { tmp = rtypenamespace.exec( types[ t ] ) || []; type = origType = tmp[ 1 ]; namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); // Unbind all events (on this namespace, if provided) for the element if ( !type ) { for ( type in events ) { jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); } continue; } special = jQuery.event.special[ type ] || {}; type = ( selector ? special.delegateType : special.bindType ) || type; handlers = events[ type ] || []; tmp = tmp[ 2 ] && new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); // Remove matching events origCount = j = handlers.length; while ( j-- ) { handleObj = handlers[ j ]; if ( ( mappedTypes || origType === handleObj.origType ) && ( !handler || handler.guid === handleObj.guid ) && ( !tmp || tmp.test( handleObj.namespace ) ) && ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { handlers.splice( j, 1 ); if ( handleObj.selector ) { handlers.delegateCount--; } if ( special.remove ) { special.remove.call( elem, handleObj ); } } } // Remove generic event handler if we removed something and no more handlers exist // (avoids potential for endless recursion during removal of special event handlers) if ( origCount && !handlers.length ) { if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { jQuery.removeEvent( elem, type, elemData.handle ); } delete events[ type ]; } } // Remove data and the expando if it's no longer used if ( jQuery.isEmptyObject( events ) ) { dataPriv.remove( elem, "handle events" ); } }, dispatch: function( nativeEvent ) { // Make a writable jQuery.Event from the native event object var event = jQuery.event.fix( nativeEvent ); var i, j, ret, matched, handleObj, handlerQueue, args = new Array( arguments.length ), handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [], special = jQuery.event.special[ event.type ] || {}; // Use the fix-ed jQuery.Event rather than the (read-only) native event args[ 0 ] = event; for ( i = 1; i < arguments.length; i++ ) { args[ i ] = arguments[ i ]; } event.delegateTarget = this; // Call the preDispatch hook for the mapped type, and let it bail if desired if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { return; } // Determine handlers handlerQueue = jQuery.event.handlers.call( this, event, handlers ); // Run delegates first; they may want to stop propagation beneath us i = 0; while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { event.currentTarget = matched.elem; j = 0; while ( ( handleObj = matched.handlers[ j++ ] ) && !event.isImmediatePropagationStopped() ) { // Triggered event must either 1) have no namespace, or 2) have namespace(s) // a subset or equal to those in the bound event (both can have no namespace). if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) { event.handleObj = handleObj; event.data = handleObj.data; ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || handleObj.handler ).apply( matched.elem, args ); if ( ret !== undefined ) { if ( ( event.result = ret ) === false ) { event.preventDefault(); event.stopPropagation(); } } } } } // Call the postDispatch hook for the mapped type if ( special.postDispatch ) { special.postDispatch.call( this, event ); } return event.result; }, handlers: function( event, handlers ) { var i, handleObj, sel, matchedHandlers, matchedSelectors, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target; // Find delegate handlers if ( delegateCount && // Support: IE <=9 // Black-hole SVG instance trees (trac-13180) cur.nodeType && // Support: Firefox <=42 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click // Support: IE 11 only // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) !( event.type === "click" && event.button >= 1 ) ) { for ( ; cur !== this; cur = cur.parentNode || this ) { // Don't check non-elements (#13208) // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { matchedHandlers = []; matchedSelectors = {}; for ( i = 0; i < delegateCount; i++ ) { handleObj = handlers[ i ]; // Don't conflict with Object.prototype properties (#13203) sel = handleObj.selector + " "; if ( matchedSelectors[ sel ] === undefined ) { matchedSelectors[ sel ] = handleObj.needsContext ? jQuery( sel, this ).index( cur ) > -1 : jQuery.find( sel, this, null, [ cur ] ).length; } if ( matchedSelectors[ sel ] ) { matchedHandlers.push( handleObj ); } } if ( matchedHandlers.length ) { handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); } } } } // Add the remaining (directly-bound) handlers cur = this; if ( delegateCount < handlers.length ) { handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); } return handlerQueue; }, addProp: function( name, hook ) { Object.defineProperty( jQuery.Event.prototype, name, { enumerable: true, configurable: true, get: isFunction( hook ) ? function() { if ( this.originalEvent ) { return hook( this.originalEvent ); } } : function() { if ( this.originalEvent ) { return this.originalEvent[ name ]; } }, set: function( value ) { Object.defineProperty( this, name, { enumerable: true, configurable: true, writable: true, value: value } ); } } ); }, fix: function( originalEvent ) { return originalEvent[ jQuery.expando ] ? originalEvent : new jQuery.Event( originalEvent ); }, special: { load: { // Prevent triggered image.load events from bubbling to window.load noBubble: true }, focus: { // Fire native event if possible so blur/focus sequence is correct trigger: function() { if ( this !== safeActiveElement() && this.focus ) { this.focus(); return false; } }, delegateType: "focusin" }, blur: { trigger: function() { if ( this === safeActiveElement() && this.blur ) { this.blur(); return false; } }, delegateType: "focusout" }, click: { // For checkbox, fire native event so checked state will be right trigger: function() { if ( this.type === "checkbox" && this.click && nodeName( this, "input" ) ) { this.click(); return false; } }, // For cross-browser consistency, don't fire native .click() on links _default: function( event ) { return nodeName( event.target, "a" ); } }, beforeunload: { postDispatch: function( event ) { // Support: Firefox 20+ // Firefox doesn't alert if the returnValue field is not set. if ( event.result !== undefined && event.originalEvent ) { event.originalEvent.returnValue = event.result; } } } } }; jQuery.removeEvent = function( elem, type, handle ) { // This "if" is needed for plain objects if ( elem.removeEventListener ) { elem.removeEventListener( type, handle ); } }; jQuery.Event = function( src, props ) { // Allow instantiation without the 'new' keyword if ( !( this instanceof jQuery.Event ) ) { return new jQuery.Event( src, props ); } // Event object if ( src && src.type ) { this.originalEvent = src; this.type = src.type; // Events bubbling up the document may have been marked as prevented // by a handler lower down the tree; reflect the correct value. this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && // Support: Android <=2.3 only src.returnValue === false ? returnTrue : returnFalse; // Create target properties // Support: Safari <=6 - 7 only // Target should not be a text node (#504, #13143) this.target = ( src.target && src.target.nodeType === 3 ) ? src.target.parentNode : src.target; this.currentTarget = src.currentTarget; this.relatedTarget = src.relatedTarget; // Event type } else { this.type = src; } // Put explicitly provided properties onto the event object if ( props ) { jQuery.extend( this, props ); } // Create a timestamp if incoming event doesn't have one this.timeStamp = src && src.timeStamp || Date.now(); // Mark it as fixed this[ jQuery.expando ] = true; }; // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html jQuery.Event.prototype = { constructor: jQuery.Event, isDefaultPrevented: returnFalse, isPropagationStopped: returnFalse, isImmediatePropagationStopped: returnFalse, isSimulated: false, preventDefault: function() { var e = this.originalEvent; this.isDefaultPrevented = returnTrue; if ( e && !this.isSimulated ) { e.preventDefault(); } }, stopPropagation: function() { var e = this.originalEvent; this.isPropagationStopped = returnTrue; if ( e && !this.isSimulated ) { e.stopPropagation(); } }, stopImmediatePropagation: function() { var e = this.originalEvent; this.isImmediatePropagationStopped = returnTrue; if ( e && !this.isSimulated ) { e.stopImmediatePropagation(); } this.stopPropagation(); } }; // Includes all common event props including KeyEvent and MouseEvent specific props jQuery.each( { altKey: true, bubbles: true, cancelable: true, changedTouches: true, ctrlKey: true, detail: true, eventPhase: true, metaKey: true, pageX: true, pageY: true, shiftKey: true, view: true, "char": true, charCode: true, key: true, keyCode: true, button: true, buttons: true, clientX: true, clientY: true, offsetX: true, offsetY: true, pointerId: true, pointerType: true, screenX: true, screenY: true, targetTouches: true, toElement: true, touches: true, which: function( event ) { var button = event.button; // Add which for key events if ( event.which == null && rkeyEvent.test( event.type ) ) { return event.charCode != null ? event.charCode : event.keyCode; } // Add which for click: 1 === left; 2 === middle; 3 === right if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) { if ( button & 1 ) { return 1; } if ( button & 2 ) { return 3; } if ( button & 4 ) { return 2; } return 0; } return event.which; } }, jQuery.event.addProp ); // Create mouseenter/leave events using mouseover/out and event-time checks // so that event delegation works in jQuery. // Do the same for pointerenter/pointerleave and pointerover/pointerout // // Support: Safari 7 only // Safari sends mouseenter too often; see: // https://bugs.chromium.org/p/chromium/issues/detail?id=470258 // for the description of the bug (it existed in older Chrome versions as well). jQuery.each( { mouseenter: "mouseover", mouseleave: "mouseout", pointerenter: "pointerover", pointerleave: "pointerout" }, function( orig, fix ) { jQuery.event.special[ orig ] = { delegateType: fix, bindType: fix, handle: function( event ) { var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj; // For mouseenter/leave call the handler if related is outside the target. // NB: No relatedTarget if the mouse left/entered the browser window if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { event.type = handleObj.origType; ret = handleObj.handler.apply( this, arguments ); event.type = fix; } return ret; } }; } ); jQuery.fn.extend( { on: function( types, selector, data, fn ) { return on( this, types, selector, data, fn ); }, one: function( types, selector, data, fn ) { return on( this, types, selector, data, fn, 1 ); }, off: function( types, selector, fn ) { var handleObj, type; if ( types && types.preventDefault && types.handleObj ) { // ( event ) dispatched jQuery.Event handleObj = types.handleObj; jQuery( types.delegateTarget ).off( handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler ); return this; } if ( typeof types === "object" ) { // ( types-object [, selector] ) for ( type in types ) { this.off( type, selector, types[ type ] ); } return this; } if ( selector === false || typeof selector === "function" ) { // ( types [, fn] ) fn = selector; selector = undefined; } if ( fn === false ) { fn = returnFalse; } return this.each( function() { jQuery.event.remove( this, types, fn, selector ); } ); } } ); var /* eslint-disable max-len */ // See https://github.com/eslint/eslint/issues/3229 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi, /* eslint-enable */ // Support: IE <=10 - 11, Edge 12 - 13 only // In IE/Edge using regex groups here causes severe slowdowns. // See https://connect.microsoft.com/IE/feedback/details/1736512/ rnoInnerhtml = /\s*$/g; // Prefer a tbody over its parent table for containing new rows function manipulationTarget( elem, content ) { if ( nodeName( elem, "table" ) && nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { return jQuery( elem ).children( "tbody" )[ 0 ] || elem; } return elem; } // Replace/restore the type attribute of script elements for safe DOM manipulation function disableScript( elem ) { elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; return elem; } function restoreScript( elem ) { if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { elem.type = elem.type.slice( 5 ); } else { elem.removeAttribute( "type" ); } return elem; } function cloneCopyEvent( src, dest ) { var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events; if ( dest.nodeType !== 1 ) { return; } // 1. Copy private data: events, handlers, etc. if ( dataPriv.hasData( src ) ) { pdataOld = dataPriv.access( src ); pdataCur = dataPriv.set( dest, pdataOld ); events = pdataOld.events; if ( events ) { delete pdataCur.handle; pdataCur.events = {}; for ( type in events ) { for ( i = 0, l = events[ type ].length; i < l; i++ ) { jQuery.event.add( dest, type, events[ type ][ i ] ); } } } } // 2. Copy user data if ( dataUser.hasData( src ) ) { udataOld = dataUser.access( src ); udataCur = jQuery.extend( {}, udataOld ); dataUser.set( dest, udataCur ); } } // Fix IE bugs, see support tests function fixInput( src, dest ) { var nodeName = dest.nodeName.toLowerCase(); // Fails to persist the checked state of a cloned checkbox or radio button. if ( nodeName === "input" && rcheckableType.test( src.type ) ) { dest.checked = src.checked; // Fails to return the selected option to the default selected state when cloning options } else if ( nodeName === "input" || nodeName === "textarea" ) { dest.defaultValue = src.defaultValue; } } function domManip( collection, args, callback, ignored ) { // Flatten any nested arrays args = concat.apply( [], args ); var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[ 0 ], valueIsFunction = isFunction( value ); // We can't cloneNode fragments that contain checked, in WebKit if ( valueIsFunction || ( l > 1 && typeof value === "string" && !support.checkClone && rchecked.test( value ) ) ) { return collection.each( function( index ) { var self = collection.eq( index ); if ( valueIsFunction ) { args[ 0 ] = value.call( this, index, self.html() ); } domManip( self, args, callback, ignored ); } ); } if ( l ) { fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); first = fragment.firstChild; if ( fragment.childNodes.length === 1 ) { fragment = first; } // Require either new content or an interest in ignored elements to invoke the callback if ( first || ignored ) { scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); hasScripts = scripts.length; // Use the original fragment for the last item // instead of the first because it can end up // being emptied incorrectly in certain situations (#8070). for ( ; i < l; i++ ) { node = fragment; if ( i !== iNoClone ) { node = jQuery.clone( node, true, true ); // Keep references to cloned scripts for later restoration if ( hasScripts ) { // Support: Android <=4.0 only, PhantomJS 1 only // push.apply(_, arraylike) throws on ancient WebKit jQuery.merge( scripts, getAll( node, "script" ) ); } } callback.call( collection[ i ], node, i ); } if ( hasScripts ) { doc = scripts[ scripts.length - 1 ].ownerDocument; // Reenable scripts jQuery.map( scripts, restoreScript ); // Evaluate executable scripts on first document insertion for ( i = 0; i < hasScripts; i++ ) { node = scripts[ i ]; if ( rscriptType.test( node.type || "" ) && !dataPriv.access( node, "globalEval" ) && jQuery.contains( doc, node ) ) { if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { // Optional AJAX dependency, but won't run scripts if not present if ( jQuery._evalUrl ) { jQuery._evalUrl( node.src ); } } else { DOMEval( node.textContent.replace( rcleanScript, "" ), doc, node ); } } } } } } return collection; } function remove( elem, selector, keepData ) { var node, nodes = selector ? jQuery.filter( selector, elem ) : elem, i = 0; for ( ; ( node = nodes[ i ] ) != null; i++ ) { if ( !keepData && node.nodeType === 1 ) { jQuery.cleanData( getAll( node ) ); } if ( node.parentNode ) { if ( keepData && jQuery.contains( node.ownerDocument, node ) ) { setGlobalEval( getAll( node, "script" ) ); } node.parentNode.removeChild( node ); } } return elem; } jQuery.extend( { htmlPrefilter: function( html ) { return html.replace( rxhtmlTag, "<$1>" ); }, clone: function( elem, dataAndEvents, deepDataAndEvents ) { var i, l, srcElements, destElements, clone = elem.cloneNode( true ), inPage = jQuery.contains( elem.ownerDocument, elem ); // Fix IE cloning issues if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && !jQuery.isXMLDoc( elem ) ) { // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2 destElements = getAll( clone ); srcElements = getAll( elem ); for ( i = 0, l = srcElements.length; i < l; i++ ) { fixInput( srcElements[ i ], destElements[ i ] ); } } // Copy the events from the original to the clone if ( dataAndEvents ) { if ( deepDataAndEvents ) { srcElements = srcElements || getAll( elem ); destElements = destElements || getAll( clone ); for ( i = 0, l = srcElements.length; i < l; i++ ) { cloneCopyEvent( srcElements[ i ], destElements[ i ] ); } } else { cloneCopyEvent( elem, clone ); } } // Preserve script evaluation history destElements = getAll( clone, "script" ); if ( destElements.length > 0 ) { setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); } // Return the cloned set return clone; }, cleanData: function( elems ) { var data, elem, type, special = jQuery.event.special, i = 0; for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { if ( acceptData( elem ) ) { if ( ( data = elem[ dataPriv.expando ] ) ) { if ( data.events ) { for ( type in data.events ) { if ( special[ type ] ) { jQuery.event.remove( elem, type ); // This is a shortcut to avoid jQuery.event.remove's overhead } else { jQuery.removeEvent( elem, type, data.handle ); } } } // Support: Chrome <=35 - 45+ // Assign undefined instead of using delete, see Data#remove elem[ dataPriv.expando ] = undefined; } if ( elem[ dataUser.expando ] ) { // Support: Chrome <=35 - 45+ // Assign undefined instead of using delete, see Data#remove elem[ dataUser.expando ] = undefined; } } } } } ); jQuery.fn.extend( { detach: function( selector ) { return remove( this, selector, true ); }, remove: function( selector ) { return remove( this, selector ); }, text: function( value ) { return access( this, function( value ) { return value === undefined ? jQuery.text( this ) : this.empty().each( function() { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { this.textContent = value; } } ); }, null, value, arguments.length ); }, append: function() { return domManip( this, arguments, function( elem ) { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { var target = manipulationTarget( this, elem ); target.appendChild( elem ); } } ); }, prepend: function() { return domManip( this, arguments, function( elem ) { if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { var target = manipulationTarget( this, elem ); target.insertBefore( elem, target.firstChild ); } } ); }, before: function() { return domManip( this, arguments, function( elem ) { if ( this.parentNode ) { this.parentNode.insertBefore( elem, this ); } } ); }, after: function() { return domManip( this, arguments, function( elem ) { if ( this.parentNode ) { this.parentNode.insertBefore( elem, this.nextSibling ); } } ); }, empty: function() { var elem, i = 0; for ( ; ( elem = this[ i ] ) != null; i++ ) { if ( elem.nodeType === 1 ) { // Prevent memory leaks jQuery.cleanData( getAll( elem, false ) ); // Remove any remaining nodes elem.textContent = ""; } } return this; }, clone: function( dataAndEvents, deepDataAndEvents ) { dataAndEvents = dataAndEvents == null ? false : dataAndEvents; deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; return this.map( function() { return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); } ); }, html: function( value ) { return access( this, function( value ) { var elem = this[ 0 ] || {}, i = 0, l = this.length; if ( value === undefined && elem.nodeType === 1 ) { return elem.innerHTML; } // See if we can take a shortcut and just use innerHTML if ( typeof value === "string" && !rnoInnerhtml.test( value ) && !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { value = jQuery.htmlPrefilter( value ); try { for ( ; i < l; i++ ) { elem = this[ i ] || {}; // Remove element nodes and prevent memory leaks if ( elem.nodeType === 1 ) { jQuery.cleanData( getAll( elem, false ) ); elem.innerHTML = value; } } elem = 0; // If using innerHTML throws an exception, use the fallback method } catch ( e ) {} } if ( elem ) { this.empty().append( value ); } }, null, value, arguments.length ); }, replaceWith: function() { var ignored = []; // Make the changes, replacing each non-ignored context element with the new content return domManip( this, arguments, function( elem ) { var parent = this.parentNode; if ( jQuery.inArray( this, ignored ) < 0 ) { jQuery.cleanData( getAll( this ) ); if ( parent ) { parent.replaceChild( elem, this ); } } // Force callback invocation }, ignored ); } } ); jQuery.each( { appendTo: "append", prependTo: "prepend", insertBefore: "before", insertAfter: "after", replaceAll: "replaceWith" }, function( name, original ) { jQuery.fn[ name ] = function( selector ) { var elems, ret = [], insert = jQuery( selector ), last = insert.length - 1, i = 0; for ( ; i <= last; i++ ) { elems = i === last ? this : this.clone( true ); jQuery( insert[ i ] )[ original ]( elems ); // Support: Android <=4.0 only, PhantomJS 1 only // .get() because push.apply(_, arraylike) throws on ancient WebKit push.apply( ret, elems.get() ); } return this.pushStack( ret ); }; } ); var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); var getStyles = function( elem ) { // Support: IE <=11 only, Firefox <=30 (#15098, #14150) // IE throws on elements created in popups // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" var view = elem.ownerDocument.defaultView; if ( !view || !view.opener ) { view = window; } return view.getComputedStyle( elem ); }; var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); ( function() { // Executing both pixelPosition & boxSizingReliable tests require only one layout // so they're executed at the same time to save the second computation. function computeStyleTests() { // This is a singleton, we need to execute it only once if ( !div ) { return; } container.style.cssText = "position:absolute;left:-11111px;width:60px;" + "margin-top:1px;padding:0;border:0"; div.style.cssText = "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + "margin:auto;border:1px;padding:1px;" + "width:60%;top:1%"; documentElement.appendChild( container ).appendChild( div ); var divStyle = window.getComputedStyle( div ); pixelPositionVal = divStyle.top !== "1%"; // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 // Some styles come back with percentage values, even though they shouldn't div.style.right = "60%"; pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; // Support: IE 9 - 11 only // Detect misreporting of content dimensions for box-sizing:border-box elements boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; // Support: IE 9 only // Detect overflow:scroll screwiness (gh-3699) div.style.position = "absolute"; scrollboxSizeVal = div.offsetWidth === 36 || "absolute"; documentElement.removeChild( container ); // Nullify the div so it wouldn't be stored in the memory and // it will also be a sign that checks already performed div = null; } function roundPixelMeasures( measure ) { return Math.round( parseFloat( measure ) ); } var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, reliableMarginLeftVal, container = document.createElement( "div" ), div = document.createElement( "div" ); // Finish early in limited (non-browser) environments if ( !div.style ) { return; } // Support: IE <=9 - 11 only // Style of cloned element affects source element cloned (#8908) div.style.backgroundClip = "content-box"; div.cloneNode( true ).style.backgroundClip = ""; support.clearCloneStyle = div.style.backgroundClip === "content-box"; jQuery.extend( support, { boxSizingReliable: function() { computeStyleTests(); return boxSizingReliableVal; }, pixelBoxStyles: function() { computeStyleTests(); return pixelBoxStylesVal; }, pixelPosition: function() { computeStyleTests(); return pixelPositionVal; }, reliableMarginLeft: function() { computeStyleTests(); return reliableMarginLeftVal; }, scrollboxSize: function() { computeStyleTests(); return scrollboxSizeVal; } } ); } )(); function curCSS( elem, name, computed ) { var width, minWidth, maxWidth, ret, // Support: Firefox 51+ // Retrieving style before computed somehow // fixes an issue with getting wrong values // on detached elements style = elem.style; computed = computed || getStyles( elem ); // getPropertyValue is needed for: // .css('filter') (IE 9 only, #12537) // .css('--customProperty) (#3144) if ( computed ) { ret = computed.getPropertyValue( name ) || computed[ name ]; if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) { ret = jQuery.style( elem, name ); } // A tribute to the "awesome hack by Dean Edwards" // Android Browser returns percentage for some values, // but width seems to be reliably pixels. // This is against the CSSOM draft spec: // https://drafts.csswg.org/cssom/#resolved-values if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { // Remember the original values width = style.width; minWidth = style.minWidth; maxWidth = style.maxWidth; // Put in the new values to get a computed value out style.minWidth = style.maxWidth = style.width = ret; ret = computed.width; // Revert the changed values style.width = width; style.minWidth = minWidth; style.maxWidth = maxWidth; } } return ret !== undefined ? // Support: IE <=9 - 11 only // IE returns zIndex value as an integer. ret + "" : ret; } function addGetHookIf( conditionFn, hookFn ) { // Define the hook, we'll check on the first run if it's really needed. return { get: function() { if ( conditionFn() ) { // Hook not needed (or it's not possible to use it due // to missing dependency), remove it. delete this.get; return; } // Hook needed; redefine it so that the support test is not executed again. return ( this.get = hookFn ).apply( this, arguments ); } }; } var // Swappable if display is none or starts with table // except "table", "table-cell", or "table-caption" // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display rdisplayswap = /^(none|table(?!-c[ea]).+)/, rcustomProp = /^--/, cssShow = { position: "absolute", visibility: "hidden", display: "block" }, cssNormalTransform = { letterSpacing: "0", fontWeight: "400" }, cssPrefixes = [ "Webkit", "Moz", "ms" ], emptyStyle = document.createElement( "div" ).style; // Return a css property mapped to a potentially vendor prefixed property function vendorPropName( name ) { // Shortcut for names that are not vendor prefixed if ( name in emptyStyle ) { return name; } // Check for vendor prefixed names var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), i = cssPrefixes.length; while ( i-- ) { name = cssPrefixes[ i ] + capName; if ( name in emptyStyle ) { return name; } } } // Return a property mapped along what jQuery.cssProps suggests or to // a vendor prefixed property. function finalPropName( name ) { var ret = jQuery.cssProps[ name ]; if ( !ret ) { ret = jQuery.cssProps[ name ] = vendorPropName( name ) || name; } return ret; } function setPositiveNumber( elem, value, subtract ) { // Any relative (+/-) values have already been // normalized at this point var matches = rcssNum.exec( value ); return matches ? // Guard against undefined "subtract", e.g., when used as in cssHooks Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : value; } function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { var i = dimension === "width" ? 1 : 0, extra = 0, delta = 0; // Adjustment may not be necessary if ( box === ( isBorderBox ? "border" : "content" ) ) { return 0; } for ( ; i < 4; i += 2 ) { // Both box models exclude margin if ( box === "margin" ) { delta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); } // If we get here with a content-box, we're seeking "padding" or "border" or "margin" if ( !isBorderBox ) { // Add padding delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); // For "border" or "margin", add border if ( box !== "padding" ) { delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); // But still keep track of it otherwise } else { extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); } // If we get here with a border-box (content + padding + border), we're seeking "content" or // "padding" or "margin" } else { // For "content", subtract padding if ( box === "content" ) { delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); } // For "content" or "padding", subtract border if ( box !== "margin" ) { delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); } } } // Account for positive content-box scroll gutter when requested by providing computedVal if ( !isBorderBox && computedVal >= 0 ) { // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border // Assuming integer scroll gutter, subtract the rest and round down delta += Math.max( 0, Math.ceil( elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - computedVal - delta - extra - 0.5 ) ); } return delta; } function getWidthOrHeight( elem, dimension, extra ) { // Start with computed style var styles = getStyles( elem ), val = curCSS( elem, dimension, styles ), isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box", valueIsBorderBox = isBorderBox; // Support: Firefox <=54 // Return a confounding non-pixel value or feign ignorance, as appropriate. if ( rnumnonpx.test( val ) ) { if ( !extra ) { return val; } val = "auto"; } // Check for style in case a browser which returns unreliable values // for getComputedStyle silently falls back to the reliable elem.style valueIsBorderBox = valueIsBorderBox && ( support.boxSizingReliable() || val === elem.style[ dimension ] ); // Fall back to offsetWidth/offsetHeight when value is "auto" // This happens for inline elements with no explicit setting (gh-3571) // Support: Android <=4.1 - 4.3 only // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) if ( val === "auto" || !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) { val = elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ]; // offsetWidth/offsetHeight provide border-box values valueIsBorderBox = true; } // Normalize "" and auto val = parseFloat( val ) || 0; // Adjust for the element's box model return ( val + boxModelAdjustment( elem, dimension, extra || ( isBorderBox ? "border" : "content" ), valueIsBorderBox, styles, // Provide the current computed size to request scroll gutter calculation (gh-3589) val ) ) + "px"; } jQuery.extend( { // Add in style property hooks for overriding the default // behavior of getting and setting a style property cssHooks: { opacity: { get: function( elem, computed ) { if ( computed ) { // We should always get a number back from opacity var ret = curCSS( elem, "opacity" ); return ret === "" ? "1" : ret; } } } }, // Don't automatically add "px" to these possibly-unitless properties cssNumber: { "animationIterationCount": true, "columnCount": true, "fillOpacity": true, "flexGrow": true, "flexShrink": true, "fontWeight": true, "lineHeight": true, "opacity": true, "order": true, "orphans": true, "widows": true, "zIndex": true, "zoom": true }, // Add in properties whose names you wish to fix before // setting or getting the value cssProps: {}, // Get and set the style property on a DOM Node style: function( elem, name, value, extra ) { // Don't set styles on text and comment nodes if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { return; } // Make sure that we're working with the right name var ret, type, hooks, origName = camelCase( name ), isCustomProp = rcustomProp.test( name ), style = elem.style; // Make sure that we're working with the right name. We don't // want to query the value if it is a CSS custom property // since they are user-defined. if ( !isCustomProp ) { name = finalPropName( origName ); } // Gets hook for the prefixed version, then unprefixed version hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; // Check if we're setting a value if ( value !== undefined ) { type = typeof value; // Convert "+=" or "-=" to relative numbers (#7345) if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { value = adjustCSS( elem, name, ret ); // Fixes bug #9237 type = "number"; } // Make sure that null and NaN values aren't set (#7116) if ( value == null || value !== value ) { return; } // If a number was passed in, add the unit (except for certain CSS properties) if ( type === "number" ) { value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); } // background-* props affect original clone's values if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { style[ name ] = "inherit"; } // If a hook was provided, use that value, otherwise just set the specified value if ( !hooks || !( "set" in hooks ) || ( value = hooks.set( elem, value, extra ) ) !== undefined ) { if ( isCustomProp ) { style.setProperty( name, value ); } else { style[ name ] = value; } } } else { // If a hook was provided get the non-computed value from there if ( hooks && "get" in hooks && ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { return ret; } // Otherwise just get the value from the style object return style[ name ]; } }, css: function( elem, name, extra, styles ) { var val, num, hooks, origName = camelCase( name ), isCustomProp = rcustomProp.test( name ); // Make sure that we're working with the right name. We don't // want to modify the value if it is a CSS custom property // since they are user-defined. if ( !isCustomProp ) { name = finalPropName( origName ); } // Try prefixed name followed by the unprefixed name hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; // If a hook was provided get the computed value from there if ( hooks && "get" in hooks ) { val = hooks.get( elem, true, extra ); } // Otherwise, if a way to get the computed value exists, use that if ( val === undefined ) { val = curCSS( elem, name, styles ); } // Convert "normal" to computed value if ( val === "normal" && name in cssNormalTransform ) { val = cssNormalTransform[ name ]; } // Make numeric if forced or a qualifier was provided and val looks numeric if ( extra === "" || extra ) { num = parseFloat( val ); return extra === true || isFinite( num ) ? num || 0 : val; } return val; } } ); jQuery.each( [ "height", "width" ], function( i, dimension ) { jQuery.cssHooks[ dimension ] = { get: function( elem, computed, extra ) { if ( computed ) { // Certain elements can have dimension info if we invisibly show them // but it must have a current display style that would benefit return rdisplayswap.test( jQuery.css( elem, "display" ) ) && // Support: Safari 8+ // Table columns in Safari have non-zero offsetWidth & zero // getBoundingClientRect().width unless display is changed. // Support: IE <=11 only // Running getBoundingClientRect on a disconnected node // in IE throws an error. ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? swap( elem, cssShow, function() { return getWidthOrHeight( elem, dimension, extra ); } ) : getWidthOrHeight( elem, dimension, extra ); } }, set: function( elem, value, extra ) { var matches, styles = getStyles( elem ), isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box", subtract = extra && boxModelAdjustment( elem, dimension, extra, isBorderBox, styles ); // Account for unreliable border-box dimensions by comparing offset* to computed and // faking a content-box to get border and padding (gh-3699) if ( isBorderBox && support.scrollboxSize() === styles.position ) { subtract -= Math.ceil( elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - parseFloat( styles[ dimension ] ) - boxModelAdjustment( elem, dimension, "border", false, styles ) - 0.5 ); } // Convert to pixels if value adjustment is needed if ( subtract && ( matches = rcssNum.exec( value ) ) && ( matches[ 3 ] || "px" ) !== "px" ) { elem.style[ dimension ] = value; value = jQuery.css( elem, dimension ); } return setPositiveNumber( elem, value, subtract ); } }; } ); jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, function( elem, computed ) { if ( computed ) { return ( parseFloat( curCSS( elem, "marginLeft" ) ) || elem.getBoundingClientRect().left - swap( elem, { marginLeft: 0 }, function() { return elem.getBoundingClientRect().left; } ) ) + "px"; } } ); // These hooks are used by animate to expand properties jQuery.each( { margin: "", padding: "", border: "Width" }, function( prefix, suffix ) { jQuery.cssHooks[ prefix + suffix ] = { expand: function( value ) { var i = 0, expanded = {}, // Assumes a single number if not a string parts = typeof value === "string" ? value.split( " " ) : [ value ]; for ( ; i < 4; i++ ) { expanded[ prefix + cssExpand[ i ] + suffix ] = parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; } return expanded; } }; if ( prefix !== "margin" ) { jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; } } ); jQuery.fn.extend( { css: function( name, value ) { return access( this, function( elem, name, value ) { var styles, len, map = {}, i = 0; if ( Array.isArray( name ) ) { styles = getStyles( elem ); len = name.length; for ( ; i < len; i++ ) { map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); } return map; } return value !== undefined ? jQuery.style( elem, name, value ) : jQuery.css( elem, name ); }, name, value, arguments.length > 1 ); } } ); function Tween( elem, options, prop, end, easing ) { return new Tween.prototype.init( elem, options, prop, end, easing ); } jQuery.Tween = Tween; Tween.prototype = { constructor: Tween, init: function( elem, options, prop, end, easing, unit ) { this.elem = elem; this.prop = prop; this.easing = easing || jQuery.easing._default; this.options = options; this.start = this.now = this.cur(); this.end = end; this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); }, cur: function() { var hooks = Tween.propHooks[ this.prop ]; return hooks && hooks.get ? hooks.get( this ) : Tween.propHooks._default.get( this ); }, run: function( percent ) { var eased, hooks = Tween.propHooks[ this.prop ]; if ( this.options.duration ) { this.pos = eased = jQuery.easing[ this.easing ]( percent, this.options.duration * percent, 0, 1, this.options.duration ); } else { this.pos = eased = percent; } this.now = ( this.end - this.start ) * eased + this.start; if ( this.options.step ) { this.options.step.call( this.elem, this.now, this ); } if ( hooks && hooks.set ) { hooks.set( this ); } else { Tween.propHooks._default.set( this ); } return this; } }; Tween.prototype.init.prototype = Tween.prototype; Tween.propHooks = { _default: { get: function( tween ) { var result; // Use a property on the element directly when it is not a DOM element, // or when there is no matching style property that exists. if ( tween.elem.nodeType !== 1 || tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { return tween.elem[ tween.prop ]; } // Passing an empty string as a 3rd parameter to .css will automatically // attempt a parseFloat and fallback to a string if the parse fails. // Simple values such as "10px" are parsed to Float; // complex values such as "rotate(1rad)" are returned as-is. result = jQuery.css( tween.elem, tween.prop, "" ); // Empty strings, null, undefined and "auto" are converted to 0. return !result || result === "auto" ? 0 : result; }, set: function( tween ) { // Use step hook for back compat. // Use cssHook if its there. // Use .style if available and use plain properties where available. if ( jQuery.fx.step[ tween.prop ] ) { jQuery.fx.step[ tween.prop ]( tween ); } else if ( tween.elem.nodeType === 1 && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) { jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); } else { tween.elem[ tween.prop ] = tween.now; } } } }; // Support: IE <=9 only // Panic based approach to setting things on disconnected nodes Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { set: function( tween ) { if ( tween.elem.nodeType && tween.elem.parentNode ) { tween.elem[ tween.prop ] = tween.now; } } }; jQuery.easing = { linear: function( p ) { return p; }, swing: function( p ) { return 0.5 - Math.cos( p * Math.PI ) / 2; }, _default: "swing" }; jQuery.fx = Tween.prototype.init; // Back compat <1.8 extension point jQuery.fx.step = {}; var fxNow, inProgress, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/; function schedule() { if ( inProgress ) { if ( document.hidden === false && window.requestAnimationFrame ) { window.requestAnimationFrame( schedule ); } else { window.setTimeout( schedule, jQuery.fx.interval ); } jQuery.fx.tick(); } } // Animations created synchronously will run synchronously function createFxNow() { window.setTimeout( function() { fxNow = undefined; } ); return ( fxNow = Date.now() ); } // Generate parameters to create a standard animation function genFx( type, includeWidth ) { var which, i = 0, attrs = { height: type }; // If we include width, step value is 1 to do all cssExpand values, // otherwise step value is 2 to skip over Left and Right includeWidth = includeWidth ? 1 : 0; for ( ; i < 4; i += 2 - includeWidth ) { which = cssExpand[ i ]; attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; } if ( includeWidth ) { attrs.opacity = attrs.width = type; } return attrs; } function createTween( value, prop, animation ) { var tween, collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), index = 0, length = collection.length; for ( ; index < length; index++ ) { if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { // We're done with this property return tween; } } } function defaultPrefilter( elem, props, opts ) { var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, isBox = "width" in props || "height" in props, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHiddenWithinTree( elem ), dataShow = dataPriv.get( elem, "fxshow" ); // Queue-skipping animations hijack the fx hooks if ( !opts.queue ) { hooks = jQuery._queueHooks( elem, "fx" ); if ( hooks.unqueued == null ) { hooks.unqueued = 0; oldfire = hooks.empty.fire; hooks.empty.fire = function() { if ( !hooks.unqueued ) { oldfire(); } }; } hooks.unqueued++; anim.always( function() { // Ensure the complete handler is called before this completes anim.always( function() { hooks.unqueued--; if ( !jQuery.queue( elem, "fx" ).length ) { hooks.empty.fire(); } } ); } ); } // Detect show/hide animations for ( prop in props ) { value = props[ prop ]; if ( rfxtypes.test( value ) ) { delete props[ prop ]; toggle = toggle || value === "toggle"; if ( value === ( hidden ? "hide" : "show" ) ) { // Pretend to be hidden if this is a "show" and // there is still data from a stopped show/hide if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { hidden = true; // Ignore all other no-op show/hide data } else { continue; } } orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); } } // Bail out if this is a no-op like .hide().hide() propTween = !jQuery.isEmptyObject( props ); if ( !propTween && jQuery.isEmptyObject( orig ) ) { return; } // Restrict "overflow" and "display" styles during box animations if ( isBox && elem.nodeType === 1 ) { // Support: IE <=9 - 11, Edge 12 - 15 // Record all 3 overflow attributes because IE does not infer the shorthand // from identically-valued overflowX and overflowY and Edge just mirrors // the overflowX value there. opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; // Identify a display type, preferring old show/hide data over the CSS cascade restoreDisplay = dataShow && dataShow.display; if ( restoreDisplay == null ) { restoreDisplay = dataPriv.get( elem, "display" ); } display = jQuery.css( elem, "display" ); if ( display === "none" ) { if ( restoreDisplay ) { display = restoreDisplay; } else { // Get nonempty value(s) by temporarily forcing visibility showHide( [ elem ], true ); restoreDisplay = elem.style.display || restoreDisplay; display = jQuery.css( elem, "display" ); showHide( [ elem ] ); } } // Animate inline elements as inline-block if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { if ( jQuery.css( elem, "float" ) === "none" ) { // Restore the original display value at the end of pure show/hide animations if ( !propTween ) { anim.done( function() { style.display = restoreDisplay; } ); if ( restoreDisplay == null ) { display = style.display; restoreDisplay = display === "none" ? "" : display; } } style.display = "inline-block"; } } } if ( opts.overflow ) { style.overflow = "hidden"; anim.always( function() { style.overflow = opts.overflow[ 0 ]; style.overflowX = opts.overflow[ 1 ]; style.overflowY = opts.overflow[ 2 ]; } ); } // Implement show/hide animations propTween = false; for ( prop in orig ) { // General show/hide setup for this element animation if ( !propTween ) { if ( dataShow ) { if ( "hidden" in dataShow ) { hidden = dataShow.hidden; } } else { dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); } // Store hidden/visible for toggle so `.stop().toggle()` "reverses" if ( toggle ) { dataShow.hidden = !hidden; } // Show elements before animating them if ( hidden ) { showHide( [ elem ], true ); } /* eslint-disable no-loop-func */ anim.done( function() { /* eslint-enable no-loop-func */ // The final step of a "hide" animation is actually hiding the element if ( !hidden ) { showHide( [ elem ] ); } dataPriv.remove( elem, "fxshow" ); for ( prop in orig ) { jQuery.style( elem, prop, orig[ prop ] ); } } ); } // Per-property setup propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); if ( !( prop in dataShow ) ) { dataShow[ prop ] = propTween.start; if ( hidden ) { propTween.end = propTween.start; propTween.start = 0; } } } } function propFilter( props, specialEasing ) { var index, name, easing, value, hooks; // camelCase, specialEasing and expand cssHook pass for ( index in props ) { name = camelCase( index ); easing = specialEasing[ name ]; value = props[ index ]; if ( Array.isArray( value ) ) { easing = value[ 1 ]; value = props[ index ] = value[ 0 ]; } if ( index !== name ) { props[ name ] = value; delete props[ index ]; } hooks = jQuery.cssHooks[ name ]; if ( hooks && "expand" in hooks ) { value = hooks.expand( value ); delete props[ name ]; // Not quite $.extend, this won't overwrite existing keys. // Reusing 'index' because we have the correct "name" for ( index in value ) { if ( !( index in props ) ) { props[ index ] = value[ index ]; specialEasing[ index ] = easing; } } } else { specialEasing[ name ] = easing; } } } function Animation( elem, properties, options ) { var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery.Deferred().always( function() { // Don't match elem in the :animated selector delete tick.elem; } ), tick = function() { if ( stopped ) { return false; } var currentTime = fxNow || createFxNow(), remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), // Support: Android 2.3 only // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length; for ( ; index < length; index++ ) { animation.tweens[ index ].run( percent ); } deferred.notifyWith( elem, [ animation, percent, remaining ] ); // If there's more to do, yield if ( percent < 1 && length ) { return remaining; } // If this was an empty animation, synthesize a final progress notification if ( !length ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); } // Resolve the animation and report its conclusion deferred.resolveWith( elem, [ animation ] ); return false; }, animation = deferred.promise( { elem: elem, props: jQuery.extend( {}, properties ), opts: jQuery.extend( true, { specialEasing: {}, easing: jQuery.easing._default }, options ), originalProperties: properties, originalOptions: options, startTime: fxNow || createFxNow(), duration: options.duration, tweens: [], createTween: function( prop, end ) { var tween = jQuery.Tween( elem, animation.opts, prop, end, animation.opts.specialEasing[ prop ] || animation.opts.easing ); animation.tweens.push( tween ); return tween; }, stop: function( gotoEnd ) { var index = 0, // If we are going to the end, we want to run all the tweens // otherwise we skip this part length = gotoEnd ? animation.tweens.length : 0; if ( stopped ) { return this; } stopped = true; for ( ; index < length; index++ ) { animation.tweens[ index ].run( 1 ); } // Resolve when we played the last frame; otherwise, reject if ( gotoEnd ) { deferred.notifyWith( elem, [ animation, 1, 0 ] ); deferred.resolveWith( elem, [ animation, gotoEnd ] ); } else { deferred.rejectWith( elem, [ animation, gotoEnd ] ); } return this; } } ), props = animation.props; propFilter( props, animation.opts.specialEasing ); for ( ; index < length; index++ ) { result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); if ( result ) { if ( isFunction( result.stop ) ) { jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = result.stop.bind( result ); } return result; } } jQuery.map( props, createTween, animation ); if ( isFunction( animation.opts.start ) ) { animation.opts.start.call( elem, animation ); } // Attach callbacks from options animation .progress( animation.opts.progress ) .done( animation.opts.done, animation.opts.complete ) .fail( animation.opts.fail ) .always( animation.opts.always ); jQuery.fx.timer( jQuery.extend( tick, { elem: elem, anim: animation, queue: animation.opts.queue } ) ); return animation; } jQuery.Animation = jQuery.extend( Animation, { tweeners: { "*": [ function( prop, value ) { var tween = this.createTween( prop, value ); adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); return tween; } ] }, tweener: function( props, callback ) { if ( isFunction( props ) ) { callback = props; props = [ "*" ]; } else { props = props.match( rnothtmlwhite ); } var prop, index = 0, length = props.length; for ( ; index < length; index++ ) { prop = props[ index ]; Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; Animation.tweeners[ prop ].unshift( callback ); } }, prefilters: [ defaultPrefilter ], prefilter: function( callback, prepend ) { if ( prepend ) { Animation.prefilters.unshift( callback ); } else { Animation.prefilters.push( callback ); } } } ); jQuery.speed = function( speed, easing, fn ) { var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { complete: fn || !fn && easing || isFunction( speed ) && speed, duration: speed, easing: fn && easing || easing && !isFunction( easing ) && easing }; // Go to the end state if fx are off if ( jQuery.fx.off ) { opt.duration = 0; } else { if ( typeof opt.duration !== "number" ) { if ( opt.duration in jQuery.fx.speeds ) { opt.duration = jQuery.fx.speeds[ opt.duration ]; } else { opt.duration = jQuery.fx.speeds._default; } } } // Normalize opt.queue - true/undefined/null -> "fx" if ( opt.queue == null || opt.queue === true ) { opt.queue = "fx"; } // Queueing opt.old = opt.complete; opt.complete = function() { if ( isFunction( opt.old ) ) { opt.old.call( this ); } if ( opt.queue ) { jQuery.dequeue( this, opt.queue ); } }; return opt; }; jQuery.fn.extend( { fadeTo: function( speed, to, easing, callback ) { // Show any hidden elements after setting opacity to 0 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() // Animate to the value specified .end().animate( { opacity: to }, speed, easing, callback ); }, animate: function( prop, speed, easing, callback ) { var empty = jQuery.isEmptyObject( prop ), optall = jQuery.speed( speed, easing, callback ), doAnimation = function() { // Operate on a copy of prop so per-property easing won't be lost var anim = Animation( this, jQuery.extend( {}, prop ), optall ); // Empty animations, or finishing resolves immediately if ( empty || dataPriv.get( this, "finish" ) ) { anim.stop( true ); } }; doAnimation.finish = doAnimation; return empty || optall.queue === false ? this.each( doAnimation ) : this.queue( optall.queue, doAnimation ); }, stop: function( type, clearQueue, gotoEnd ) { var stopQueue = function( hooks ) { var stop = hooks.stop; delete hooks.stop; stop( gotoEnd ); }; if ( typeof type !== "string" ) { gotoEnd = clearQueue; clearQueue = type; type = undefined; } if ( clearQueue && type !== false ) { this.queue( type || "fx", [] ); } return this.each( function() { var dequeue = true, index = type != null && type + "queueHooks", timers = jQuery.timers, data = dataPriv.get( this ); if ( index ) { if ( data[ index ] && data[ index ].stop ) { stopQueue( data[ index ] ); } } else { for ( index in data ) { if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { stopQueue( data[ index ] ); } } } for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && ( type == null || timers[ index ].queue === type ) ) { timers[ index ].anim.stop( gotoEnd ); dequeue = false; timers.splice( index, 1 ); } } // Start the next in the queue if the last step wasn't forced. // Timers currently will call their complete callbacks, which // will dequeue but only if they were gotoEnd. if ( dequeue || !gotoEnd ) { jQuery.dequeue( this, type ); } } ); }, finish: function( type ) { if ( type !== false ) { type = type || "fx"; } return this.each( function() { var index, data = dataPriv.get( this ), queue = data[ type + "queue" ], hooks = data[ type + "queueHooks" ], timers = jQuery.timers, length = queue ? queue.length : 0; // Enable finishing flag on private data data.finish = true; // Empty the queue first jQuery.queue( this, type, [] ); if ( hooks && hooks.stop ) { hooks.stop.call( this, true ); } // Look for any active animations, and finish them for ( index = timers.length; index--; ) { if ( timers[ index ].elem === this && timers[ index ].queue === type ) { timers[ index ].anim.stop( true ); timers.splice( index, 1 ); } } // Look for any animations in the old queue and finish them for ( index = 0; index < length; index++ ) { if ( queue[ index ] && queue[ index ].finish ) { queue[ index ].finish.call( this ); } } // Turn off finishing flag delete data.finish; } ); } } ); jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) { var cssFn = jQuery.fn[ name ]; jQuery.fn[ name ] = function( speed, easing, callback ) { return speed == null || typeof speed === "boolean" ? cssFn.apply( this, arguments ) : this.animate( genFx( name, true ), speed, easing, callback ); }; } ); // Generate shortcuts for custom animations jQuery.each( { slideDown: genFx( "show" ), slideUp: genFx( "hide" ), slideToggle: genFx( "toggle" ), fadeIn: { opacity: "show" }, fadeOut: { opacity: "hide" }, fadeToggle: { opacity: "toggle" } }, function( name, props ) { jQuery.fn[ name ] = function( speed, easing, callback ) { return this.animate( props, speed, easing, callback ); }; } ); jQuery.timers = []; jQuery.fx.tick = function() { var timer, i = 0, timers = jQuery.timers; fxNow = Date.now(); for ( ; i < timers.length; i++ ) { timer = timers[ i ]; // Run the timer and safely remove it when done (allowing for external removal) if ( !timer() && timers[ i ] === timer ) { timers.splice( i--, 1 ); } } if ( !timers.length ) { jQuery.fx.stop(); } fxNow = undefined; }; jQuery.fx.timer = function( timer ) { jQuery.timers.push( timer ); jQuery.fx.start(); }; jQuery.fx.interval = 13; jQuery.fx.start = function() { if ( inProgress ) { return; } inProgress = true; schedule(); }; jQuery.fx.stop = function() { inProgress = null; }; jQuery.fx.speeds = { slow: 600, fast: 200, // Default speed _default: 400 }; // Based off of the plugin by Clint Helfers, with permission. // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/ jQuery.fn.delay = function( time, type ) { time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; type = type || "fx"; return this.queue( type, function( next, hooks ) { var timeout = window.setTimeout( next, time ); hooks.stop = function() { window.clearTimeout( timeout ); }; } ); }; ( function() { var input = document.createElement( "input" ), select = document.createElement( "select" ), opt = select.appendChild( document.createElement( "option" ) ); input.type = "checkbox"; // Support: Android <=4.3 only // Default value for a checkbox should be "on" support.checkOn = input.value !== ""; // Support: IE <=11 only // Must access selectedIndex to make default options select support.optSelected = opt.selected; // Support: IE <=11 only // An input loses its value after becoming a radio input = document.createElement( "input" ); input.value = "t"; input.type = "radio"; support.radioValue = input.value === "t"; } )(); var boolHook, attrHandle = jQuery.expr.attrHandle; jQuery.fn.extend( { attr: function( name, value ) { return access( this, jQuery.attr, name, value, arguments.length > 1 ); }, removeAttr: function( name ) { return this.each( function() { jQuery.removeAttr( this, name ); } ); } } ); jQuery.extend( { attr: function( elem, name, value ) { var ret, hooks, nType = elem.nodeType; // Don't get/set attributes on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; } // Fallback to prop when attributes are not supported if ( typeof elem.getAttribute === "undefined" ) { return jQuery.prop( elem, name, value ); } // Attribute hooks are determined by the lowercase version // Grab necessary hook if one is defined if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { hooks = jQuery.attrHooks[ name.toLowerCase() ] || ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); } if ( value !== undefined ) { if ( value === null ) { jQuery.removeAttr( elem, name ); return; } if ( hooks && "set" in hooks && ( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; } elem.setAttribute( name, value + "" ); return value; } if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; } ret = jQuery.find.attr( elem, name ); // Non-existent attributes return null, we normalize to undefined return ret == null ? undefined : ret; }, attrHooks: { type: { set: function( elem, value ) { if ( !support.radioValue && value === "radio" && nodeName( elem, "input" ) ) { var val = elem.value; elem.setAttribute( "type", value ); if ( val ) { elem.value = val; } return value; } } } }, removeAttr: function( elem, value ) { var name, i = 0, // Attribute names can contain non-HTML whitespace characters // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 attrNames = value && value.match( rnothtmlwhite ); if ( attrNames && elem.nodeType === 1 ) { while ( ( name = attrNames[ i++ ] ) ) { elem.removeAttribute( name ); } } } } ); // Hooks for boolean attributes boolHook = { set: function( elem, value, name ) { if ( value === false ) { // Remove boolean attributes when set to false jQuery.removeAttr( elem, name ); } else { elem.setAttribute( name, name ); } return name; } }; jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { var getter = attrHandle[ name ] || jQuery.find.attr; attrHandle[ name ] = function( elem, name, isXML ) { var ret, handle, lowercaseName = name.toLowerCase(); if ( !isXML ) { // Avoid an infinite loop by temporarily removing this function from the getter handle = attrHandle[ lowercaseName ]; attrHandle[ lowercaseName ] = ret; ret = getter( elem, name, isXML ) != null ? lowercaseName : null; attrHandle[ lowercaseName ] = handle; } return ret; }; } ); var rfocusable = /^(?:input|select|textarea|button)$/i, rclickable = /^(?:a|area)$/i; jQuery.fn.extend( { prop: function( name, value ) { return access( this, jQuery.prop, name, value, arguments.length > 1 ); }, removeProp: function( name ) { return this.each( function() { delete this[ jQuery.propFix[ name ] || name ]; } ); } } ); jQuery.extend( { prop: function( elem, name, value ) { var ret, hooks, nType = elem.nodeType; // Don't get/set properties on text, comment and attribute nodes if ( nType === 3 || nType === 8 || nType === 2 ) { return; } if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { // Fix name and attach hooks name = jQuery.propFix[ name ] || name; hooks = jQuery.propHooks[ name ]; } if ( value !== undefined ) { if ( hooks && "set" in hooks && ( ret = hooks.set( elem, value, name ) ) !== undefined ) { return ret; } return ( elem[ name ] = value ); } if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { return ret; } return elem[ name ]; }, propHooks: { tabIndex: { get: function( elem ) { // Support: IE <=9 - 11 only // elem.tabIndex doesn't always return the // correct value when it hasn't been explicitly set // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ // Use proper attribute retrieval(#12072) var tabindex = jQuery.find.attr( elem, "tabindex" ); if ( tabindex ) { return parseInt( tabindex, 10 ); } if ( rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ) { return 0; } return -1; } } }, propFix: { "for": "htmlFor", "class": "className" } } ); // Support: IE <=11 only // Accessing the selectedIndex property // forces the browser to respect setting selected // on the option // The getter ensures a default option is selected // when in an optgroup // eslint rule "no-unused-expressions" is disabled for this code // since it considers such accessions noop if ( !support.optSelected ) { jQuery.propHooks.selected = { get: function( elem ) { /* eslint no-unused-expressions: "off" */ var parent = elem.parentNode; if ( parent && parent.parentNode ) { parent.parentNode.selectedIndex; } return null; }, set: function( elem ) { /* eslint no-unused-expressions: "off" */ var parent = elem.parentNode; if ( parent ) { parent.selectedIndex; if ( parent.parentNode ) { parent.parentNode.selectedIndex; } } } }; } jQuery.each( [ "tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable" ], function() { jQuery.propFix[ this.toLowerCase() ] = this; } ); // Strip and collapse whitespace according to HTML spec // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace function stripAndCollapse( value ) { var tokens = value.match( rnothtmlwhite ) || []; return tokens.join( " " ); } function getClass( elem ) { return elem.getAttribute && elem.getAttribute( "class" ) || ""; } function classesToArray( value ) { if ( Array.isArray( value ) ) { return value; } if ( typeof value === "string" ) { return value.match( rnothtmlwhite ) || []; } return []; } jQuery.fn.extend( { addClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; if ( isFunction( value ) ) { return this.each( function( j ) { jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); } ); } classes = classesToArray( value ); if ( classes.length ) { while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem ); cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) { if ( cur.indexOf( " " + clazz + " " ) < 0 ) { cur += clazz + " "; } } // Only assign if different to avoid unneeded rendering. finalValue = stripAndCollapse( cur ); if ( curValue !== finalValue ) { elem.setAttribute( "class", finalValue ); } } } } return this; }, removeClass: function( value ) { var classes, elem, cur, curValue, clazz, j, finalValue, i = 0; if ( isFunction( value ) ) { return this.each( function( j ) { jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); } ); } if ( !arguments.length ) { return this.attr( "class", "" ); } classes = classesToArray( value ); if ( classes.length ) { while ( ( elem = this[ i++ ] ) ) { curValue = getClass( elem ); // This expression is here for better compressibility (see addClass) cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); if ( cur ) { j = 0; while ( ( clazz = classes[ j++ ] ) ) { // Remove *all* instances while ( cur.indexOf( " " + clazz + " " ) > -1 ) { cur = cur.replace( " " + clazz + " ", " " ); } } // Only assign if different to avoid unneeded rendering. finalValue = stripAndCollapse( cur ); if ( curValue !== finalValue ) { elem.setAttribute( "class", finalValue ); } } } } return this; }, toggleClass: function( value, stateVal ) { var type = typeof value, isValidValue = type === "string" || Array.isArray( value ); if ( typeof stateVal === "boolean" && isValidValue ) { return stateVal ? this.addClass( value ) : this.removeClass( value ); } if ( isFunction( value ) ) { return this.each( function( i ) { jQuery( this ).toggleClass( value.call( this, i, getClass( this ), stateVal ), stateVal ); } ); } return this.each( function() { var className, i, self, classNames; if ( isValidValue ) { // Toggle individual class names i = 0; self = jQuery( this ); classNames = classesToArray( value ); while ( ( className = classNames[ i++ ] ) ) { // Check each className given, space separated list if ( self.hasClass( className ) ) { self.removeClass( className ); } else { self.addClass( className ); } } // Toggle whole class name } else if ( value === undefined || type === "boolean" ) { className = getClass( this ); if ( className ) { // Store className if set dataPriv.set( this, "__className__", className ); } // If the element has a class name or if we're passed `false`, // then remove the whole classname (if there was one, the above saved it). // Otherwise bring back whatever was previously saved (if anything), // falling back to the empty string if nothing was stored. if ( this.setAttribute ) { this.setAttribute( "class", className || value === false ? "" : dataPriv.get( this, "__className__" ) || "" ); } } } ); }, hasClass: function( selector ) { var className, elem, i = 0; className = " " + selector + " "; while ( ( elem = this[ i++ ] ) ) { if ( elem.nodeType === 1 && ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { return true; } } return false; } } ); var rreturn = /\r/g; jQuery.fn.extend( { val: function( value ) { var hooks, ret, valueIsFunction, elem = this[ 0 ]; if ( !arguments.length ) { if ( elem ) { hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ]; if ( hooks && "get" in hooks && ( ret = hooks.get( elem, "value" ) ) !== undefined ) { return ret; } ret = elem.value; // Handle most common string cases if ( typeof ret === "string" ) { return ret.replace( rreturn, "" ); } // Handle cases where value is null/undef or number return ret == null ? "" : ret; } return; } valueIsFunction = isFunction( value ); return this.each( function( i ) { var val; if ( this.nodeType !== 1 ) { return; } if ( valueIsFunction ) { val = value.call( this, i, jQuery( this ).val() ); } else { val = value; } // Treat null/undefined as ""; convert numbers to string if ( val == null ) { val = ""; } else if ( typeof val === "number" ) { val += ""; } else if ( Array.isArray( val ) ) { val = jQuery.map( val, function( value ) { return value == null ? "" : value + ""; } ); } hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; // If set returns undefined, fall back to normal setting if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { this.value = val; } } ); } } ); jQuery.extend( { valHooks: { option: { get: function( elem ) { var val = jQuery.find.attr( elem, "value" ); return val != null ? val : // Support: IE <=10 - 11 only // option.text throws exceptions (#14686, #14858) // Strip and collapse whitespace // https://html.spec.whatwg.org/#strip-and-collapse-whitespace stripAndCollapse( jQuery.text( elem ) ); } }, select: { get: function( elem ) { var value, option, i, options = elem.options, index = elem.selectedIndex, one = elem.type === "select-one", values = one ? null : [], max = one ? index + 1 : options.length; if ( index < 0 ) { i = max; } else { i = one ? index : 0; } // Loop through all the selected options for ( ; i < max; i++ ) { option = options[ i ]; // Support: IE <=9 only // IE8-9 doesn't update selected after form reset (#2551) if ( ( option.selected || i === index ) && // Don't return options that are disabled or in a disabled optgroup !option.disabled && ( !option.parentNode.disabled || !nodeName( option.parentNode, "optgroup" ) ) ) { // Get the specific value for the option value = jQuery( option ).val(); // We don't need an array for one selects if ( one ) { return value; } // Multi-Selects return an array values.push( value ); } } return values; }, set: function( elem, value ) { var optionSet, option, options = elem.options, values = jQuery.makeArray( value ), i = options.length; while ( i-- ) { option = options[ i ]; /* eslint-disable no-cond-assign */ if ( option.selected = jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) { optionSet = true; } /* eslint-enable no-cond-assign */ } // Force browsers to behave consistently when non-matching value is set if ( !optionSet ) { elem.selectedIndex = -1; } return values; } } } } ); // Radios and checkboxes getter/setter jQuery.each( [ "radio", "checkbox" ], function() { jQuery.valHooks[ this ] = { set: function( elem, value ) { if ( Array.isArray( value ) ) { return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); } } }; if ( !support.checkOn ) { jQuery.valHooks[ this ].get = function( elem ) { return elem.getAttribute( "value" ) === null ? "on" : elem.value; }; } } ); // Return jQuery for attributes-only inclusion support.focusin = "onfocusin" in window; var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, stopPropagationCallback = function( e ) { e.stopPropagation(); }; jQuery.extend( jQuery.event, { trigger: function( event, data, elem, onlyHandlers ) { var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, eventPath = [ elem || document ], type = hasOwn.call( event, "type" ) ? event.type : event, namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; cur = lastElement = tmp = elem = elem || document; // Don't do events on text and comment nodes if ( elem.nodeType === 3 || elem.nodeType === 8 ) { return; } // focus/blur morphs to focusin/out; ensure we're not firing them right now if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { return; } if ( type.indexOf( "." ) > -1 ) { // Namespaced trigger; create a regexp to match event type in handle() namespaces = type.split( "." ); type = namespaces.shift(); namespaces.sort(); } ontype = type.indexOf( ":" ) < 0 && "on" + type; // Caller can pass in a jQuery.Event object, Object, or just an event type string event = event[ jQuery.expando ] ? event : new jQuery.Event( type, typeof event === "object" && event ); // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) event.isTrigger = onlyHandlers ? 2 : 3; event.namespace = namespaces.join( "." ); event.rnamespace = event.namespace ? new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : null; // Clean up the event in case it is being reused event.result = undefined; if ( !event.target ) { event.target = elem; } // Clone any incoming data and prepend the event, creating the handler arg list data = data == null ? [ event ] : jQuery.makeArray( data, [ event ] ); // Allow special events to draw outside the lines special = jQuery.event.special[ type ] || {}; if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { return; } // Determine event propagation path in advance, per W3C events spec (#9951) // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { bubbleType = special.delegateType || type; if ( !rfocusMorph.test( bubbleType + type ) ) { cur = cur.parentNode; } for ( ; cur; cur = cur.parentNode ) { eventPath.push( cur ); tmp = cur; } // Only add window if we got to document (e.g., not plain obj or detached DOM) if ( tmp === ( elem.ownerDocument || document ) ) { eventPath.push( tmp.defaultView || tmp.parentWindow || window ); } } // Fire handlers on the event path i = 0; while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { lastElement = cur; event.type = i > 1 ? bubbleType : special.bindType || type; // jQuery handler handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] && dataPriv.get( cur, "handle" ); if ( handle ) { handle.apply( cur, data ); } // Native handler handle = ontype && cur[ ontype ]; if ( handle && handle.apply && acceptData( cur ) ) { event.result = handle.apply( cur, data ); if ( event.result === false ) { event.preventDefault(); } } } event.type = type; // If nobody prevented the default action, do it now if ( !onlyHandlers && !event.isDefaultPrevented() ) { if ( ( !special._default || special._default.apply( eventPath.pop(), data ) === false ) && acceptData( elem ) ) { // Call a native DOM method on the target with the same name as the event. // Don't do default actions on window, that's where global variables be (#6170) if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { // Don't re-trigger an onFOO event when we call its FOO() method tmp = elem[ ontype ]; if ( tmp ) { elem[ ontype ] = null; } // Prevent re-triggering of the same event, since we already bubbled it above jQuery.event.triggered = type; if ( event.isPropagationStopped() ) { lastElement.addEventListener( type, stopPropagationCallback ); } elem[ type ](); if ( event.isPropagationStopped() ) { lastElement.removeEventListener( type, stopPropagationCallback ); } jQuery.event.triggered = undefined; if ( tmp ) { elem[ ontype ] = tmp; } } } } return event.result; }, // Piggyback on a donor event to simulate a different one // Used only for `focus(in | out)` events simulate: function( type, elem, event ) { var e = jQuery.extend( new jQuery.Event(), event, { type: type, isSimulated: true } ); jQuery.event.trigger( e, null, elem ); } } ); jQuery.fn.extend( { trigger: function( type, data ) { return this.each( function() { jQuery.event.trigger( type, data, this ); } ); }, triggerHandler: function( type, data ) { var elem = this[ 0 ]; if ( elem ) { return jQuery.event.trigger( type, data, elem, true ); } } } ); // Support: Firefox <=44 // Firefox doesn't have focus(in | out) events // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 // // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 // focus(in | out) events fire after focus & blur events, // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 if ( !support.focusin ) { jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) { // Attach a single capturing handler on the document while someone wants focusin/focusout var handler = function( event ) { jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) ); }; jQuery.event.special[ fix ] = { setup: function() { var doc = this.ownerDocument || this, attaches = dataPriv.access( doc, fix ); if ( !attaches ) { doc.addEventListener( orig, handler, true ); } dataPriv.access( doc, fix, ( attaches || 0 ) + 1 ); }, teardown: function() { var doc = this.ownerDocument || this, attaches = dataPriv.access( doc, fix ) - 1; if ( !attaches ) { doc.removeEventListener( orig, handler, true ); dataPriv.remove( doc, fix ); } else { dataPriv.access( doc, fix, attaches ); } } }; } ); } var location = window.location; var nonce = Date.now(); var rquery = ( /\?/ ); // Cross-browser xml parsing jQuery.parseXML = function( data ) { var xml; if ( !data || typeof data !== "string" ) { return null; } // Support: IE 9 - 11 only // IE throws on parseFromString with invalid input. try { xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); } catch ( e ) { xml = undefined; } if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) { jQuery.error( "Invalid XML: " + data ); } return xml; }; var rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i; function buildParams( prefix, obj, traditional, add ) { var name; if ( Array.isArray( obj ) ) { // Serialize array item. jQuery.each( obj, function( i, v ) { if ( traditional || rbracket.test( prefix ) ) { // Treat each array item as a scalar. add( prefix, v ); } else { // Item is non-scalar (array or object), encode its numeric index. buildParams( prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", v, traditional, add ); } } ); } else if ( !traditional && toType( obj ) === "object" ) { // Serialize object item. for ( name in obj ) { buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); } } else { // Serialize scalar item. add( prefix, obj ); } } // Serialize an array of form elements or a set of // key/values into a query string jQuery.param = function( a, traditional ) { var prefix, s = [], add = function( key, valueOrFunction ) { // If value is a function, invoke it and use its return value var value = isFunction( valueOrFunction ) ? valueOrFunction() : valueOrFunction; s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value == null ? "" : value ); }; // If an array was passed in, assume that it is an array of form elements. if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { // Serialize the form elements jQuery.each( a, function() { add( this.name, this.value ); } ); } else { // If traditional, encode the "old" way (the way 1.3.2 or older // did it), otherwise encode params recursively. for ( prefix in a ) { buildParams( prefix, a[ prefix ], traditional, add ); } } // Return the resulting serialization return s.join( "&" ); }; jQuery.fn.extend( { serialize: function() { return jQuery.param( this.serializeArray() ); }, serializeArray: function() { return this.map( function() { // Can add propHook for "elements" to filter or add form elements var elements = jQuery.prop( this, "elements" ); return elements ? jQuery.makeArray( elements ) : this; } ) .filter( function() { var type = this.type; // Use .is( ":disabled" ) so that fieldset[disabled] works return this.name && !jQuery( this ).is( ":disabled" ) && rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && ( this.checked || !rcheckableType.test( type ) ); } ) .map( function( i, elem ) { var val = jQuery( this ).val(); if ( val == null ) { return null; } if ( Array.isArray( val ) ) { return jQuery.map( val, function( val ) { return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ); } return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; } ).get(); } } ); var r20 = /%20/g, rhash = /#.*$/, rantiCache = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, // #7653, #8125, #8152: local protocol detection rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//, /* Prefilters * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) * 2) These are called: * - BEFORE asking for a transport * - AFTER param serialization (s.data is a string if s.processData is true) * 3) key is the dataType * 4) the catchall symbol "*" can be used * 5) execution will start with transport dataType and THEN continue down to "*" if needed */ prefilters = {}, /* Transports bindings * 1) key is the dataType * 2) the catchall symbol "*" can be used * 3) selection will start with transport dataType and THEN go to "*" if needed */ transports = {}, // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression allTypes = "*/".concat( "*" ), // Anchor tag for parsing the document origin originAnchor = document.createElement( "a" ); originAnchor.href = location.href; // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport function addToPrefiltersOrTransports( structure ) { // dataTypeExpression is optional and defaults to "*" return function( dataTypeExpression, func ) { if ( typeof dataTypeExpression !== "string" ) { func = dataTypeExpression; dataTypeExpression = "*"; } var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; if ( isFunction( func ) ) { // For each dataType in the dataTypeExpression while ( ( dataType = dataTypes[ i++ ] ) ) { // Prepend if requested if ( dataType[ 0 ] === "+" ) { dataType = dataType.slice( 1 ) || "*"; ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); // Otherwise append } else { ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); } } } }; } // Base inspection function for prefilters and transports function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { var inspected = {}, seekingTransport = ( structure === transports ); function inspect( dataType ) { var selected; inspected[ dataType ] = true; jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) { options.dataTypes.unshift( dataTypeOrTransport ); inspect( dataTypeOrTransport ); return false; } else if ( seekingTransport ) { return !( selected = dataTypeOrTransport ); } } ); return selected; } return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); } // A special extend for ajax options // that takes "flat" options (not to be deep extended) // Fixes #9887 function ajaxExtend( target, src ) { var key, deep, flatOptions = jQuery.ajaxSettings.flatOptions || {}; for ( key in src ) { if ( src[ key ] !== undefined ) { ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; } } if ( deep ) { jQuery.extend( true, target, deep ); } return target; } /* Handles responses to an ajax request: * - finds the right dataType (mediates between content-type and expected dataType) * - returns the corresponding response */ function ajaxHandleResponses( s, jqXHR, responses ) { var ct, type, finalDataType, firstDataType, contents = s.contents, dataTypes = s.dataTypes; // Remove auto dataType and get content-type in the process while ( dataTypes[ 0 ] === "*" ) { dataTypes.shift(); if ( ct === undefined ) { ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); } } // Check if we're dealing with a known content-type if ( ct ) { for ( type in contents ) { if ( contents[ type ] && contents[ type ].test( ct ) ) { dataTypes.unshift( type ); break; } } } // Check to see if we have a response for the expected dataType if ( dataTypes[ 0 ] in responses ) { finalDataType = dataTypes[ 0 ]; } else { // Try convertible dataTypes for ( type in responses ) { if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { finalDataType = type; break; } if ( !firstDataType ) { firstDataType = type; } } // Or just use first one finalDataType = finalDataType || firstDataType; } // If we found a dataType // We add the dataType to the list if needed // and return the corresponding response if ( finalDataType ) { if ( finalDataType !== dataTypes[ 0 ] ) { dataTypes.unshift( finalDataType ); } return responses[ finalDataType ]; } } /* Chain conversions given the request and the original response * Also sets the responseXXX fields on the jqXHR instance */ function ajaxConvert( s, response, jqXHR, isSuccess ) { var conv2, current, conv, tmp, prev, converters = {}, // Work with a copy of dataTypes in case we need to modify it for conversion dataTypes = s.dataTypes.slice(); // Create converters map with lowercased keys if ( dataTypes[ 1 ] ) { for ( conv in s.converters ) { converters[ conv.toLowerCase() ] = s.converters[ conv ]; } } current = dataTypes.shift(); // Convert to each sequential dataType while ( current ) { if ( s.responseFields[ current ] ) { jqXHR[ s.responseFields[ current ] ] = response; } // Apply the dataFilter if provided if ( !prev && isSuccess && s.dataFilter ) { response = s.dataFilter( response, s.dataType ); } prev = current; current = dataTypes.shift(); if ( current ) { // There's only work to do if current dataType is non-auto if ( current === "*" ) { current = prev; // Convert response if prev dataType is non-auto and differs from current } else if ( prev !== "*" && prev !== current ) { // Seek a direct converter conv = converters[ prev + " " + current ] || converters[ "* " + current ]; // If none found, seek a pair if ( !conv ) { for ( conv2 in converters ) { // If conv2 outputs current tmp = conv2.split( " " ); if ( tmp[ 1 ] === current ) { // If prev can be converted to accepted input conv = converters[ prev + " " + tmp[ 0 ] ] || converters[ "* " + tmp[ 0 ] ]; if ( conv ) { // Condense equivalence converters if ( conv === true ) { conv = converters[ conv2 ]; // Otherwise, insert the intermediate dataType } else if ( converters[ conv2 ] !== true ) { current = tmp[ 0 ]; dataTypes.unshift( tmp[ 1 ] ); } break; } } } } // Apply converter (if not an equivalence) if ( conv !== true ) { // Unless errors are allowed to bubble, catch and return them if ( conv && s.throws ) { response = conv( response ); } else { try { response = conv( response ); } catch ( e ) { return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current }; } } } } } } return { state: "success", data: response }; } jQuery.extend( { // Counter for holding the number of active queries active: 0, // Last-Modified header cache for next request lastModified: {}, etag: {}, ajaxSettings: { url: location.href, type: "GET", isLocal: rlocalProtocol.test( location.protocol ), global: true, processData: true, async: true, contentType: "application/x-www-form-urlencoded; charset=UTF-8", /* timeout: 0, data: null, dataType: null, username: null, password: null, cache: null, throws: false, traditional: false, headers: {}, */ accepts: { "*": allTypes, text: "text/plain", html: "text/html", xml: "application/xml, text/xml", json: "application/json, text/javascript" }, contents: { xml: /\bxml\b/, html: /\bhtml/, json: /\bjson\b/ }, responseFields: { xml: "responseXML", text: "responseText", json: "responseJSON" }, // Data converters // Keys separate source (or catchall "*") and destination types with a single space converters: { // Convert anything to text "* text": String, // Text to html (true = no transformation) "text html": true, // Evaluate text as a json expression "text json": JSON.parse, // Parse text as xml "text xml": jQuery.parseXML }, // For options that shouldn't be deep extended: // you can add your own custom options here if // and when you create one that shouldn't be // deep extended (see ajaxExtend) flatOptions: { url: true, context: true } }, // Creates a full fledged settings object into target // with both ajaxSettings and settings fields. // If target is omitted, writes into ajaxSettings. ajaxSetup: function( target, settings ) { return settings ? // Building a settings object ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : // Extending ajaxSettings ajaxExtend( jQuery.ajaxSettings, target ); }, ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), ajaxTransport: addToPrefiltersOrTransports( transports ), // Main method ajax: function( url, options ) { // If url is an object, simulate pre-1.5 signature if ( typeof url === "object" ) { options = url; url = undefined; } // Force options to be an object options = options || {}; var transport, // URL without anti-cache param cacheURL, // Response headers responseHeadersString, responseHeaders, // timeout handle timeoutTimer, // Url cleanup var urlAnchor, // Request state (becomes false upon send and true upon completion) completed, // To know if global events are to be dispatched fireGlobals, // Loop variable i, // uncached part of the url uncached, // Create the final options object s = jQuery.ajaxSetup( {}, options ), // Callbacks context callbackContext = s.context || s, // Context for global events is callbackContext if it is a DOM node or jQuery collection globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ? jQuery( callbackContext ) : jQuery.event, // Deferreds deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks( "once memory" ), // Status-dependent callbacks statusCode = s.statusCode || {}, // Headers (they are sent all at once) requestHeaders = {}, requestHeadersNames = {}, // Default abort message strAbort = "canceled", // Fake xhr jqXHR = { readyState: 0, // Builds headers hashtable if needed getResponseHeader: function( key ) { var match; if ( completed ) { if ( !responseHeaders ) { responseHeaders = {}; while ( ( match = rheaders.exec( responseHeadersString ) ) ) { responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ]; } } match = responseHeaders[ key.toLowerCase() ]; } return match == null ? null : match; }, // Raw string getAllResponseHeaders: function() { return completed ? responseHeadersString : null; }, // Caches the header setRequestHeader: function( name, value ) { if ( completed == null ) { name = requestHeadersNames[ name.toLowerCase() ] = requestHeadersNames[ name.toLowerCase() ] || name; requestHeaders[ name ] = value; } return this; }, // Overrides response content-type header overrideMimeType: function( type ) { if ( completed == null ) { s.mimeType = type; } return this; }, // Status-dependent callbacks statusCode: function( map ) { var code; if ( map ) { if ( completed ) { // Execute the appropriate callbacks jqXHR.always( map[ jqXHR.status ] ); } else { // Lazy-add the new callbacks in a way that preserves old ones for ( code in map ) { statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; } } } return this; }, // Cancel the request abort: function( statusText ) { var finalText = statusText || strAbort; if ( transport ) { transport.abort( finalText ); } done( 0, finalText ); return this; } }; // Attach deferreds deferred.promise( jqXHR ); // Add protocol if not provided (prefilters might expect it) // Handle falsy url in the settings object (#10093: consistency with old signature) // We also use the url parameter if available s.url = ( ( url || s.url || location.href ) + "" ) .replace( rprotocol, location.protocol + "//" ); // Alias method option to type as per ticket #12004 s.type = options.method || options.type || s.method || s.type; // Extract dataTypes list s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; // A cross-domain request is in order when the origin doesn't match the current origin. if ( s.crossDomain == null ) { urlAnchor = document.createElement( "a" ); // Support: IE <=8 - 11, Edge 12 - 15 // IE throws exception on accessing the href property if url is malformed, // e.g. http://example.com:80x/ try { urlAnchor.href = s.url; // Support: IE <=8 - 11 only // Anchor's host property isn't correctly set when s.url is relative urlAnchor.href = urlAnchor.href; s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host; } catch ( e ) { // If there is an error parsing the URL, assume it is crossDomain, // it can be rejected by the transport if it is invalid s.crossDomain = true; } } // Convert data if not already a string if ( s.data && s.processData && typeof s.data !== "string" ) { s.data = jQuery.param( s.data, s.traditional ); } // Apply prefilters inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); // If request was aborted inside a prefilter, stop there if ( completed ) { return jqXHR; } // We can fire global events as of now if asked to // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) fireGlobals = jQuery.event && s.global; // Watch for a new set of requests if ( fireGlobals && jQuery.active++ === 0 ) { jQuery.event.trigger( "ajaxStart" ); } // Uppercase the type s.type = s.type.toUpperCase(); // Determine if request has content s.hasContent = !rnoContent.test( s.type ); // Save the URL in case we're toying with the If-Modified-Since // and/or If-None-Match header later on // Remove hash to simplify url manipulation cacheURL = s.url.replace( rhash, "" ); // More options handling for requests with no content if ( !s.hasContent ) { // Remember the hash so we can put it back uncached = s.url.slice( cacheURL.length ); // If data is available and should be processed, append data to url if ( s.data && ( s.processData || typeof s.data === "string" ) ) { cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; // #9682: remove data so that it's not used in an eventual retry delete s.data; } // Add or update anti-cache param if needed if ( s.cache === false ) { cacheURL = cacheURL.replace( rantiCache, "$1" ); uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached; } // Put hash and anti-cache on the URL that will be requested (gh-1732) s.url = cacheURL + uncached; // Change '%20' to '+' if this is encoded form body content (gh-2658) } else if ( s.data && s.processData && ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { s.data = s.data.replace( r20, "+" ); } // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { if ( jQuery.lastModified[ cacheURL ] ) { jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); } if ( jQuery.etag[ cacheURL ] ) { jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); } } // Set the correct header, if data is being sent if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { jqXHR.setRequestHeader( "Content-Type", s.contentType ); } // Set the Accepts header for the server, depending on the dataType jqXHR.setRequestHeader( "Accept", s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? s.accepts[ s.dataTypes[ 0 ] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : s.accepts[ "*" ] ); // Check for headers option for ( i in s.headers ) { jqXHR.setRequestHeader( i, s.headers[ i ] ); } // Allow custom headers/mimetypes and early abort if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { // Abort if not done already and return return jqXHR.abort(); } // Aborting is no longer a cancellation strAbort = "abort"; // Install callbacks on deferreds completeDeferred.add( s.complete ); jqXHR.done( s.success ); jqXHR.fail( s.error ); // Get transport transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); // If no transport, we auto-abort if ( !transport ) { done( -1, "No Transport" ); } else { jqXHR.readyState = 1; // Send global event if ( fireGlobals ) { globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); } // If request was aborted inside ajaxSend, stop there if ( completed ) { return jqXHR; } // Timeout if ( s.async && s.timeout > 0 ) { timeoutTimer = window.setTimeout( function() { jqXHR.abort( "timeout" ); }, s.timeout ); } try { completed = false; transport.send( requestHeaders, done ); } catch ( e ) { // Rethrow post-completion exceptions if ( completed ) { throw e; } // Propagate others as results done( -1, e ); } } // Callback for when everything is done function done( status, nativeStatusText, responses, headers ) { var isSuccess, success, error, response, modified, statusText = nativeStatusText; // Ignore repeat invocations if ( completed ) { return; } completed = true; // Clear timeout if it exists if ( timeoutTimer ) { window.clearTimeout( timeoutTimer ); } // Dereference transport for early garbage collection // (no matter how long the jqXHR object will be used) transport = undefined; // Cache response headers responseHeadersString = headers || ""; // Set readyState jqXHR.readyState = status > 0 ? 4 : 0; // Determine if successful isSuccess = status >= 200 && status < 300 || status === 304; // Get response data if ( responses ) { response = ajaxHandleResponses( s, jqXHR, responses ); } // Convert no matter what (that way responseXXX fields are always set) response = ajaxConvert( s, response, jqXHR, isSuccess ); // If successful, handle type chaining if ( isSuccess ) { // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. if ( s.ifModified ) { modified = jqXHR.getResponseHeader( "Last-Modified" ); if ( modified ) { jQuery.lastModified[ cacheURL ] = modified; } modified = jqXHR.getResponseHeader( "etag" ); if ( modified ) { jQuery.etag[ cacheURL ] = modified; } } // if no content if ( status === 204 || s.type === "HEAD" ) { statusText = "nocontent"; // if not modified } else if ( status === 304 ) { statusText = "notmodified"; // If we have data, let's convert it } else { statusText = response.state; success = response.data; error = response.error; isSuccess = !error; } } else { // Extract error from statusText and normalize for non-aborts error = statusText; if ( status || !statusText ) { statusText = "error"; if ( status < 0 ) { status = 0; } } } // Set data for the fake xhr object jqXHR.status = status; jqXHR.statusText = ( nativeStatusText || statusText ) + ""; // Success/Error if ( isSuccess ) { deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); } else { deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); } // Status-dependent callbacks jqXHR.statusCode( statusCode ); statusCode = undefined; if ( fireGlobals ) { globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", [ jqXHR, s, isSuccess ? success : error ] ); } // Complete completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); if ( fireGlobals ) { globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); // Handle the global AJAX counter if ( !( --jQuery.active ) ) { jQuery.event.trigger( "ajaxStop" ); } } } return jqXHR; }, getJSON: function( url, data, callback ) { return jQuery.get( url, data, callback, "json" ); }, getScript: function( url, callback ) { return jQuery.get( url, undefined, callback, "script" ); } } ); jQuery.each( [ "get", "post" ], function( i, method ) { jQuery[ method ] = function( url, data, callback, type ) { // Shift arguments if data argument was omitted if ( isFunction( data ) ) { type = type || callback; callback = data; data = undefined; } // The url can be an options object (which then must have .url) return jQuery.ajax( jQuery.extend( { url: url, type: method, dataType: type, data: data, success: callback }, jQuery.isPlainObject( url ) && url ) ); }; } ); jQuery._evalUrl = function( url ) { return jQuery.ajax( { url: url, // Make this explicit, since user can override this through ajaxSetup (#11264) type: "GET", dataType: "script", cache: true, async: false, global: false, "throws": true } ); }; jQuery.fn.extend( { wrapAll: function( html ) { var wrap; if ( this[ 0 ] ) { if ( isFunction( html ) ) { html = html.call( this[ 0 ] ); } // The elements to wrap the target around wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); if ( this[ 0 ].parentNode ) { wrap.insertBefore( this[ 0 ] ); } wrap.map( function() { var elem = this; while ( elem.firstElementChild ) { elem = elem.firstElementChild; } return elem; } ).append( this ); } return this; }, wrapInner: function( html ) { if ( isFunction( html ) ) { return this.each( function( i ) { jQuery( this ).wrapInner( html.call( this, i ) ); } ); } return this.each( function() { var self = jQuery( this ), contents = self.contents(); if ( contents.length ) { contents.wrapAll( html ); } else { self.append( html ); } } ); }, wrap: function( html ) { var htmlIsFunction = isFunction( html ); return this.each( function( i ) { jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); } ); }, unwrap: function( selector ) { this.parent( selector ).not( "body" ).each( function() { jQuery( this ).replaceWith( this.childNodes ); } ); return this; } } ); jQuery.expr.pseudos.hidden = function( elem ) { return !jQuery.expr.pseudos.visible( elem ); }; jQuery.expr.pseudos.visible = function( elem ) { return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); }; jQuery.ajaxSettings.xhr = function() { try { return new window.XMLHttpRequest(); } catch ( e ) {} }; var xhrSuccessStatus = { // File protocol always yields status code 0, assume 200 0: 200, // Support: IE <=9 only // #1450: sometimes IE returns 1223 when it should be 204 1223: 204 }, xhrSupported = jQuery.ajaxSettings.xhr(); support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); support.ajax = xhrSupported = !!xhrSupported; jQuery.ajaxTransport( function( options ) { var callback, errorCallback; // Cross domain only allowed if supported through XMLHttpRequest if ( support.cors || xhrSupported && !options.crossDomain ) { return { send: function( headers, complete ) { var i, xhr = options.xhr(); xhr.open( options.type, options.url, options.async, options.username, options.password ); // Apply custom fields if provided if ( options.xhrFields ) { for ( i in options.xhrFields ) { xhr[ i ] = options.xhrFields[ i ]; } } // Override mime type if needed if ( options.mimeType && xhr.overrideMimeType ) { xhr.overrideMimeType( options.mimeType ); } // X-Requested-With header // For cross-domain requests, seeing as conditions for a preflight are // akin to a jigsaw puzzle, we simply never set it to be sure. // (it can always be set on a per-request basis or even using ajaxSetup) // For same-domain requests, won't change header if already provided. if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { headers[ "X-Requested-With" ] = "XMLHttpRequest"; } // Set headers for ( i in headers ) { xhr.setRequestHeader( i, headers[ i ] ); } // Callback callback = function( type ) { return function() { if ( callback ) { callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.ontimeout = xhr.onreadystatechange = null; if ( type === "abort" ) { xhr.abort(); } else if ( type === "error" ) { // Support: IE <=9 only // On a manual native abort, IE9 throws // errors on any property access that is not readyState if ( typeof xhr.status !== "number" ) { complete( 0, "error" ); } else { complete( // File: protocol always yields status 0; see #8605, #14207 xhr.status, xhr.statusText ); } } else { complete( xhrSuccessStatus[ xhr.status ] || xhr.status, xhr.statusText, // Support: IE <=9 only // IE9 has no XHR2 but throws on binary (trac-11426) // For XHR2 non-text, let the caller handle it (gh-2498) ( xhr.responseType || "text" ) !== "text" || typeof xhr.responseText !== "string" ? { binary: xhr.response } : { text: xhr.responseText }, xhr.getAllResponseHeaders() ); } } }; }; // Listen to events xhr.onload = callback(); errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); // Support: IE 9 only // Use onreadystatechange to replace onabort // to handle uncaught aborts if ( xhr.onabort !== undefined ) { xhr.onabort = errorCallback; } else { xhr.onreadystatechange = function() { // Check readyState before timeout as it changes if ( xhr.readyState === 4 ) { // Allow onerror to be called first, // but that will not handle a native abort // Also, save errorCallback to a variable // as xhr.onerror cannot be accessed window.setTimeout( function() { if ( callback ) { errorCallback(); } } ); } }; } // Create the abort callback callback = callback( "abort" ); try { // Do send the request (this may raise an exception) xhr.send( options.hasContent && options.data || null ); } catch ( e ) { // #14683: Only rethrow if this hasn't been notified as an error yet if ( callback ) { throw e; } } }, abort: function() { if ( callback ) { callback(); } } }; } } ); // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) jQuery.ajaxPrefilter( function( s ) { if ( s.crossDomain ) { s.contents.script = false; } } ); // Install script dataType jQuery.ajaxSetup( { accepts: { script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript" }, contents: { script: /\b(?:java|ecma)script\b/ }, converters: { "text script": function( text ) { jQuery.globalEval( text ); return text; } } } ); // Handle cache's special case and crossDomain jQuery.ajaxPrefilter( "script", function( s ) { if ( s.cache === undefined ) { s.cache = false; } if ( s.crossDomain ) { s.type = "GET"; } } ); // Bind script tag hack transport jQuery.ajaxTransport( "script", function( s ) { // This transport only deals with cross domain requests if ( s.crossDomain ) { var script, callback; return { send: function( _, complete ) { script = jQuery( "

About

pyfuse3 is a set of Python 3 bindings for libfuse 3. It provides an asynchronous API compatible with Trio and asyncio, and enables you to easily write a full-featured Linux filesystem in Python.

pyfuse3 releases can be downloaded from PyPi. The documentation can be read online and is also included in the doc/html directory of the pyfuse3 tarball.

Getting Help

Please report any bugs on the issue tracker. For discussion and questions, please use the general FUSE mailing list. A searchable mailing list archive is kindly provided by Gmane.

Development Status

pyfuse3 is in beta. Bugs are likely.

pyfuse3 uses semantic versioning. This means backwards incompatible changes in the API will be reflected in an increase of the major version number.

Contributing

The pyfuse3 source code is available on GitHub.

pyfuse3-3.2.0/doc/html/asyncio.html0000664000175000017500000001426213773155703020662 0ustar nikrationikratio00000000000000 asyncio Support — pyfuse3 3.2.0 documentation

asyncio Support

By default, pyfuse3 uses asynchronous I/O using Trio (and most of the documentation assumes that you are using Trio). If you’d rather use asyncio, import the pyfuse3_asyncio module and call its enable() function before using pyfuse3. For example:

import pyfuse3
import pyfuse3_asyncio

pyfuse3_asyncio.enable()

# Use pyfuse3 as usual from here on.
pyfuse3-3.2.0/doc/html/changes.html0000664000175000017500000002543713773155703020633 0ustar nikrationikratio00000000000000 Changelog — pyfuse3 3.2.0 documentation

Changelog

Release 3.2.0 (2020-12-30)

  • Fix long-standing rounding error in file date handling when the nanosecond part of file dates were > 999999500.
  • There is a new pyfuse3.terminate() function to gracefully end the main loop.

Release 3.1.1 (2020-10-06)

  • No source changes. Regenerated Cython files with Cython 0.29.21 for Python 3.9 compatibility.

Release 3.1.0 (2020-05-31)

  • Made compatible with newest Trio module.

Release 3.0.0 (2020-05-08)

  • Changed create handler to return a FileInfo struct to allow for modification of certain kernel file attributes, e.g. direct_io.

    Note that this change breaks backwards compatibility, code that depends on the old behavior needs to be changed.

Release 2.0.0

  • Changed open handler to return the new FileInfo struct to allow for modification of certain kernel file attributes, e.g. direct_io.

    Note that this change breaks backwards compatibility, code that depends on the old behavior needs to be changed.

Release 1.3.1 (2019-07-17)

  • Fixed a bug in the hello_asyncio.py example.

Release 1.3 (2019-06-02)

  • Fixed a bug in the tmpfs.py and passthroughfs.py example file systems (so rename operations no longer fail).

Release 1.2 (2018-12-22)

  • Clarified that invalidate_inode may block in some circumstances.
  • Added support for using the asyncio module instead of Trio.

Release 1.1 (2018-11-02)

  • Fixed examples/passthroughfs.py - was not handling readdir() correctly.
  • invalidate_entry_async now accepts an additional ignore_enoent parameter. When this is set, no errors are logged if the kernel is not actually aware of the entry that should have been removed.

Release 1.0 (2018-10-08)

  • Added a new syncfs function.

Release 0.9 (2018-09-27)

  • First release
  • pyfuse3 was forked from python-llfuse - thanks for all the work!
  • If you need compatibility with Python 2.x or libfuse 2.x, you may want to take a look at python-llfuse instead.
pyfuse3-3.2.0/doc/html/data.html0000664000175000017500000006254013773155703020130 0ustar nikrationikratio00000000000000 Data Structures — pyfuse3 3.2.0 documentation

Data Structures

pyfuse3.ENOATTR

This errorcode is unfortunately missing in the errno module, so it is provided by pyfuse3 instead.

pyfuse3.ROOT_INODE

The inode of the root directory, i.e. the mount point of the file system.

pyfuse3.RENAME_EXCHANGE

A flag that may be passed to the rename handler. When passed, the handler must atomically exchange the two paths (which must both exist).

pyfuse3.RENAME_NOREPLACE

A flag that may be passed to the rename handler. When passed, the handler must not replace an existing target.

pyfuse3.default_options

This is a recommended set of options that should be passed to pyfuse3.init to get reasonable behavior and performance. pyfuse3 is compatible with any other combination of options as well, but you should only deviate from the defaults with good reason.

(The fsname=<foo> option is guaranteed never to be included in the default options, so you can always safely add it to the set).

The default options are:

  • default_permissions enables permission checking by kernel. Without this any umask (or uid/gid) would not have an effect.
exception pyfuse3.FUSEError

This exception may be raised by request handlers to indicate that the requested operation could not be carried out. The system call that resulted in the request (if any) will then fail with error code errno_.

class pyfuse3.RequestContext

Instances of this class are passed to some Operations methods to provide information about the caller of the syscall that initiated the request.

pid
uid
gid
umask
class pyfuse3.StatvfsData

Instances of this class store information about the file system. The attributes correspond to the elements of the statvfs struct, see statvfs(2) for details.

f_bsize
f_frsize
f_blocks
f_bfree
f_bavail
f_files
f_ffree
f_favail
f_namemax
class pyfuse3.EntryAttributes

Instances of this class store attributes of directory entries. Most of the attributes correspond to the elements of the stat C struct as returned by e.g. fstat and should be self-explanatory.

st_ino
generation

The inode generation number

entry_timeout

Validity timeout for the name/existence of the directory entry

Floating point numbers may be used. Units are seconds.

attr_timeout

Validity timeout for the attributes of the directory entry

Floating point numbers may be used. Units are seconds.

st_mode
st_uid
st_gid
st_rdev
st_size
st_blksize
st_blocks
st_atime_ns

Time of last access in (integer) nanoseconds

st_ctime_ns

Time of last inode modification in (integer) nanoseconds

st_mtime_ns

Time of last modification in (integer) nanoseconds

class pyfuse3.FileInfo

Instances of this class store options and data that Operations.open returns. The attributes correspond to the elements of the fuse_file_info struct that are relevant to the Operations.open function.

fh

fh: ‘uint64_t’

This attribute must be set to the file handle to be returned from Operations.open.

direct_io

direct_io: ‘bool’

If true, signals to the kernel that this file should not be cached or buffered.

keep_cache

keep_cache: ‘bool’

If true, signals to the kernel that previously cached data for this inode is still valid, and should not be invalidated.

nonseekable

nonseekable: ‘bool’

If true, indicates that the file does not support seeking.

class pyfuse3.SetattrFields

SetattrFields instances are passed to the setattr handler to specify which attributes should be updated.

update_atime

If this attribute is true, it signals the Operations.setattr method that the st_atime_ns field contains an updated value.

update_mtime

If this attribute is true, it signals the Operations.setattr method that the st_mtime_ns field contains an updated value.

update_mode

If this attribute is true, it signals the Operations.setattr method that the st_mode field contains an updated value.

update_uid

If this attribute is true, it signals the Operations.setattr method that the st_uid field contains an updated value.

update_gid

If this attribute is true, it signals the Operations.setattr method that the st_gid field contains an updated value.

update_size

If this attribute is true, it signals the Operations.setattr method that the st_size field contains an updated value.

pyfuse3-3.2.0/doc/html/example.html0000664000175000017500000056506213773155703020661 0ustar nikrationikratio00000000000000 Example File Systems — pyfuse3 3.2.0 documentation

Example File Systems

pyfuse3 comes with several example file systems in the examples directory of the release tarball. For completeness, these examples are also included here.

Single-file, Read-only File System

(shipped as examples/lltest.py)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
'''
hello.py - Example file system for pyfuse3.

This program presents a static file system containing a single file.

Copyright © 2015 Nikolaus Rath <Nikolaus.org>
Copyright © 2015 Gerion Entrup.

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.

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.
'''

import os
import sys

# If we are running from the pyfuse3 source directory, try
# to load the module from there first.
basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..'))
if (os.path.exists(os.path.join(basedir, 'setup.py')) and
    os.path.exists(os.path.join(basedir, 'src', 'pyfuse3.pyx'))):
    sys.path.insert(0, os.path.join(basedir, 'src'))

from argparse import ArgumentParser
import stat
import logging
import errno
import pyfuse3
import trio

try:
    import faulthandler
except ImportError:
    pass
else:
    faulthandler.enable()

log = logging.getLogger(__name__)

class TestFs(pyfuse3.Operations):
    def __init__(self):
        super(TestFs, self).__init__()
        self.hello_name = b"message"
        self.hello_inode = pyfuse3.ROOT_INODE+1
        self.hello_data = b"hello world\n"

    async def getattr(self, inode, ctx=None):
        entry = pyfuse3.EntryAttributes()
        if inode == pyfuse3.ROOT_INODE:
            entry.st_mode = (stat.S_IFDIR | 0o755)
            entry.st_size = 0
        elif inode == self.hello_inode:
            entry.st_mode = (stat.S_IFREG | 0o644)
            entry.st_size = len(self.hello_data)
        else:
            raise pyfuse3.FUSEError(errno.ENOENT)

        stamp = int(1438467123.985654 * 1e9)
        entry.st_atime_ns = stamp
        entry.st_ctime_ns = stamp
        entry.st_mtime_ns = stamp
        entry.st_gid = os.getgid()
        entry.st_uid = os.getuid()
        entry.st_ino = inode

        return entry

    async def lookup(self, parent_inode, name, ctx=None):
        if parent_inode != pyfuse3.ROOT_INODE or name != self.hello_name:
            raise pyfuse3.FUSEError(errno.ENOENT)
        return self.getattr(self.hello_inode)

    async def opendir(self, inode, ctx):
        if inode != pyfuse3.ROOT_INODE:
            raise pyfuse3.FUSEError(errno.ENOENT)
        return inode

    async def readdir(self, fh, start_id, token):
        assert fh == pyfuse3.ROOT_INODE

        # only one entry
        if start_id == 0:
            pyfuse3.readdir_reply(
                token, self.hello_name, await self.getattr(self.hello_inode), 1)
        return

    async def open(self, inode, flags, ctx):
        if inode != self.hello_inode:
            raise pyfuse3.FUSEError(errno.ENOENT)
        if flags & os.O_RDWR or flags & os.O_WRONLY:
            raise pyfuse3.FUSEError(errno.EACCES)
        return pyfuse3.FileInfo(fh=inode)

    async def read(self, fh, off, size):
        assert fh == self.hello_inode
        return self.hello_data[off:off+size]

def init_logging(debug=False):
    formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: '
                                  '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S")
    handler = logging.StreamHandler()
    handler.setFormatter(formatter)
    root_logger = logging.getLogger()
    if debug:
        handler.setLevel(logging.DEBUG)
        root_logger.setLevel(logging.DEBUG)
    else:
        handler.setLevel(logging.INFO)
        root_logger.setLevel(logging.INFO)
    root_logger.addHandler(handler)

def parse_args():
    '''Parse command line'''

    parser = ArgumentParser()

    parser.add_argument('mountpoint', type=str,
                        help='Where to mount the file system')
    parser.add_argument('--debug', action='store_true', default=False,
                        help='Enable debugging output')
    parser.add_argument('--debug-fuse', action='store_true', default=False,
                        help='Enable FUSE debugging output')
    return parser.parse_args()


def main():
    options = parse_args()
    init_logging(options.debug)

    testfs = TestFs()
    fuse_options = set(pyfuse3.default_options)
    fuse_options.add('fsname=hello')
    if options.debug_fuse:
        fuse_options.add('debug')
    pyfuse3.init(testfs, options.mountpoint, fuse_options)
    try:
        trio.run(pyfuse3.main)
    except:
        pyfuse3.close(unmount=False)
        raise

    pyfuse3.close()


if __name__ == '__main__':
    main()

In-memory File System

(shipped as examples/tmpfs.py)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
'''
tmpfs.py - Example file system for pyfuse3.

This file system stores all data in memory.

Copyright © 2013 Nikolaus Rath <Nikolaus.org>

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.

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.
'''

import os
import sys

# If we are running from the pyfuse3 source directory, try
# to load the module from there first.
basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..'))
if (os.path.exists(os.path.join(basedir, 'setup.py')) and
    os.path.exists(os.path.join(basedir, 'src', 'pyfuse3.pyx'))):
    sys.path.insert(0, os.path.join(basedir, 'src'))

import pyfuse3
import errno
import stat
from time import time
import sqlite3
import logging
from collections import defaultdict
from pyfuse3 import FUSEError
from argparse import ArgumentParser
import trio

try:
    import faulthandler
except ImportError:
    pass
else:
    faulthandler.enable()

log = logging.getLogger()

class Operations(pyfuse3.Operations):
    '''An example filesystem that stores all data in memory

    This is a very simple implementation with terrible performance.
    Don't try to store significant amounts of data. Also, there are
    some other flaws that have not been fixed to keep the code easier
    to understand:

    * atime, mtime and ctime are not updated
    * generation numbers are not supported
    * lookup counts are not maintained
    '''

    enable_writeback_cache = True

    def __init__(self):
        super(Operations, self).__init__()
        self.db = sqlite3.connect(':memory:')
        self.db.text_factory = str
        self.db.row_factory = sqlite3.Row
        self.cursor = self.db.cursor()
        self.inode_open_count = defaultdict(int)
        self.init_tables()

    def init_tables(self):
        '''Initialize file system tables'''

        self.cursor.execute("""
        CREATE TABLE inodes (
            id        INTEGER PRIMARY KEY,
            uid       INT NOT NULL,
            gid       INT NOT NULL,
            mode      INT NOT NULL,
            mtime_ns  INT NOT NULL,
            atime_ns  INT NOT NULL,
            ctime_ns  INT NOT NULL,
            target    BLOB(256) ,
            size      INT NOT NULL DEFAULT 0,
            rdev      INT NOT NULL DEFAULT 0,
            data      BLOB
        )
        """)

        self.cursor.execute("""
        CREATE TABLE contents (
            rowid     INTEGER PRIMARY KEY AUTOINCREMENT,
            name      BLOB(256) NOT NULL,
            inode     INT NOT NULL REFERENCES inodes(id),
            parent_inode INT NOT NULL REFERENCES inodes(id),

            UNIQUE (name, parent_inode)
        )""")

        # Insert root directory
        now_ns = int(time() * 1e9)
        self.cursor.execute("INSERT INTO inodes (id,mode,uid,gid,mtime_ns,atime_ns,ctime_ns) "
                            "VALUES (?,?,?,?,?,?,?)",
                            (pyfuse3.ROOT_INODE, stat.S_IFDIR | stat.S_IRUSR | stat.S_IWUSR
                              | stat.S_IXUSR | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH
                              | stat.S_IXOTH, os.getuid(), os.getgid(), now_ns, now_ns, now_ns))
        self.cursor.execute("INSERT INTO contents (name, parent_inode, inode) VALUES (?,?,?)",
                            (b'..', pyfuse3.ROOT_INODE, pyfuse3.ROOT_INODE))


    def get_row(self, *a, **kw):
        self.cursor.execute(*a, **kw)
        try:
            row = next(self.cursor)
        except StopIteration:
            raise NoSuchRowError()
        try:
            next(self.cursor)
        except StopIteration:
            pass
        else:
            raise NoUniqueValueError()

        return row

    async def lookup(self, inode_p, name, ctx=None):
        if name == '.':
            inode = inode_p
        elif name == '..':
            inode = self.get_row("SELECT * FROM contents WHERE inode=?",
                                 (inode_p,))['parent_inode']
        else:
            try:
                inode = self.get_row("SELECT * FROM contents WHERE name=? AND parent_inode=?",
                                     (name, inode_p))['inode']
            except NoSuchRowError:
                raise(pyfuse3.FUSEError(errno.ENOENT))

        return await self.getattr(inode, ctx)


    async def getattr(self, inode, ctx=None):
        row = self.get_row('SELECT * FROM inodes WHERE id=?', (inode,))

        entry = pyfuse3.EntryAttributes()
        entry.st_ino = inode
        entry.generation = 0
        entry.entry_timeout = 300
        entry.attr_timeout = 300
        entry.st_mode = row['mode']
        entry.st_nlink = self.get_row("SELECT COUNT(inode) FROM contents WHERE inode=?",
                                     (inode,))[0]
        entry.st_uid = row['uid']
        entry.st_gid = row['gid']
        entry.st_rdev = row['rdev']
        entry.st_size = row['size']

        entry.st_blksize = 512
        entry.st_blocks = 1
        entry.st_atime_ns = row['atime_ns']
        entry.st_mtime_ns = row['mtime_ns']
        entry.st_ctime_ns = row['ctime_ns']

        return entry

    async def readlink(self, inode, ctx):
        return self.get_row('SELECT * FROM inodes WHERE id=?', (inode,))['target']

    async def opendir(self, inode, ctx):
        return inode

    async def readdir(self, inode, off, token):
        if off == 0:
            off = -1

        cursor2 = self.db.cursor()
        cursor2.execute("SELECT * FROM contents WHERE parent_inode=? "
                        'AND rowid > ? ORDER BY rowid', (inode, off))

        for row in cursor2:
            pyfuse3.readdir_reply(
                token, row['name'], await self.getattr(row['inode']), row['rowid'])

    async def unlink(self, inode_p, name,ctx):
        entry = await self.lookup(inode_p, name)

        if stat.S_ISDIR(entry.st_mode):
            raise pyfuse3.FUSEError(errno.EISDIR)

        self._remove(inode_p, name, entry)

    async def rmdir(self, inode_p, name, ctx):
        entry = await self.lookup(inode_p, name)

        if not stat.S_ISDIR(entry.st_mode):
            raise pyfuse3.FUSEError(errno.ENOTDIR)

        self._remove(inode_p, name, entry)

    def _remove(self, inode_p, name, entry):
        if self.get_row("SELECT COUNT(inode) FROM contents WHERE parent_inode=?",
                        (entry.st_ino,))[0] > 0:
            raise pyfuse3.FUSEError(errno.ENOTEMPTY)

        self.cursor.execute("DELETE FROM contents WHERE name=? AND parent_inode=?",
                        (name, inode_p))

        if entry.st_nlink == 1 and entry.st_ino not in self.inode_open_count:
            self.cursor.execute("DELETE FROM inodes WHERE id=?", (entry.st_ino,))

    async def symlink(self, inode_p, name, target, ctx):
        mode = (stat.S_IFLNK | stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR |
                stat.S_IRGRP | stat.S_IWGRP | stat.S_IXGRP |
                stat.S_IROTH | stat.S_IWOTH | stat.S_IXOTH)
        return await self._create(inode_p, name, mode, ctx, target=target)

    async def rename(self, inode_p_old, name_old, inode_p_new, name_new,
                     flags, ctx):
        if flags != 0:
            raise FUSEError(errno.EINVAL)

        entry_old = await self.lookup(inode_p_old, name_old)

        try:
            entry_new = await self.lookup(inode_p_new, name_new)
        except pyfuse3.FUSEError as exc:
            if exc.errno != errno.ENOENT:
                raise
            target_exists = False
        else:
            target_exists = True

        if target_exists:
            self._replace(inode_p_old, name_old, inode_p_new, name_new,
                          entry_old, entry_new)
        else:
            self.cursor.execute("UPDATE contents SET name=?, parent_inode=? WHERE name=? "
                                "AND parent_inode=?", (name_new, inode_p_new,
                                                       name_old, inode_p_old))

    def _replace(self, inode_p_old, name_old, inode_p_new, name_new,
                 entry_old, entry_new):

        if self.get_row("SELECT COUNT(inode) FROM contents WHERE parent_inode=?",
                        (entry_new.st_ino,))[0] > 0:
            raise pyfuse3.FUSEError(errno.ENOTEMPTY)

        self.cursor.execute("UPDATE contents SET inode=? WHERE name=? AND parent_inode=?",
                            (entry_old.st_ino, name_new, inode_p_new))
        self.db.execute('DELETE FROM contents WHERE name=? AND parent_inode=?',
                        (name_old, inode_p_old))

        if entry_new.st_nlink == 1 and entry_new.st_ino not in self.inode_open_count:
            self.cursor.execute("DELETE FROM inodes WHERE id=?", (entry_new.st_ino,))


    async def link(self, inode, new_inode_p, new_name, ctx):
        entry_p = await self.getattr(new_inode_p)
        if entry_p.st_nlink == 0:
            log.warn('Attempted to create entry %s with unlinked parent %d',
                     new_name, new_inode_p)
            raise FUSEError(errno.EINVAL)

        self.cursor.execute("INSERT INTO contents (name, inode, parent_inode) VALUES(?,?,?)",
                            (new_name, inode, new_inode_p))

        return await self.getattr(inode)

    async def setattr(self, inode, attr, fields, fh, ctx):

        if fields.update_size:
            data = self.get_row('SELECT data FROM inodes WHERE id=?', (inode,))[0]
            if data is None:
                data = b''
            if len(data) < attr.st_size:
                data = data + b'\0' * (attr.st_size - len(data))
            else:
                data = data[:attr.st_size]
            self.cursor.execute('UPDATE inodes SET data=?, size=? WHERE id=?',
                                (memoryview(data), attr.st_size, inode))
        if fields.update_mode:
            self.cursor.execute('UPDATE inodes SET mode=? WHERE id=?',
                                (attr.st_mode, inode))

        if fields.update_uid:
            self.cursor.execute('UPDATE inodes SET uid=? WHERE id=?',
                                (attr.st_uid, inode))

        if fields.update_gid:
            self.cursor.execute('UPDATE inodes SET gid=? WHERE id=?',
                                (attr.st_gid, inode))

        if fields.update_atime:
            self.cursor.execute('UPDATE inodes SET atime_ns=? WHERE id=?',
                                (attr.st_atime_ns, inode))

        if fields.update_mtime:
            self.cursor.execute('UPDATE inodes SET mtime_ns=? WHERE id=?',
                                (attr.st_mtime_ns, inode))

        if fields.update_ctime:
            self.cursor.execute('UPDATE inodes SET ctime_ns=? WHERE id=?',
                                (attr.st_ctime_ns, inode))
        else:
            self.cursor.execute('UPDATE inodes SET ctime_ns=? WHERE id=?',
                                (int(time()*1e9), inode))

        return await self.getattr(inode)

    async def mknod(self, inode_p, name, mode, rdev, ctx):
        return await self._create(inode_p, name, mode, ctx, rdev=rdev)

    async def mkdir(self, inode_p, name, mode, ctx):
        return await self._create(inode_p, name, mode, ctx)

    async def statfs(self, ctx):
        stat_ = pyfuse3.StatvfsData()

        stat_.f_bsize = 512
        stat_.f_frsize = 512

        size = self.get_row('SELECT SUM(size) FROM inodes')[0]
        stat_.f_blocks = size // stat_.f_frsize
        stat_.f_bfree = max(size // stat_.f_frsize, 1024)
        stat_.f_bavail = stat_.f_bfree

        inodes = self.get_row('SELECT COUNT(id) FROM inodes')[0]
        stat_.f_files = inodes
        stat_.f_ffree = max(inodes , 100)
        stat_.f_favail = stat_.f_ffree

        return stat_

    async def open(self, inode, flags, ctx):
        # Yeah, unused arguments
        #pylint: disable=W0613
        self.inode_open_count[inode] += 1

        # Use inodes as a file handles
        return pyfuse3.FileInfo(fh=inode)

    async def access(self, inode, mode, ctx):
        # Yeah, could be a function and has unused arguments
        #pylint: disable=R0201,W0613
        return True

    async def create(self, inode_parent, name, mode, flags, ctx):
        #pylint: disable=W0612
        entry = await self._create(inode_parent, name, mode, ctx)
        self.inode_open_count[entry.st_ino] += 1
        return (pyfuse3.FileInfo(fh=entry.st_ino), entry)

    async def _create(self, inode_p, name, mode, ctx, rdev=0, target=None):
        if (await self.getattr(inode_p)).st_nlink == 0:
            log.warn('Attempted to create entry %s with unlinked parent %d',
                     name, inode_p)
            raise FUSEError(errno.EINVAL)

        now_ns = int(time() * 1e9)
        self.cursor.execute('INSERT INTO inodes (uid, gid, mode, mtime_ns, atime_ns, '
                            'ctime_ns, target, rdev) VALUES(?, ?, ?, ?, ?, ?, ?, ?)',
                            (ctx.uid, ctx.gid, mode, now_ns, now_ns, now_ns, target, rdev))

        inode = self.cursor.lastrowid
        self.db.execute("INSERT INTO contents(name, inode, parent_inode) VALUES(?,?,?)",
                        (name, inode, inode_p))
        return await self.getattr(inode)

    async def read(self, fh, offset, length):
        data = self.get_row('SELECT data FROM inodes WHERE id=?', (fh,))[0]
        if data is None:
            data = b''
        return data[offset:offset+length]

    async def write(self, fh, offset, buf):
        data = self.get_row('SELECT data FROM inodes WHERE id=?', (fh,))[0]
        if data is None:
            data = b''
        data = data[:offset] + buf + data[offset+len(buf):]

        self.cursor.execute('UPDATE inodes SET data=?, size=? WHERE id=?',
                            (memoryview(data), len(data), fh))
        return len(buf)

    async def release(self, fh):
        self.inode_open_count[fh] -= 1

        if self.inode_open_count[fh] == 0:
            del self.inode_open_count[fh]
            if (await self.getattr(fh)).st_nlink == 0:
                self.cursor.execute("DELETE FROM inodes WHERE id=?", (fh,))

class NoUniqueValueError(Exception):
    def __str__(self):
        return 'Query generated more than 1 result row'


class NoSuchRowError(Exception):
    def __str__(self):
        return 'Query produced 0 result rows'

def init_logging(debug=False):
    formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: '
                                  '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S")
    handler = logging.StreamHandler()
    handler.setFormatter(formatter)
    root_logger = logging.getLogger()
    if debug:
        handler.setLevel(logging.DEBUG)
        root_logger.setLevel(logging.DEBUG)
    else:
        handler.setLevel(logging.INFO)
        root_logger.setLevel(logging.INFO)
    root_logger.addHandler(handler)

def parse_args():
    '''Parse command line'''

    parser = ArgumentParser()

    parser.add_argument('mountpoint', type=str,
                        help='Where to mount the file system')
    parser.add_argument('--debug', action='store_true', default=False,
                        help='Enable debugging output')
    parser.add_argument('--debug-fuse', action='store_true', default=False,
                        help='Enable FUSE debugging output')

    return parser.parse_args()

if __name__ == '__main__':

    options = parse_args()
    init_logging(options.debug)
    operations = Operations()

    fuse_options = set(pyfuse3.default_options)
    fuse_options.add('fsname=tmpfs')
    fuse_options.discard('default_permissions')
    if options.debug_fuse:
        fuse_options.add('debug')
    pyfuse3.init(operations, options.mountpoint, fuse_options)

    try:
        trio.run(pyfuse3.main)
    except:
        pyfuse3.close(unmount=False)
        raise

    pyfuse3.close()

Passthrough / Overlay File System

(shipped as examples/passthroughfs.py)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
#!/usr/bin/env python3
'''
passthroughfs.py - Example file system for pyfuse3

This file system mirrors the contents of a specified directory tree.

Caveats:

 * Inode generation numbers are not passed through but set to zero.

 * Block size (st_blksize) and number of allocated blocks (st_blocks) are not
   passed through.

 * Performance for large directories is not good, because the directory
   is always read completely.

 * There may be a way to break-out of the directory tree.

 * The readdir implementation is not fully POSIX compliant. If a directory
   contains hardlinks and is modified during a readdir call, readdir()
   may return some of the hardlinked files twice or omit them completely.

 * If you delete or rename files in the underlying file system, the
   passthrough file system will get confused.

Copyright ©  Nikolaus Rath <Nikolaus.org>

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.

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.
'''

import os
import sys

# If we are running from the pyfuse3 source directory, try
# to load the module from there first.
basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..'))
if (os.path.exists(os.path.join(basedir, 'setup.py')) and
    os.path.exists(os.path.join(basedir, 'src', 'pyfuse3.pyx'))):
    sys.path.insert(0, os.path.join(basedir, 'src'))

import pyfuse3
from argparse import ArgumentParser
import errno
import logging
import stat as stat_m
from pyfuse3 import FUSEError
from os import fsencode, fsdecode
from collections import defaultdict
import trio

import faulthandler
faulthandler.enable()

log = logging.getLogger(__name__)

class Operations(pyfuse3.Operations):

    enable_writeback_cache = True

    def __init__(self, source):
        super().__init__()
        self._inode_path_map = { pyfuse3.ROOT_INODE: source }
        self._lookup_cnt = defaultdict(lambda : 0)
        self._fd_inode_map = dict()
        self._inode_fd_map = dict()
        self._fd_open_count = dict()

    def _inode_to_path(self, inode):
        try:
            val = self._inode_path_map[inode]
        except KeyError:
            raise FUSEError(errno.ENOENT)

        if isinstance(val, set):
            # In case of hardlinks, pick any path
            val = next(iter(val))
        return val

    def _add_path(self, inode, path):
        log.debug('_add_path for %d, %s', inode, path)
        self._lookup_cnt[inode] += 1

        # With hardlinks, one inode may map to multiple paths.
        if inode not in self._inode_path_map:
            self._inode_path_map[inode] = path
            return

        val = self._inode_path_map[inode]
        if isinstance(val, set):
            val.add(path)
        elif val != path:
            self._inode_path_map[inode] = { path, val }

    async def forget(self, inode_list):
        for (inode, nlookup) in inode_list:
            if self._lookup_cnt[inode] > nlookup:
                self._lookup_cnt[inode] -= nlookup
                continue
            log.debug('forgetting about inode %d', inode)
            assert inode not in self._inode_fd_map
            del self._lookup_cnt[inode]
            try:
                del self._inode_path_map[inode]
            except KeyError: # may have been deleted
                pass

    async def lookup(self, inode_p, name, ctx=None):
        name = fsdecode(name)
        log.debug('lookup for %s in %d', name, inode_p)
        path = os.path.join(self._inode_to_path(inode_p), name)
        attr = self._getattr(path=path)
        if name != '.' and name != '..':
            self._add_path(attr.st_ino, path)
        return attr

    async def getattr(self, inode, ctx=None):
        if inode in self._inode_fd_map:
            return self._getattr(fd=self._inode_fd_map[inode])
        else:
            return self._getattr(path=self._inode_to_path(inode))

    def _getattr(self, path=None, fd=None):
        assert fd is None or path is None
        assert not(fd is None and path is None)
        try:
            if fd is None:
                stat = os.lstat(path)
            else:
                stat = os.fstat(fd)
        except OSError as exc:
            raise FUSEError(exc.errno)

        entry = pyfuse3.EntryAttributes()
        for attr in ('st_ino', 'st_mode', 'st_nlink', 'st_uid', 'st_gid',
                     'st_rdev', 'st_size', 'st_atime_ns', 'st_mtime_ns',
                     'st_ctime_ns'):
            setattr(entry, attr, getattr(stat, attr))
        entry.generation = 0
        entry.entry_timeout = 0
        entry.attr_timeout = 0
        entry.st_blksize = 512
        entry.st_blocks = ((entry.st_size+entry.st_blksize-1) // entry.st_blksize)

        return entry

    async def readlink(self, inode, ctx):
        path = self._inode_to_path(inode)
        try:
            target = os.readlink(path)
        except OSError as exc:
            raise FUSEError(exc.errno)
        return fsencode(target)

    async def opendir(self, inode, ctx):
        return inode

    async def readdir(self, inode, off, token):
        path = self._inode_to_path(inode)
        log.debug('reading %s', path)
        entries = []
        for name in os.listdir(path):
            if name == '.' or name == '..':
                continue
            attr = self._getattr(path=os.path.join(path, name))
            entries.append((attr.st_ino, name, attr))

        log.debug('read %d entries, starting at %d', len(entries), off)

        # This is not fully posix compatible. If there are hardlinks
        # (two names with the same inode), we don't have a unique
        # offset to start in between them. Note that we cannot simply
        # count entries, because then we would skip over entries
        # (or return them more than once) if the number of directory
        # entries changes between two calls to readdir().
        for (ino, name, attr) in sorted(entries):
            if ino <= off:
                continue
            if not pyfuse3.readdir_reply(
                token, fsencode(name), attr, ino):
                break
            self._add_path(attr.st_ino, os.path.join(path, name))

    async def unlink(self, inode_p, name, ctx):
        name = fsdecode(name)
        parent = self._inode_to_path(inode_p)
        path = os.path.join(parent, name)
        try:
            inode = os.lstat(path).st_ino
            os.unlink(path)
        except OSError as exc:
            raise FUSEError(exc.errno)
        if inode in self._lookup_cnt:
            self._forget_path(inode, path)

    async def rmdir(self, inode_p, name, ctx):
        name = fsdecode(name)
        parent = self._inode_to_path(inode_p)
        path = os.path.join(parent, name)
        try:
            inode = os.lstat(path).st_ino
            os.rmdir(path)
        except OSError as exc:
            raise FUSEError(exc.errno)
        if inode in self._lookup_cnt:
            self._forget_path(inode, path)

    def _forget_path(self, inode, path):
        log.debug('forget %s for %d', path, inode)
        val = self._inode_path_map[inode]
        if isinstance(val, set):
            val.remove(path)
            if len(val) == 1:
                self._inode_path_map[inode] = next(iter(val))
        else:
            del self._inode_path_map[inode]

    async def symlink(self, inode_p, name, target, ctx):
        name = fsdecode(name)
        target = fsdecode(target)
        parent = self._inode_to_path(inode_p)
        path = os.path.join(parent, name)
        try:
            os.symlink(target, path)
            os.chown(path, ctx.uid, ctx.gid, follow_symlinks=False)
        except OSError as exc:
            raise FUSEError(exc.errno)
        stat = os.lstat(path)
        self._add_path(stat.st_ino, path)
        return await self.getattr(stat.st_ino)

    async def rename(self, inode_p_old, name_old, inode_p_new, name_new,
                     flags, ctx):
        if flags != 0:
            raise FUSEError(errno.EINVAL)

        name_old = fsdecode(name_old)
        name_new = fsdecode(name_new)
        parent_old = self._inode_to_path(inode_p_old)
        parent_new = self._inode_to_path(inode_p_new)
        path_old = os.path.join(parent_old, name_old)
        path_new = os.path.join(parent_new, name_new)
        try:
            os.rename(path_old, path_new)
            inode = os.lstat(path_new).st_ino
        except OSError as exc:
            raise FUSEError(exc.errno)
        if inode not in self._lookup_cnt:
            return

        val = self._inode_path_map[inode]
        if isinstance(val, set):
            assert len(val) > 1
            val.add(path_new)
            val.remove(path_old)
        else:
            assert val == path_old
            self._inode_path_map[inode] = path_new

    async def link(self, inode, new_inode_p, new_name, ctx):
        new_name = fsdecode(new_name)
        parent = self._inode_to_path(new_inode_p)
        path = os.path.join(parent, new_name)
        try:
            os.link(self._inode_to_path(inode), path, follow_symlinks=False)
        except OSError as exc:
            raise FUSEError(exc.errno)
        self._add_path(inode, path)
        return await self.getattr(inode)

    async def setattr(self, inode, attr, fields, fh, ctx):
        # We use the f* functions if possible so that we can handle
        # a setattr() call for an inode without associated directory
        # handle.
        if fh is None:
            path_or_fh = self._inode_to_path(inode)
            truncate = os.truncate
            chmod = os.chmod
            chown = os.chown
            stat = os.lstat
        else:
            path_or_fh = fh
            truncate = os.ftruncate
            chmod = os.fchmod
            chown = os.fchown
            stat = os.fstat

        try:
            if fields.update_size:
                truncate(path_or_fh, attr.st_size)

            if fields.update_mode:
                # Under Linux, chmod always resolves symlinks so we should
                # actually never get a setattr() request for a symbolic
                # link.
                assert not stat_m.S_ISLNK(attr.st_mode)
                chmod(path_or_fh, stat_m.S_IMODE(attr.st_mode))

            if fields.update_uid:
                chown(path_or_fh, attr.st_uid, -1, follow_symlinks=False)

            if fields.update_gid:
                chown(path_or_fh, -1, attr.st_gid, follow_symlinks=False)

            if fields.update_atime and fields.update_mtime:
                if fh is None:
                    os.utime(path_or_fh, None, follow_symlinks=False,
                             ns=(attr.st_atime_ns, attr.st_mtime_ns))
                else:
                    os.utime(path_or_fh, None,
                             ns=(attr.st_atime_ns, attr.st_mtime_ns))
            elif fields.update_atime or fields.update_mtime:
                # We can only set both values, so we first need to retrieve the
                # one that we shouldn't be changing.
                oldstat = stat(path_or_fh)
                if not fields.update_atime:
                    attr.st_atime_ns = oldstat.st_atime_ns
                else:
                    attr.st_mtime_ns = oldstat.st_mtime_ns
                if fh is None:
                    os.utime(path_or_fh, None, follow_symlinks=False,
                             ns=(attr.st_atime_ns, attr.st_mtime_ns))
                else:
                    os.utime(path_or_fh, None,
                             ns=(attr.st_atime_ns, attr.st_mtime_ns))

        except OSError as exc:
            raise FUSEError(exc.errno)

        return await self.getattr(inode)

    async def mknod(self, inode_p, name, mode, rdev, ctx):
        path = os.path.join(self._inode_to_path(inode_p), fsdecode(name))
        try:
            os.mknod(path, mode=(mode & ~ctx.umask), device=rdev)
            os.chown(path, ctx.uid, ctx.gid)
        except OSError as exc:
            raise FUSEError(exc.errno)
        attr = self._getattr(path=path)
        self._add_path(attr.st_ino, path)
        return attr

    async def mkdir(self, inode_p, name, mode, ctx):
        path = os.path.join(self._inode_to_path(inode_p), fsdecode(name))
        try:
            os.mkdir(path, mode=(mode & ~ctx.umask))
            os.chown(path, ctx.uid, ctx.gid)
        except OSError as exc:
            raise FUSEError(exc.errno)
        attr = self._getattr(path=path)
        self._add_path(attr.st_ino, path)
        return attr

    async def statfs(self, ctx):
        root = self._inode_path_map[pyfuse3.ROOT_INODE]
        stat_ = pyfuse3.StatvfsData()
        try:
            statfs = os.statvfs(root)
        except OSError as exc:
            raise FUSEError(exc.errno)
        for attr in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', 'f_bavail',
                     'f_files', 'f_ffree', 'f_favail'):
            setattr(stat_, attr, getattr(statfs, attr))
        stat_.f_namemax = statfs.f_namemax - (len(root)+1)
        return stat_

    async def open(self, inode, flags, ctx):
        if inode in self._inode_fd_map:
            fd = self._inode_fd_map[inode]
            self._fd_open_count[fd] += 1
            return pyfuse3.FileInfo(fh=fd)
        assert flags & os.O_CREAT == 0
        try:
            fd = os.open(self._inode_to_path(inode), flags)
        except OSError as exc:
            raise FUSEError(exc.errno)
        self._inode_fd_map[inode] = fd
        self._fd_inode_map[fd] = inode
        self._fd_open_count[fd] = 1
        return pyfuse3.FileInfo(fh=fd)

    async def create(self, inode_p, name, mode, flags, ctx):
        path = os.path.join(self._inode_to_path(inode_p), fsdecode(name))
        try:
            fd = os.open(path, flags | os.O_CREAT | os.O_TRUNC)
        except OSError as exc:
            raise FUSEError(exc.errno)
        attr = self._getattr(fd=fd)
        self._add_path(attr.st_ino, path)
        self._inode_fd_map[attr.st_ino] = fd
        self._fd_inode_map[fd] = attr.st_ino
        self._fd_open_count[fd] = 1
        return (pyfuse3.FileInfo(fh=fd), attr)

    async def read(self, fd, offset, length):
        os.lseek(fd, offset, os.SEEK_SET)
        return os.read(fd, length)

    async def write(self, fd, offset, buf):
        os.lseek(fd, offset, os.SEEK_SET)
        return os.write(fd, buf)

    async def release(self, fd):
        if self._fd_open_count[fd] > 1:
            self._fd_open_count[fd] -= 1
            return

        del self._fd_open_count[fd]
        inode = self._fd_inode_map[fd]
        del self._inode_fd_map[inode]
        del self._fd_inode_map[fd]
        try:
            os.close(fd)
        except OSError as exc:
            raise FUSEError(exc.errno)

def init_logging(debug=False):
    formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: '
                                  '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S")
    handler = logging.StreamHandler()
    handler.setFormatter(formatter)
    root_logger = logging.getLogger()
    if debug:
        handler.setLevel(logging.DEBUG)
        root_logger.setLevel(logging.DEBUG)
    else:
        handler.setLevel(logging.INFO)
        root_logger.setLevel(logging.INFO)
    root_logger.addHandler(handler)


def parse_args(args):
    '''Parse command line'''

    parser = ArgumentParser()

    parser.add_argument('source', type=str,
                        help='Directory tree to mirror')
    parser.add_argument('mountpoint', type=str,
                        help='Where to mount the file system')
    parser.add_argument('--debug', action='store_true', default=False,
                        help='Enable debugging output')
    parser.add_argument('--debug-fuse', action='store_true', default=False,
                        help='Enable FUSE debugging output')

    return parser.parse_args(args)

def main():
    options = parse_args(sys.argv[1:])
    init_logging(options.debug)
    operations = Operations(options.source)

    log.debug('Mounting...')
    fuse_options = set(pyfuse3.default_options)
    fuse_options.add('fsname=passthroughfs')
    if options.debug_fuse:
        fuse_options.add('debug')
    pyfuse3.init(operations, options.mountpoint, fuse_options)

    try:
        log.debug('Entering main loop..')
        trio.run(pyfuse3.main)
    except:
        pyfuse3.close(unmount=False)
        raise

    log.debug('Unmounting..')
    pyfuse3.close()

if __name__ == '__main__':
    main()
pyfuse3-3.2.0/doc/html/fuse_api.html0000664000175000017500000005743313773155703021017 0ustar nikrationikratio00000000000000 FUSE API Functions — pyfuse3 3.2.0 documentation

FUSE API Functions

pyfuse3.init(ops, mountpoint, options=default_options)

Initialize and mount FUSE file system

ops has to be an instance of the Operations class (or another class defining the same methods).

args has to be a set of strings. default_options provides some reasonable defaults. It is recommended to use these options as a basis and add or remove options as necessary. For example:

my_opts = set(pyfuse3.default_options)
my_opts.add('allow_other')
my_opts.discard('default_permissions')
pyfuse3.init(ops, mountpoint, my_opts)

Valid options are listed under struct fuse_opt fuse_mount_opts[] (in mount.c) and struct fuse_opt fuse_ll_opts[] (in fuse_lowlevel_c).

coroutine pyfuse3.main(min_tasks=1, max_tasks=99)

Run FUSE main loop

pyfuse3.terminate()

Terminate FUSE main loop.

This function gracefully terminates the FUSE main loop (resulting in the call to main() to return).

When called by a thread different from the one that runs the main loop, the call must be wrapped with trio.from_thread.run_sync. The necessary trio_token argument can (for convience) be retrieved from the trio_token module attribute.

pyfuse3.close(unmount=True)

Clean up and ensure filesystem is unmounted

If unmount is False, only clean up operations are peformed, but the file system is not explicitly unmounted.

Normally, the filesystem is unmounted by the user calling umount(8) or fusermount(1), which then terminates the FUSE main loop. However, the loop may also terminate as a result of an exception or a signal. In this case the filesystem remains mounted, but any attempt to access it will block (while the filesystem process is still running) or (after the filesystem process has terminated) return an error. If unmount is True, this function will ensure that the filesystem is properly unmounted.

Note: if the connection to the kernel is terminated via the /sys/fs/fuse/connections/ interface, this function will not unmount the filesystem even if unmount is True.

pyfuse3.invalidate_inode(fuse_ino_t inode, attr_only=False)

Invalidate cache for inode

Instructs the FUSE kernel module to forgot cached attributes and data (unless attr_only is True) for inode.

This operation may block if writeback caching is active and there is dirty data for the inode that is to be invalidated. Unfortunately there is no way to return control to the event loop until writeback is complete (leading to a deadlock if the necessary write() requests cannot be processed by the filesystem). Unless writeback caching is disabled, this function should therefore be called from a separate thread.

If the operation is not supported by the kernel, raises OSError with errno ENOSYS.

pyfuse3.invalidate_entry(fuse_ino_t inode_p, name, fuse_ino_t deleted=0)

Invalidate directory entry

Instructs the FUSE kernel module to forget about the directory entry name in the directory with inode inode_p.

If the inode passed as deleted matches the inode that is currently associated with name by the kernel, any inotify watchers of this inode are informed that the entry has been deleted.

If there is a pending filesystem operation that is related to the parent directory or directory entry, this function will block until that operation has completed. Therefore, to avoid a deadlock this function must not be called while handling a related request, nor while holding a lock that could be needed for handling such a request.

As for kernel 4.18, a “related operation” is a lookup, symlink, mknod, mkdir, unlink, rename, link or create request for the parent, and a setattr, unlink, rmdir, rename, setxattr, removexattr or readdir request for the inode itself.

For technical reasons, this function can also not return control to the main event loop but will actually block. To return control to the event loop while this function is running, call it in a separate thread using trio.run_sync_in_worker_thread. A less complicated alternative is to use the invalidate_entry_async function instead.

pyfuse3.invalidate_entry_async(inode_p, name, deleted=0, ignore_enoent=False)

Asynchronously invalidate directory entry

This function performs the same operation as invalidate_entry, but does so asynchronously in a separate thread. This avoids the deadlocks that may occur when using invalidate_entry from within a request handler, but means that the function generally returns before the kernel has actually invalidated the entry, and that no errors can be reported (they will be logged though).

The directory entries that are to be invalidated are put in an unbounded queue which is processed by a single thread. This means that if the entry at the beginning of the queue cannot be invalidated yet because a related file system operation is still in progress, none of the other entries will be processed and repeated calls to this function will result in continued growth of the queue.

If there are errors, an exception is logged using the logging module.

If ignore_enoent is True, ignore ENOENT errors (which occur if the kernel doesn’t actually have knowledge of the entry that is to be removed).

pyfuse3.notify_store(inode, offset, data)

Store data in kernel page cache

Sends data for the kernel to store it in the page cache for inode at offset. If this provides data beyond the current file size, the file is automatically extended.

If this function raises an exception, the store may still have completed partially.

If the operation is not supported by the kernel, raises OSError with errno ENOSYS.

pyfuse3.readdir_reply(ReaddirToken token, name, EntryAttributes attr, off_t next_id)

Report a directory entry in response to a readdir request.

This function should be called by the readdir handler to provide the list of directory entries. The function should be called once for each directory entry, until it returns False.

token must be the token received by the readdir handler.

name and must be the name of the directory entry and attr an
EntryAttributes instance holding its attributes.

next_id must be a 64-bit integer value that uniquely identifies the current position in the list of directory entries. It may be passed back to a later readdir call to start another listing at the right position. This value should be robust in the presence of file removals and creations, i.e. if files are created or removed after a call to readdir and readdir is called again with start_id set to any previously supplied next_id values, under no circumstances must any file be reported twice or skipped over.

pyfuse3.trio_token

Set to the value returned by trio.lowlevel.current_trio_token() while main() is running. Can be used by other threads to run code in the main loop through trio.from_thread.run.

pyfuse3-3.2.0/doc/html/general.html0000664000175000017500000003211113773155703020623 0ustar nikrationikratio00000000000000 General Information — pyfuse3 3.2.0 documentation

General Information

Getting started

A file system is implemented by subclassing the pyfuse3.Operations class and implementing the various request handlers. The handlers respond to requests received from the FUSE kernel module and perform functions like looking up the inode given a file name, looking up attributes of an inode, opening a (file) inode for reading or writing or listing the contents of a (directory) inode.

By default, pyfuse3 uses asynchronous I/O using Trio, and most of the documentation assumes that you are using Trio. If you’d rather use asyncio, take a look at asyncio Support. If you would like to use Trio (which is recommended) but you have not yet used Trio before, please read the Trio tutorial first.

An instance of the operations class is passed to pyfuse3.init to mount the file system. To enter the request handling loop, run pyfuse3.main in a trio event loop. This function will return when the file system should be unmounted again, which is done by calling pyfuse3.close.

All character data (directory entry names, extended attribute names and values, symbolic link targets etc) are passed as bytes and must be returned as bytes.

For easier debugging, it is strongly recommended that applications using pyfuse3 also make use of the faulthandler module.

Lookup Counts

Most file systems need to keep track which inodes are currently known to the kernel. This is, for example, necessary to correctly implement the unlink system call: when unlinking a directory entry whose associated inode is currently opened, the file system must defer removal of the inode (and thus the file contents) until it is no longer in use by any process.

FUSE file systems achieve this by using “lookup counts”. A lookup count is a number that’s associated with an inode. An inode with a lookup count of zero is currently not known to the kernel. This means that if there are no directory entries referring to such an inode it can be safely removed, or (if a file system implements dynamic inode numbers), the inode number can be safely recycled.

The lookup count of an inode is increased by every operation that could make the inode “known” to the kernel. This includes e.g. lookup, create and readdir (to determine if a given request handler affects the lookup count, please refer to its description in the Operations class). The lookup count is decreased by calls to the forget handler.

FUSE and VFS Locking

FUSE and the kernel’s VFS layer provide some basic locking that FUSE file systems automatically take advantage of. Specifically:

  • Calls to rename, create, symlink, mknod, link and mkdir acquire a write-lock on the inode of the directory in which the respective operation takes place (two in case of rename).
  • Calls to lookup acquire a read-lock on the inode of the parent directory (meaning that lookups in the same directory may run concurrently, but never at the same time as e.g. a rename or mkdir operation).
  • Unless writeback caching is enabled, calls to write for the same inode are automatically serialized (i.e., there are never concurrent calls for the same inode even when multithreading is enabled).
pyfuse3-3.2.0/doc/html/genindex.html0000664000175000017500000004605313773155703021021 0ustar nikrationikratio00000000000000 Index — pyfuse3 3.2.0 documentation

Index

A | C | D | E | F | G | I | K | L | M | N | O | P | R | S | T | U | W

A

C

D

E

F

G

I

K

L

M

N

O

P

R

S

T

U

W

pyfuse3-3.2.0/doc/html/gotchas.html0000664000175000017500000002123513773155703020643 0ustar nikrationikratio00000000000000 Common Gotchas — pyfuse3 3.2.0 documentation

Common Gotchas

This chapter lists some common gotchas that should be avoided.

pyfuse3-3.2.0/doc/html/index.html0000664000175000017500000001503413773155703020322 0ustar nikrationikratio00000000000000 pyfuse3 Documentation — pyfuse3 3.2.0 documentation
pyfuse3-3.2.0/doc/html/install.html0000664000175000017500000002210713773155703020660 0ustar nikrationikratio00000000000000 Installation — pyfuse3 3.2.0 documentation

Installation

Dependencies

In order to build and run pyfuse3 you need the following software:

  • Linux kernel 3.9 or newer.
  • Version 3.3.0 or newer of the libfuse library, including development headers (typically distributions provide them in a libfuse3-devel or libfuse3-dev package).
  • Python 3.5 or newer installed with development headers
  • The Trio Python module, version 0.7 or newer.
  • The setuptools Python module, version 1.0 or newer.
  • the pkg-config tool
  • the attr library
  • A C compiler (only for building)

To run the unit tests, you will need

  • The py.test Python module, version 3.3.0 or newer

Stable releases

To install a stable pyfuse3 release:

  1. Download and unpack the release tarball from https://pypi.python.org/pypi/pyfuse3/
  2. Run python3 setup.py build_ext --inplace to build the C extension
  3. Run python3 -m pytest test/ to run a self-test. If this fails, ask for help on the FUSE mailing list or report a bug in the issue tracker.
  4. To install system-wide for all users, run sudo python setup.py install. To install into ~/.local, run python3 setup.py install --user.

Development Version

If you have checked out the unstable development version, a bit more effort is required. You need to also have Cython (0.28.1 or newer) and Sphinx (1.1 or newer) installed, and the necessary commands are:

python3 setup.py build_cython
python3 setup.py build_ext --inplace
python3 -m pytest test/
python3 setup.py build_sphinx
python3 setup.py install
pyfuse3-3.2.0/doc/html/objects.inv0000664000175000017500000000216613773155703020476 0ustar nikrationikratio00000000000000# Sphinx inventory version 2 # Project: pyfuse3 # Version: 3.2.0 # The remainder of this file is compressed using zlib. xڥMs8 UeP;5Q ɤjR!S7۠>`,؄DsnRKrKFw*ǁA}E Nڨ-k *j)JOtZ6΂ Scre}Qv ob 4LIolA4 61_Weo-, ɋ4qk%gAӺ=ih=Z/Z+^B-3ϲV7^9ρ)pݕ@%-wp%(4 Lrզd!wČ%`w'K 3;,4YA?i05DcY&jzJ5ŐAE4RU$CXnh;4pn@N , -`nec5-I0TNb4 X._?˧H/W?jVsWA<6!a=K7:ųC6az_ӇxV_L k 8ȞW ѽZc{>%W1k,ӑ/eq[xf¸jZsҌE؋>r=[R],hg2DY`HSsq$e2b,J{BC\0u4_ '4m?&\/^LЕyxtgj׮m9?%|Lr7A۸^N dDžHjWZL|.ZCq2E">  1qܑaweӤ>[m?CgF B_c [>d)"O<\h%nN=Gɭ_T[>vr+;I>X%S O֧h|%to>SL83P>93aDg G>l$')$?8h31@u7mXIXʏ˜Opyfuse3-3.2.0/doc/html/operations.html0000664000175000017500000015757613773155703021420 0ustar nikrationikratio00000000000000 Request Handlers — pyfuse3 3.2.0 documentation

Request Handlers

(You can use the Index to directly jump to a specific handler).

class pyfuse3.Operations

This class defines the request handler methods that an pyfuse3 file system may implement. If a particular request handler has not been implemented, it must raise FUSEError with an errorcode of errno.ENOSYS. Further requests of this type will then be handled directly by the FUSE kernel module without calling the handler again.

The only exception that request handlers are allowed to raise is FUSEError. This will cause the specified errno to be returned by the syscall that is being handled.

It is recommended that file systems are derived from this class and only overwrite the handlers that they actually implement. (The methods defined in this class all just raise FUSEError(ENOSYS) or do nothing).

supports_dot_lookup = True

If set, indicates that the filesystem supports lookup of the . and .. entries. This is required if the file system will be shared over NFS.

enable_writeback_cache = True

Enables write-caching in the kernel if available. This means that individual write request may be buffered and merged in the kernel before they are send to the filesystem.

enable_acl = False

Enable ACL support. When enabled, the kernel will cache and have responsibility for enforcing ACLs. ACL will be stored as xattrs and passed to userspace, which is responsible for updating the ACLs in the filesystem, keeping the file mode in sync with the ACL, and ensuring inheritance of default ACLs when new filesystem nodes are created. Note that this requires that the file system is able to parse and interpret the xattr representation of ACLs.

Enabling this feature implicitly turns on the default_permissions option.
coroutine access(inode, mode, ctx)

Check if requesting process has mode rights on inode.

ctx will be a RequestContext instance.

The method must return a boolean value.

If the default_permissions mount option is given, this method is not called.

When implementing this method, the get_sup_groups function may be useful.

coroutine create(parent_inode, name, mode, flags, ctx)

Create a file with permissions mode and open it with flags

ctx will be a RequestContext instance.

The method must return a tuple of the form (fi, attr), where fi is a FileInfo instance handle like the one returned by open and attr is an EntryAttributes instance with the attributes of the newly created directory entry.

(Successful) execution of this handler increases the lookup count for the returned inode by one.

coroutine flush(fh)

Handle close() syscall.

fh will by an integer filehandle returned by a prior open or create call.

This method is called whenever a file descriptor is closed. It may be called multiple times for the same open file (e.g. if the file handle has been duplicated).

coroutine forget(inode_list)

Decrease lookup counts for inodes in inode_list

inode_list is a list of (inode, nlookup) tuples. This method should reduce the lookup count for each inode by nlookup.

If the lookup count reaches zero, the inode is currently not known to the kernel. In this case, the file system will typically check if there are still directory entries referring to this inode and, if not, remove the inode.

If the file system is unmounted, it may not have received forget calls to bring all lookup counts to zero. The filesystem needs to take care to clean up inodes that at that point still have non-zero lookup count (e.g. by explicitly calling forget with the current lookup count for every such inode after main has returned).

This method must not raise any exceptions (not even FUSEError), since it is not handling a particular client request.

coroutine fsync(fh, datasync)

Flush buffers for open file fh

If datasync is true, only the file contents should be flushed (in contrast to the metadata about the file).

fh will by an integer filehandle returned by a prior open or create call.

coroutine fsyncdir(fh, datasync)

Flush buffers for open directory fh

If datasync is true, only the directory contents should be flushed (in contrast to metadata about the directory itself).

coroutine getattr(inode, ctx)

Get attributes for inode

ctx will be a RequestContext instance.

This method should return an EntryAttributes instance with the attributes of inode. The entry_timeout attribute is ignored in this context.

coroutine getxattr(inode, name, ctx)

Return extended attribute name of inode

ctx will be a RequestContext instance.

If the attribute does not exist, the method must raise FUSEError with an error code of ENOATTR. name will be of type bytes, but is guaranteed not to contain zero-bytes (\0).

init()

Initialize operations

This method will be called just before the file system starts handling requests. It must not raise any exceptions (not even FUSEError), since it is not handling a particular client request.

Create directory entry name in parent_inode refering to inode.

ctx will be a RequestContext instance.

The method must return an EntryAttributes instance with the attributes of the newly created directory entry.

(Successful) execution of this handler increases the lookup count for the returned inode by one.

coroutine listxattr(inode, ctx)

Get list of extended attributes for inode

ctx will be a RequestContext instance.

This method must return a sequence of bytes objects. The objects must not include zero-bytes (\0).

coroutine lookup(parent_inode, name, ctx)

Look up a directory entry by name and get its attributes.

This method should return an EntryAttributes instance for the directory entry name in the directory with inode parent_inode.

If there is no such entry, the method should either return an EntryAttributes instance with zero st_ino value (in which case the negative lookup will be cached as specified by entry_timeout), or it should raise FUSEError with an errno of errno.ENOENT (in this case the negative result will not be cached).

ctx will be a RequestContext instance.

The file system must be able to handle lookups for . and .., no matter if these entries are returned by readdir or not.

(Successful) execution of this handler increases the lookup count for the returned inode by one.

coroutine mkdir(parent_inode, name, mode, ctx)

Create a directory

This method must create a new directory name with mode mode in the directory with inode parent_inode. ctx will be a RequestContext instance.

This method must return an EntryAttributes instance with the attributes of the newly created directory entry.

(Successful) execution of this handler increases the lookup count for the returned inode by one.

coroutine mknod(parent_inode, name, mode, rdev, ctx)

Create (possibly special) file

This method must create a (special or regular) file name in the directory with inode parent_inode. Whether the file is special or regular is determined by its mode. If the file is neither a block nor character device, rdev can be ignored. ctx will be a RequestContext instance.

The method must return an EntryAttributes instance with the attributes of the newly created directory entry.

(Successful) execution of this handler increases the lookup count for the returned inode by one.

coroutine open(inode, flags, ctx)

Open a inode inode with flags.

ctx will be a RequestContext instance.

flags will be a bitwise or of the open flags described in the open(2) manpage and defined in the os module (with the exception of O_CREAT, O_EXCL, O_NOCTTY and O_TRUNC)

This method must return a FileInfo instance. The FileInfo.fh field must contain an integer file handle, which will be passed to the read, write, flush, fsync and release methods to identify the open file. The FileInfo instance may also have relevant configuration attributes set; see the FileInfo documentation for more information.

coroutine opendir(inode, ctx)

Open the directory with inode inode

ctx will be a RequestContext instance.

This method should return an integer file handle. The file handle will be passed to the readdir, fsyncdir and releasedir methods to identify the directory.

coroutine read(fh, off, size)

Read size bytes from fh at position off

fh will by an integer filehandle returned by a prior open or create call.

This function should return exactly the number of bytes requested except on EOF or error, otherwise the rest of the data will be substituted with zeroes.

coroutine readdir(fh, start_id, token)

Read entries in open directory fh.

This method should list the contents of directory fh (as returned by a prior opendir call), starting at the entry identified by start_id.

Instead of returning the directory entries directly, the method must call readdir_reply for each directory entry. If readdir_reply returns True, the file system must increase the lookup count for the provided directory entry by one and call readdir_reply again for the next entry (if any). If readdir_reply returns False, the lookup count must not be increased and the method should return without further calls to readdir_reply.

The start_id parameter will be either zero (in which case listing should begin with the first entry) or it will correspond to a value that was previously passed by the file system to the readdir_reply function in the next_id parameter.

If entries are added or removed during a readdir cycle, they may or may not be returned. However, they must not cause other entries to be skipped or returned more than once.

. and .. entries may be included but are not required. However, if they are reported the filesystem must not increase the lookup count for the corresponding inodes (even if readdir_reply returns True).

Return target of symbolic link inode.

ctx will be a RequestContext instance.

coroutine release(fh)

Release open file

This method will be called when the last file descriptor of fh has been closed, i.e. when the file is no longer opened by any client process.

fh will by an integer filehandle returned by a prior open or create call. Once release has been called, no future requests for fh will be received (until the value is re-used in the return value of another open or create call).

This method may return an error by raising FUSEError, but the error will be discarded because there is no corresponding client request.

coroutine releasedir(fh)

Release open directory

This method will be called exactly once for each opendir call. After fh has been released, no further readdir requests will be received for it (until it is opened again with opendir).

coroutine removexattr(inode, name, ctx)

Remove extended attribute name of inode

ctx will be a RequestContext instance.

If the attribute does not exist, the method must raise FUSEError with an error code of ENOATTR. name will be of type bytes, but is guaranteed not to contain zero-bytes (\0).

coroutine rename(parent_inode_old, name_old, parent_inode_new, name_new, flags, ctx)

Rename a directory entry.

This method must rename name_old in the directory with inode parent_inode_old to name_new in the directory with inode parent_inode_new. If name_new already exists, it should be overwritten.

flags may be RENAME_EXCHANGE or RENAME_NOREPLACE. If RENAME_NOREPLACE is specified, the filesystem must not overwrite name_new if it exists and return an error instead. If RENAME_EXCHANGE is specified, the filesystem must atomically exchange the two files, i.e. both must exist and neither may be deleted.

ctx will be a RequestContext instance.

Let the inode associated with name_old in parent_inode_old be inode_moved, and the inode associated with name_new in parent_inode_new (if it exists) be called inode_deref.

If inode_deref exists and has a non-zero lookup count, or if there are other directory entries referring to inode_deref), the file system must update only the directory entry for name_new to point to inode_moved instead of inode_deref. (Potential) removal of inode_deref (containing the previous contents of name_new) must be deferred to the forget method to be carried out when the lookup count reaches zero (and of course only if at that point there are no more directory entries associated with inode_deref either).

coroutine rmdir(parent_inode, name, ctx)

Remove directory name

This method must remove the directory name from the direcory with inode parent_inode. ctx will be a RequestContext instance. If there are still entries in the directory, the method should raise FUSEError(errno.ENOTEMPTY).

If the inode associated with name (i.e., not the parent_inode) has a non-zero lookup count, the file system must remove only the directory entry (so that future calls to readdir for parent_inode will no longer include name, but e.g. calls to getattr for file’s inode still succeed). Removal of the associated inode holding the directory contents and metadata must be deferred to the forget method to be carried out when the lookup count reaches zero.

(Since hard links to directories are not allowed by POSIX, this method is not required to check if there are still other directory entries refering to the same inode. This conveniently avoids the ambigiouties associated with the . and .. entries).

coroutine setattr(inode, attr, fields, fh, ctx)

Change attributes of inode

fields will be an SetattrFields instance that specifies which attributes are to be updated. attr will be an EntryAttributes instance for inode that contains the new values for changed attributes, and undefined values for all other attributes.

Most file systems will additionally set the st_ctime_ns attribute to the current time (to indicate that the inode metadata was changed).

If the syscall that is being processed received a file descriptor argument (like e.g. ftruncate(2) or fchmod(2)), fh will be the file handle returned by the corresponding call to the open handler. If the syscall was path based (like e.g. truncate(2) or chmod(2)), fh will be None.

ctx will be a RequestContext instance.

The method should return an EntryAttributes instance (containing both the changed and unchanged values).

coroutine setxattr(inode, name, value, ctx)

Set extended attribute name of inode to value.

ctx will be a RequestContext instance.

The attribute may or may not exist already. Both name and value will be of type bytes. name is guaranteed not to contain zero-bytes (\0).

stacktrace()

Asynchronous debugging

This method will be called when the fuse_stacktrace extended attribute is set on the mountpoint. The default implementation logs the current stack trace of every running Python thread. This can be quite useful to debug file system deadlocks.

coroutine statfs(ctx)

Get file system statistics

ctx will be a RequestContext instance.

The method must return an appropriately filled StatvfsData instance.

Create a symbolic link

This method must create a symbolink link named name in the directory with inode parent_inode, pointing to target. ctx will be a RequestContext instance.

The method must return an EntryAttributes instance with the attributes of the newly created directory entry.

(Successful) execution of this handler increases the lookup count for the returned inode by one.

Remove a (possibly special) file

This method must remove the (special or regular) file name from the direcory with inode parent_inode. ctx will be a RequestContext instance.

If the inode associated with file (i.e., not the parent_inode) has a non-zero lookup count, or if there are still other directory entries referring to this inode (due to hardlinks), the file system must remove only the directory entry (so that future calls to readdir for parent_inode will no longer include name, but e.g. calls to getattr for file’s inode still succeed). (Potential) removal of the associated inode with the file contents and metadata must be deferred to the forget method to be carried out when the lookup count reaches zero (and of course only if at that point there are no more directory entries associated with the inode either).

coroutine write(fh, off, buf)

Write buf into fh at off

fh will by an integer filehandle returned by a prior open or create call.

This method must return the number of bytes written. However, unless the file system has been mounted with the direct_io option, the file system must always write all the provided data (i.e., return len(buf)).

pyfuse3-3.2.0/doc/html/py-modindex.html0000664000175000017500000001153713773155703021454 0ustar nikrationikratio00000000000000 Python Module Index — pyfuse3 3.2.0 documentation

Python Module Index

p
 
p
pyfuse3
pyfuse3-3.2.0/doc/html/search.html0000664000175000017500000001147713773155703020467 0ustar nikrationikratio00000000000000 Search — pyfuse3 3.2.0 documentation

Search

Please activate JavaScript to enable the search functionality.

From here you can search these documents. Enter your search words into the box below and click "search". Note that the search function will automatically search for all of the words. Pages containing fewer words won't appear in the result list.

pyfuse3-3.2.0/doc/html/searchindex.js0000664000175000017500000004063313773155703021163 0ustar nikrationikratio00000000000000Search.setIndex({docnames:["about","asyncio","changes","data","example","fuse_api","general","gotchas","index","install","operations","util"],envversion:{"sphinx.domains.c":1,"sphinx.domains.changeset":1,"sphinx.domains.cpp":1,"sphinx.domains.javascript":1,"sphinx.domains.math":2,"sphinx.domains.python":1,"sphinx.domains.rst":1,"sphinx.domains.std":1,"sphinx.ext.intersphinx":1,sphinx:55},filenames:["about.rst","asyncio.rst","changes.rst","data.rst","example.rst","fuse_api.rst","general.rst","gotchas.rst","index.rst","install.rst","operations.rst","util.rst"],objects:{"":{pyfuse3:[8,0,0,"-"]},"pyfuse3.EntryAttributes":{attr_timeout:[3,3,1,""],entry_timeout:[3,3,1,""],generation:[3,3,1,""],st_atime_ns:[3,3,1,""],st_blksize:[3,3,1,""],st_blocks:[3,3,1,""],st_ctime_ns:[3,3,1,""],st_gid:[3,3,1,""],st_ino:[3,3,1,""],st_mode:[3,3,1,""],st_mtime_ns:[3,3,1,""],st_nlink:[3,3,1,""],st_rdev:[3,3,1,""],st_size:[3,3,1,""],st_uid:[3,3,1,""]},"pyfuse3.FileInfo":{direct_io:[3,3,1,""],fh:[3,3,1,""],keep_cache:[3,3,1,""],nonseekable:[3,3,1,""]},"pyfuse3.Operations":{access:[10,5,1,""],create:[10,5,1,""],flush:[10,5,1,""],forget:[10,5,1,""],fsync:[10,5,1,""],fsyncdir:[10,5,1,""],getattr:[10,5,1,""],getxattr:[10,5,1,""],init:[10,5,1,""],link:[10,5,1,""],listxattr:[10,5,1,""],lookup:[10,5,1,""],mkdir:[10,5,1,""],mknod:[10,5,1,""],open:[10,5,1,""],opendir:[10,5,1,""],read:[10,5,1,""],readdir:[10,5,1,""],readlink:[10,5,1,""],release:[10,5,1,""],releasedir:[10,5,1,""],removexattr:[10,5,1,""],rename:[10,5,1,""],rmdir:[10,5,1,""],setattr:[10,5,1,""],setxattr:[10,5,1,""],stacktrace:[10,5,1,""],statfs:[10,5,1,""],symlink:[10,5,1,""],unlink:[10,5,1,""],write:[10,5,1,""]},"pyfuse3.RequestContext":{gid:[3,3,1,""],pid:[3,3,1,""],uid:[3,3,1,""],umask:[3,3,1,""]},"pyfuse3.SetattrFields":{update_atime:[3,3,1,""],update_gid:[3,3,1,""],update_mode:[3,3,1,""],update_mtime:[3,3,1,""],update_size:[3,3,1,""],update_uid:[3,3,1,""]},"pyfuse3.StatvfsData":{f_bavail:[3,3,1,""],f_bfree:[3,3,1,""],f_blocks:[3,3,1,""],f_bsize:[3,3,1,""],f_favail:[3,3,1,""],f_ffree:[3,3,1,""],f_files:[3,3,1,""],f_frsize:[3,3,1,""],f_namemax:[3,3,1,""]},pyfuse3:{ENOATTR:[3,1,1,""],EntryAttributes:[3,2,1,""],FUSEError:[3,4,1,""],FileInfo:[3,2,1,""],Operations:[10,2,1,""],RENAME_EXCHANGE:[3,1,1,""],RENAME_NOREPLACE:[3,1,1,""],ROOT_INODE:[3,1,1,""],RequestContext:[3,2,1,""],SetattrFields:[3,2,1,""],StatvfsData:[3,2,1,""],close:[5,6,1,""],default_options:[3,1,1,""],get_sup_groups:[11,6,1,""],getxattr:[11,6,1,""],init:[5,6,1,""],invalidate_entry:[5,6,1,""],invalidate_entry_async:[5,6,1,""],invalidate_inode:[5,6,1,""],listdir:[11,6,1,""],main:[5,6,1,""],notify_store:[5,6,1,""],readdir_reply:[5,6,1,""],setxattr:[11,6,1,""],syncfs:[11,6,1,""],terminate:[5,6,1,""],trio_token:[5,1,1,""]}},objnames:{"0":["py","module","Python module"],"1":["py","data","Python data"],"2":["py","class","Python class"],"3":["py","attribute","Python attribute"],"4":["py","exception","Python exception"],"5":["py","method","Python method"],"6":["py","function","Python function"]},objtypes:{"0":"py:module","1":"py:data","2":"py:class","3":"py:attribute","4":"py:exception","5":"py:method","6":"py:function"},terms:{"03d":4,"0o644":4,"0o755":4,"1e9":4,"boolean":10,"break":[2,4],"byte":[6,10,11],"case":[4,5,6,10],"class":[3,4,5,6,10],"default":[1,3,4,5,6,10],"final":11,"float":3,"function":[1,2,3,4,6,8,10],"import":[1,4],"int":4,"long":2,"new":[2,10],"null":4,"return":[2,3,4,5,6,10,11],"static":4,"super":4,"true":[3,4,5,10],"try":4,"while":5,AND:4,Added:2,BUT:4,FOR:4,For:[0,1,4,5,6,11],INTO:4,NFS:10,NOT:4,THE:4,The:[0,3,4,5,6,9,10,11],There:[2,4,11],USE:4,Use:[1,4],WITH:4,With:4,__init__:4,__main__:4,__name__:4,__str__:4,_add_path:4,_creat:4,_fd_inode_map:4,_fd_open_count:4,_forget_path:4,_getattr:4,_inode_fd_map:4,_inode_path_map:4,_inode_to_path:4,_lookup_cnt:4,_remov:4,_replac:4,abl:10,about:[3,4,5,8,10],abspath:4,accept:2,access:[3,4,5,10],achiev:6,acl:10,acquir:6,action:4,activ:5,actual:[2,4,5,10],add:[3,4,5],add_argu:4,added:10,addhandl:4,addit:2,addition:10,advantag:6,affect:6,after:[5,10],again:[5,6,10],all:[2,4,6,9,10],alloc:4,allow:[2,10],allow_oth:5,alreadi:10,also:[0,4,5,6,9,10,11],altern:5,alwai:[3,4,10],ambigiouti:10,amount:4,ani:[0,3,4,5,6,10],anoth:[5,10],api:[0,8],append:4,applic:6,appropri:10,approxim:11,archiv:0,arg:[4,5],argpars:4,argument:[4,5,10],argumentpars:4,argv:4,aris:4,asctim:4,ask:9,assert:[4,7],associ:[4,5,6,10],assum:[1,6],async:4,asynchron:[0,1,5,6,10],asyncio:[0,2,6,8],atim:4,atime_n:4,atom:[3,10],attempt:[4,5],attr:[4,5,9,10],attr_onli:5,attr_timeout:[3,4],attribut:[2,3,5,6,10,11],author:4,autoincr:4,automat:[5,6],avail:[0,10,11],avoid:[5,7,10],await:4,awar:2,back:5,backward:[0,2],bar:7,base:10,basedir:4,basi:5,basic:6,becaus:[4,5,10,11],been:[2,4,5,10],befor:[1,5,6,10],begin:[5,10],behavior:[2,3],being:10,beta:0,between:4,beyond:5,bin:4,bind:0,bit:[5,9],bitwis:10,blob:4,block:[2,4,5,10],bool:3,both:[3,4,10],bring:10,buf:[4,10],buffer:[3,10],bug:[0,2,9],build:9,build_cython:9,build_ext:9,build_sphinx:9,cach:[3,5,6,10],call:[1,3,4,5,6,10,11],caller:[3,11],can:[0,3,4,5,6,10],cannot:[4,5],care:10,carri:[3,10,11],caus:10,caveat:4,certain:2,chang:[0,2,4,10],changelog:8,chapter:7,charact:[6,10],charg:4,check:[3,9,10],chmod:[4,10],chown:4,circumst:[2,5],claim:4,clarifi:2,clean:[5,10],client:10,close:[4,5,6,7,10],code:[0,2,3,4,5,7,10,11],collect:4,combin:3,come:4,command:[4,9],common:8,compat:[0,2,3,4],compil:9,complet:[4,5,7],compliant:4,complic:5,concurr:6,config:9,configur:10,confus:4,connect:[4,5],contain:[3,4,10,11],content:[4,6,7,10],context:10,continu:[4,5],contract:4,contrast:[10,11],control:5,conveni:10,convienc:[5,11],copi:4,copyright:4,coroutin:[5,10],correctli:[2,6],correspond:[3,10],could:[3,4,5,6],count:[4,10],cours:10,creat:[2,4,5,6,10],creation:5,ctime:4,ctime_n:4,ctx:[4,10],current:[5,6,10],current_token:[],current_trio_token:5,cursor2:4,cursor:4,cycl:10,cython:[2,9],damag:4,data:[4,5,6,8,10],datasync:10,date:2,datefmt:4,deadlock:[5,10],deal:4,debug:[4,6,10],debug_fus:4,decreas:[6,10],def:4,default_opt:[3,4,5],default_permiss:[3,4,5,10],defaultdict:4,defer:[6,7,10],defin:[5,10],del:4,delet:[4,5,10],depend:2,deriv:10,describ:10,descript:6,descriptor:10,detail:3,determin:[6,10,11],dev:9,devel:9,deviat:3,devic:[4,10],dict:4,did:7,differ:5,direcori:10,direct_io:[2,3,10],directli:10,directori:[0,3,4,5,6,10,11],dirnam:4,dirti:5,disabl:[4,5],discard:[4,5,10],discuss:0,distribut:[4,9],doc:0,document:[0,1,4,6,10],doe:[3,5,10],doesn:5,don:4,done:6,download:[0,9],due:10,dup:7,duplic:10,dure:[4,10],dynam:6,eacc:4,each:[5,10],easier:[4,6],easili:0,effect:3,effort:9,einval:4,eisdir:4,either:10,element:3,elif:4,els:4,enabl:[0,1,3,4,6,10],enable_acl:10,enable_writeback_cach:[4,10],end:2,enforc:10,enoattr:[3,10],enoent:[4,5,10],enosi:[5,10],enotdir:4,enotempti:[4,10],enotsup:[],ensur:[5,10],enter:[4,6],entri:[2,3,4,5,6,10,11],entrup:4,entry_new:4,entry_old:4,entry_p:4,entry_timeout:[3,4,10],entryattribut:[3,4,5,10],env:4,eof:10,errno:[3,4,5,10],errno_:3,error:[2,3,5,7,10],errorcod:[3,10],escap:11,etc:6,even:[5,6,10],event:[4,5,6],everi:[6,10],exactli:10,exampl:[1,2,5,6,8],exc:4,except:[3,4,5,10],exchang:[3,10],execut:[4,10],exist:[3,4,10],expens:11,explanatori:3,explicitli:[5,10],express:4,extend:[5,6,10,11],extens:9,f_bavail:[3,4],f_bfree:[3,4],f_block:[3,4],f_bsize:[3,4],f_favail:[3,4],f_ffree:[3,4],f_file:[3,4],f_frsize:[3,4],f_namemax:[3,4],fail:[2,3,9,11],fals:[4,5,10],faulthandl:[4,6],fchmod:[4,10],fchown:4,featur:[0,10],fh1:7,fh2:7,field:[3,4,10],file:[2,3,5,6,7,8,10,11],file_on:7,filehandl:10,fileinfo:[2,3,4,10],fileno:7,filesystem:[0,4,5,10,11],fill:10,first:[2,4,6,10,11],fit:4,fix:[2,4],flag:[3,4,10],flaw:4,flush:[7,10],follow:[7,9,11],follow_symlink:4,foo:[3,7],foobar:7,forget:[4,5,6,7,10],forgot:5,fork:2,form:10,formatt:4,free:4,freebsd:11,from:[0,1,2,3,4,5,6,9,10,11],from_thread:5,fsdecod:4,fsencod:4,fsname:[3,4],fstat:[3,4],fsync:10,fsyncdir:10,ftruncat:[4,10],full:0,fulli:4,furnish:4,further:10,fuse:[0,4,8,9,10,11],fuse_file_info:3,fuse_ino_t:5,fuse_ll_opt:5,fuse_lowlevel_c:5,fuse_mount_opt:5,fuse_opt:[4,5],fuse_stacktrac:10,fuseerror:[3,4,10],fusermount:5,futur:10,gener:[0,3,4,5,8],gerion:4,get:[3,4,7,10,11],get_row:4,get_sup_group:[10,11],getattr:[4,10],getgid:4,getlogg:4,getuid:4,getxattr:[10,11],gid:[3,4],gil:11,github:0,given:[6,10],gmane:0,good:[3,4],gotcha:8,gracefulli:[2,5],grant:4,group:11,growth:5,guarante:[3,10],guess:11,handl:[2,3,4,5,6,10],handler:[2,3,4,5,6,8],hard:10,hardlink:[4,10],has:[4,5,10,11],have:[2,3,4,5,6,9,10,11],header:9,hello:4,hello_asyncio:2,hello_data:4,hello_inod:4,hello_nam:4,help:[4,9],here:[1,4],herebi:4,hold:[5,10],holder:4,howev:[5,10],html:0,http:9,identifi:[5,10],ids:11,ignor:[5,10,11],ignore_eno:[2,5],implement:[4,6,7,10,11],impli:4,implicitli:10,importerror:4,includ:[0,3,4,6,9,10],incompat:0,increas:[0,6,10],index:[8,10],indic:[3,10],individu:10,info:4,inform:[3,5,8,10],inherit:10,init:[3,4,5,6,10],init_log:4,init_t:4,initi:[3,4,5,10],ino:4,inod:[3,4,5,6,10],inode_deref:10,inode_list:[4,10],inode_mov:10,inode_open_count:4,inode_p:[4,5],inode_p_new:4,inode_p_old:4,inode_par:4,inotifi:5,inplac:9,insert:4,instal:8,instanc:[3,5,6,10],instead:[2,3,5,10],instruct:5,integ:[3,4,5,10],interfac:[5,11],interpret:10,invalid:[3,5],invalidate_entri:5,invalidate_entry_async:[2,5],invalidate_inod:[2,5],isinst:4,issu:[0,9],iter:[4,11],its:[1,5,6,10],itself:[5,10],join:4,jump:10,just:10,keep:[4,6,10],keep_cach:3,kei:4,kernel:[2,3,5,6,9,10],keyerror:4,kind:4,kindli:0,know:11,knowledg:5,known:[6,10],lambda:4,larg:4,last:[3,10],lastrowid:4,later:5,layer:6,lead:5,len:[4,10],length:4,less:5,let:10,liabil:4,liabl:4,libfus:[0,2,9,11],libfuse3:9,librari:[9,11],like:[0,6,10,11],limit:4,line:4,link:[4,5,6,10],linux:[0,4,9,11],list:[0,5,6,7,9,10],listdir:[4,7,11],listxattr:10,llfuse:2,lltest:4,load:4,local:9,lock:5,log:[2,4,5,10],longer:[2,6,10],look:[2,6,10],lookup:[4,5,10],loop:[2,4,5,6],lowlevel:5,lseek:4,lstat:4,made:2,mai:[2,3,4,5,6,10,11],mail:[0,9],main:[2,4,5,6,10],maintain:4,major:0,make:6,manpag:10,map:4,match:5,matter:10,max:4,max_task:5,mean:[0,5,6,10],memoryview:4,merchant:4,merg:[4,10],messag:4,metadata:10,method:[3,5,10,11],min_task:5,mirror:4,miss:3,mistak:7,mkdir:[4,5,6,10],mknod:[4,5,6,10],mnt:7,mode:[4,10],modif:[2,3],modifi:4,modul:[1,2,3,4,5,6,9,10],more:[4,9,10],most:[1,3,6,10],mount:[3,4,5,6,7,10,11],mountpoint:[4,5,10],msec:4,mtime:4,mtime_n:4,multipl:[4,10],multithread:6,must:[3,5,6,10],my_opt:5,name:[3,4,5,6,10,11],name_new:[4,10],name_old:[4,10],namespac:11,nanosecond:[2,3],necessari:[5,6,9],necessarili:11,need:[2,4,5,6,9,10],neg:10,neither:10,never:[3,4,6],new_inode_p:4,new_nam:[4,10],new_parent_inod:10,newer:9,newest:2,newli:10,next:[4,10],next_id:[5,10],nikolau:4,nlookup:[4,10],node:10,non:[10,11],none:[4,5,10],noninfring:4,nonseek:3,nor:[5,10],normal:5,nosuchrowerror:4,note:[2,4,5,10],noth:10,notify_stor:5,nouniquevalueerror:4,now:2,now_n:4,number:[0,3,4,6,10],o_creat:[4,10],o_excl:10,o_noctti:10,o_rdwr:4,o_trunc:[4,10],o_wronli:4,object:10,obtain:4,occur:5,off:[4,10],off_t:5,offset:[4,5],old:2,oldstat:4,omit:4,onc:[4,5,10],one:[4,5,10],onli:[3,5,9,10],onlin:0,open:[2,3,4,6,7,10],opendir:[4,10],oper:[2,3,4,5,6,10],ops:5,option:[3,4,5,10],order:[4,9],org:[4,9],oserror:[4,5],other:[3,4,5,10,11],otherwis:[4,10],out:[3,4,9,10,11],output:4,over:[4,5,10,11],overwrit:10,overwritten:10,packag:9,page:[5,8],paramet:[2,10,11],parent:[4,5,6],parent_inod:[4,10],parent_inode_new:10,parent_inode_old:10,parent_new:4,parent_old:4,pars:[4,10],parse_arg:4,parser:4,part:2,partial:5,particular:[4,10,11],pass:[3,4,5,6,10],passthroughf:[2,4],path:[3,4,10,11],path_new:4,path_old:4,path_or_fh:4,peform:5,pend:5,pep:11,perform:[3,4,5,6],permiss:[3,4,10],permit:4,person:4,pick:4,pid:[3,11],pkg:9,place:6,platform:11,pleas:[0,6],point:[3,10],posit:[5,10],posix:[4,10],possibl:[4,10],potenti:[10,11],presenc:5,present:4,previou:10,previous:[3,5,10],primari:4,prior:10,probabl:7,proc:11,process:[5,6,10],produc:4,program:4,progress:5,properli:5,provid:[0,3,4,5,6,9,10,11],publish:4,purpos:4,put:5,pyfuse3:[0,1,2,3,4,5,6,9,10,11],pyfuse3_asyncio:1,pylint:4,pypi:[0,9],pytest:9,python3:[4,9],python:[0,2,9,10,11],pyx:4,queri:4,question:0,queue:5,quit:10,r0201:4,rais:[3,4,5,10],rath:4,rather:[1,6],rdev:[4,10],reach:10,read:[0,6,7,10,11],readdir:[2,4,5,6,10],readdir_repli:[4,5,10],readdirtoken:5,readlink:[4,10],reason:[3,5,11],receiv:[5,6,10],recommend:[3,5,6,10],recycl:6,reduc:10,refer:[4,6,10],reflect:0,regener:2,regular:10,rel:11,relat:[5,11],releas:[0,4,10,11],releasedir:10,relev:[3,10],remain:5,remov:[2,4,5,6,10],removexattr:[5,10],renam:[2,3,4,5,6,10],rename_exchang:[3,10],rename_noreplac:[3,10],repeat:5,replac:3,report:[0,5,9,10],represent:[10,11],request:[3,4,5,6,8],requestcontext:[3,10],requir:[9,10],resolv:4,respect:6,respond:6,respons:[5,10],rest:10,restrict:4,result:[3,4,5,10],retriev:[4,5],right:[4,5,10],rmdir:[4,5,10],robust:5,root:[3,4],root_inod:[3,4],root_logg:4,round:2,row:4,row_factori:4,rowid:4,run:[4,5,6,9,10],run_sync:5,run_sync_in_worker_thread:5,s_ifdir:4,s_iflnk:4,s_ifreg:4,s_imod:4,s_irgrp:4,s_iroth:4,s_irusr:4,s_isdir:4,s_islnk:4,s_iwgrp:4,s_iwoth:4,s_iwusr:4,s_ixgrp:4,s_ixoth:4,s_ixusr:4,safe:[3,6],same:[4,5,6,10,11],search:8,searchabl:0,second:[3,11],see:[3,10],seek:[3,7],seek_set:4,select:[4,11],self:[3,4,9],sell:4,semant:0,send:[5,10],separ:5,sequenc:10,serial:6,set:[0,2,3,4,5,10,11],setattr:[3,4,5,10],setattrfield:[3,10],setformatt:4,setlevel:4,setup:[4,9],setuptool:9,setxattr:[5,10,11],sever:4,shall:4,share:10,ship:4,should:[2,3,4,5,6,7,10,11],shouldn:4,signal:[3,5],signific:4,simpl:4,simpli:4,sinc:10,singl:5,size:[4,5,10,11],size_guess:11,size_t:11,skip:[4,5,10],softwar:[4,9],some:[2,3,4,5,6,7],sort:4,sourc:[0,2,4],special:10,specif:[6,10],specifi:[3,4,10],sphinx:9,sqlite3:4,src:4,st_atime_n:[3,4],st_blksize:[3,4],st_block:[3,4],st_ctime_n:[3,4,10],st_gid:[3,4],st_ino:[3,4,10],st_mode:[3,4],st_mtime_n:[3,4],st_nlink:[3,4],st_rdev:[3,4],st_size:[3,4],st_uid:[3,4],stack:10,stacktrac:10,stamp:4,stand:2,standard:11,start:[4,5,10],start_id:[4,5,10],stat:[3,4],stat_:4,stat_m:4,statf:[4,10],statist:10,statu:11,statvf:[3,4],statvfsdata:[3,4,10],still:[3,5,10],stopiter:4,store:[3,4,5,10],store_tru:4,str:[4,11],streamhandl:4,string:[5,11],strongli:6,struct:[2,3,5],structur:8,subclass:6,sublicens:4,substitut:10,succe:10,success:10,sudo:9,sum:4,supplementari:11,suppli:[5,11],support:[2,3,4,5,6,8,10],supports_dot_lookup:10,surrog:11,symbol:[4,6,10],symbolink:10,symlink:[4,5,6,10],sync:[10,11],syncf:[2,11],sys:[4,5],syscal:[3,10],system:[2,3,5,6,7,8,9,10,11],tabl:4,take:[2,6,10],tarbal:[0,4,9],target:[3,4,6,10],target_exist:4,technic:5,termin:[2,5],terribl:4,test:9,testf:4,text_factori:4,than:[4,10],thank:2,thei:[5,10,11],them:[4,9],therefor:5,thi:[0,2,3,4,5,6,7,9,10,11],third:11,though:5,thread:[5,10],threadnam:4,three:11,through:[4,5],thu:6,time:[3,4,6,10,11],timeout:3,tmpf:[2,4],token:[4,5,10],tool:9,tort:4,trace:10,track:6,tracker:[0,9],translat:11,tree:4,trio:[0,1,2,4,5,6,9],trio_token:5,truncat:[4,10],tupl:10,turn:[10,11],tutori:6,twice:[4,5],two:[3,4,6,10],type:[4,10,11],typic:[9,10],uid:[3,4],uint64_t:3,umask:[3,4],umount:5,unbound:5,unchang:10,undefin:10,under:[4,5,11],underli:4,understand:4,unfortun:[3,5],uniqu:[4,5],unit:[3,9],unless:[5,6,10],unlink:[4,5,6,10],unmount:[4,5,6,10],unpack:9,unstabl:9,until:[5,6,10],unus:4,updat:[3,4,10],update_atim:[3,4],update_ctim:4,update_gid:[3,4],update_mod:[3,4],update_mtim:[3,4],update_s:[3,4],update_uid:[3,4],use:[0,1,4,5,6,10],used:[3,5,6,10,11],useful:[10,11],user:[5,9,11],userspac:10,uses:[0,1,6],using:[1,2,5,6],usr:4,usual:1,utf:4,util:8,utim:4,val:4,valid:[3,5],valu:[3,4,5,6,10,11],variou:6,veri:4,version:0,via:5,w0612:4,w0613:4,wai:[4,5],want:2,warn:4,warranti:4,watcher:5,well:3,were:2,when:[2,3,5,6,7,10,11],whenev:10,where:[4,10],whether:[4,10],which:[3,5,6,10],whom:4,whose:6,wide:9,within:5,without:[3,4,7,10],work:[2,11],world:4,would:[3,4,6],wrap:5,write:[0,4,5,6,7,10],writeback:[5,6],written:10,wrong:11,xattr:10,yeah:4,yet:[5,6],you:[0,1,2,3,4,6,7,9,10],your:7,zero:[4,6,10]},titles:["About","asyncio Support","Changelog","Data Structures","Example File Systems","FUSE API Functions","General Information","Common Gotchas","pyfuse3 Documentation","Installation","Request Handlers","Utility Functions"],titleterms:{"function":[5,11],VFS:6,about:0,api:5,asyncio:1,changelog:2,common:7,content:8,contribut:0,count:6,data:3,depend:9,develop:[0,9],document:8,exampl:4,file:4,fuse:[5,6],gener:6,get:[0,6],gotcha:7,handler:[7,10],help:0,indic:8,inform:6,inod:7,instal:9,lock:6,lookup:6,memori:4,onli:4,overlai:4,passthrough:4,pyfuse3:8,read:4,releas:[2,9],remov:7,request:10,singl:4,stabl:9,start:6,statu:0,structur:3,support:1,system:4,tabl:8,tbd:[],unlink:7,util:11,version:9}})pyfuse3-3.2.0/doc/html/util.html0000664000175000017500000002620213773155703020167 0ustar nikrationikratio00000000000000 Utility Functions — pyfuse3 3.2.0 documentation

Utility Functions

The following functions do not necessarily translate to calls to the FUSE library. They are provided because they’re potentially useful when implementing file systems in Python.

pyfuse3.setxattr(path, name, value, namespace=u'user')

Set extended attribute

path and name have to be of type str. In Python 3.x, they may contain surrogates. value has to be of type bytes.

Under FreeBSD, the namespace parameter may be set to system or user to select the namespace for the extended attribute. For other platforms, this parameter is ignored.

In contrast to the os.setxattr function from the standard library, the method provided by pyfuse3 is also available for non-Linux systems.

pyfuse3.getxattr(path, name, size_t size_guess=128, namespace=u'user')

Get extended attribute

path and name have to be of type str. In Python 3.x, they may contain surrogates. Returns a value of type bytes.

If the caller knows the approximate size of the attribute value, it should be supplied in size_guess. If the guess turns out to be wrong, the system call has to be carried out three times (the first call will fail, the second determines the size and the third finally gets the value).

Under FreeBSD, the namespace parameter may be set to system or user to select the namespace for the extended attribute. For other platforms, this parameter is ignored.

In contrast to the os.getxattr function from the standard library, the method provided by pyfuse3 is also available for non-Linux systems.

pyfuse3.listdir(path)

Like os.listdir, but releases the GIL.

This function returns an iterator over the directory entries in path.

The returned values are of type str. Surrogate escape coding (cf. PEP 383) is used for directory names that do not have a string representation.

pyfuse3.get_sup_groups(pid)

Return supplementary group ids of pid

This function is relatively expensive because it has to read the group ids from /proc/[pid]/status. For the same reason, it will also not work on systems that do not provide a /proc file system.

Returns a set.

pyfuse3.syncfs(path)

Sync filesystem mounted at path

This is a Python interface to the syncfs(2) system call. There is no particular relation to libfuse, it is provided by pyfuse3 as a convience.

pyfuse3-3.2.0/examples/0000775000175000017500000000000013773156367016436 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/examples/hello.py0000775000175000017500000001206113772376153020112 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' hello.py - Example file system for pyfuse3. This program presents a static file system containing a single file. Copyright © 2015 Nikolaus Rath Copyright © 2015 Gerion Entrup. 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. 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. ''' import os import sys # If we are running from the pyfuse3 source directory, try # to load the module from there first. basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..')) if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'pyfuse3.pyx'))): sys.path.insert(0, os.path.join(basedir, 'src')) from argparse import ArgumentParser import stat import logging import errno import pyfuse3 import trio try: import faulthandler except ImportError: pass else: faulthandler.enable() log = logging.getLogger(__name__) class TestFs(pyfuse3.Operations): def __init__(self): super(TestFs, self).__init__() self.hello_name = b"message" self.hello_inode = pyfuse3.ROOT_INODE+1 self.hello_data = b"hello world\n" async def getattr(self, inode, ctx=None): entry = pyfuse3.EntryAttributes() if inode == pyfuse3.ROOT_INODE: entry.st_mode = (stat.S_IFDIR | 0o755) entry.st_size = 0 elif inode == self.hello_inode: entry.st_mode = (stat.S_IFREG | 0o644) entry.st_size = len(self.hello_data) else: raise pyfuse3.FUSEError(errno.ENOENT) stamp = int(1438467123.985654 * 1e9) entry.st_atime_ns = stamp entry.st_ctime_ns = stamp entry.st_mtime_ns = stamp entry.st_gid = os.getgid() entry.st_uid = os.getuid() entry.st_ino = inode return entry async def lookup(self, parent_inode, name, ctx=None): if parent_inode != pyfuse3.ROOT_INODE or name != self.hello_name: raise pyfuse3.FUSEError(errno.ENOENT) return self.getattr(self.hello_inode) async def opendir(self, inode, ctx): if inode != pyfuse3.ROOT_INODE: raise pyfuse3.FUSEError(errno.ENOENT) return inode async def readdir(self, fh, start_id, token): assert fh == pyfuse3.ROOT_INODE # only one entry if start_id == 0: pyfuse3.readdir_reply( token, self.hello_name, await self.getattr(self.hello_inode), 1) return async def open(self, inode, flags, ctx): if inode != self.hello_inode: raise pyfuse3.FUSEError(errno.ENOENT) if flags & os.O_RDWR or flags & os.O_WRONLY: raise pyfuse3.FUSEError(errno.EACCES) return pyfuse3.FileInfo(fh=inode) async def read(self, fh, off, size): assert fh == self.hello_inode return self.hello_data[off:off+size] def init_logging(debug=False): formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: ' '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S") handler = logging.StreamHandler() handler.setFormatter(formatter) root_logger = logging.getLogger() if debug: handler.setLevel(logging.DEBUG) root_logger.setLevel(logging.DEBUG) else: handler.setLevel(logging.INFO) root_logger.setLevel(logging.INFO) root_logger.addHandler(handler) def parse_args(): '''Parse command line''' parser = ArgumentParser() parser.add_argument('mountpoint', type=str, help='Where to mount the file system') parser.add_argument('--debug', action='store_true', default=False, help='Enable debugging output') parser.add_argument('--debug-fuse', action='store_true', default=False, help='Enable FUSE debugging output') return parser.parse_args() def main(): options = parse_args() init_logging(options.debug) testfs = TestFs() fuse_options = set(pyfuse3.default_options) fuse_options.add('fsname=hello') if options.debug_fuse: fuse_options.add('debug') pyfuse3.init(testfs, options.mountpoint, fuse_options) try: trio.run(pyfuse3.main) except: pyfuse3.close(unmount=False) raise pyfuse3.close() if __name__ == '__main__': main() pyfuse3-3.2.0/examples/hello_asyncio.py0000775000175000017500000001301313772375527021641 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' hello_asyncio.py - Example file system for pyfuse3 using asyncio. This program presents a static file system containing a single file. Copyright © 2015 Nikolaus Rath Copyright © 2015 Gerion Entrup. 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. 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. ''' import os import sys # If we are running from the pyfuse3 source directory, try # to load the module from there first. basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..')) if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'pyfuse3.pyx'))): sys.path.insert(0, os.path.join(basedir, 'src')) from argparse import ArgumentParser import asyncio import stat import logging import errno import pyfuse3 import pyfuse3_asyncio try: import faulthandler except ImportError: pass else: faulthandler.enable() log = logging.getLogger(__name__) pyfuse3_asyncio.enable() class TestFs(pyfuse3.Operations): def __init__(self): super(TestFs, self).__init__() self.hello_name = b"message" self.hello_inode = pyfuse3.ROOT_INODE+1 self.hello_data = b"hello world\n" async def getattr(self, inode, ctx=None): entry = pyfuse3.EntryAttributes() if inode == pyfuse3.ROOT_INODE: entry.st_mode = (stat.S_IFDIR | 0o755) entry.st_size = 0 elif inode == self.hello_inode: entry.st_mode = (stat.S_IFREG | 0o644) entry.st_size = len(self.hello_data) else: raise pyfuse3.FUSEError(errno.ENOENT) stamp = int(1438467123.985654 * 1e9) entry.st_atime_ns = stamp entry.st_ctime_ns = stamp entry.st_mtime_ns = stamp entry.st_gid = os.getgid() entry.st_uid = os.getuid() entry.st_ino = inode return entry async def lookup(self, parent_inode, name, ctx=None): if parent_inode != pyfuse3.ROOT_INODE or name != self.hello_name: raise pyfuse3.FUSEError(errno.ENOENT) return await self.getattr(self.hello_inode) async def opendir(self, inode, ctx): if inode != pyfuse3.ROOT_INODE: raise pyfuse3.FUSEError(errno.ENOENT) return inode async def readdir(self, fh, start_id, token): assert fh == pyfuse3.ROOT_INODE # only one entry if start_id == 0: pyfuse3.readdir_reply( token, self.hello_name, await self.getattr(self.hello_inode), 1) return async def setxattr(self, inode, name, value, ctx): if inode != pyfuse3.ROOT_INODE or name != b'command': raise pyfuse3.FUSEError(errno.ENOTSUP) if value == b'terminate': pyfuse3.terminate() else: raise pyfuse3.FUSEError(errno.EINVAL) async def open(self, inode, flags, ctx): if inode != self.hello_inode: raise pyfuse3.FUSEError(errno.ENOENT) if flags & os.O_RDWR or flags & os.O_WRONLY: raise pyfuse3.FUSEError(errno.EACCES) return pyfuse3.FileInfo(fh=inode) async def read(self, fh, off, size): assert fh == self.hello_inode return self.hello_data[off:off+size] def init_logging(debug=False): formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: ' '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S") handler = logging.StreamHandler() handler.setFormatter(formatter) root_logger = logging.getLogger() if debug: handler.setLevel(logging.DEBUG) root_logger.setLevel(logging.DEBUG) else: handler.setLevel(logging.INFO) root_logger.setLevel(logging.INFO) root_logger.addHandler(handler) def parse_args(): '''Parse command line''' parser = ArgumentParser() parser.add_argument('mountpoint', type=str, help='Where to mount the file system') parser.add_argument('--debug', action='store_true', default=False, help='Enable debugging output') parser.add_argument('--debug-fuse', action='store_true', default=False, help='Enable FUSE debugging output') return parser.parse_args() def main(): options = parse_args() init_logging(options.debug) testfs = TestFs() fuse_options = set(pyfuse3.default_options) fuse_options.add('fsname=hello_asyncio') if options.debug_fuse: fuse_options.add('debug') pyfuse3.init(testfs, options.mountpoint, fuse_options) loop = asyncio.get_event_loop() try: loop.run_until_complete(pyfuse3.main()) except: pyfuse3.close(unmount=False) raise finally: loop.close() pyfuse3.close() if __name__ == '__main__': main() pyfuse3-3.2.0/examples/passthroughfs.py0000775000175000017500000004151213772370051021701 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 ''' passthroughfs.py - Example file system for pyfuse3 This file system mirrors the contents of a specified directory tree. Caveats: * Inode generation numbers are not passed through but set to zero. * Block size (st_blksize) and number of allocated blocks (st_blocks) are not passed through. * Performance for large directories is not good, because the directory is always read completely. * There may be a way to break-out of the directory tree. * The readdir implementation is not fully POSIX compliant. If a directory contains hardlinks and is modified during a readdir call, readdir() may return some of the hardlinked files twice or omit them completely. * If you delete or rename files in the underlying file system, the passthrough file system will get confused. Copyright © Nikolaus Rath 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. 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. ''' import os import sys # If we are running from the pyfuse3 source directory, try # to load the module from there first. basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..')) if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'pyfuse3.pyx'))): sys.path.insert(0, os.path.join(basedir, 'src')) import pyfuse3 from argparse import ArgumentParser import errno import logging import stat as stat_m from pyfuse3 import FUSEError from os import fsencode, fsdecode from collections import defaultdict import trio import faulthandler faulthandler.enable() log = logging.getLogger(__name__) class Operations(pyfuse3.Operations): enable_writeback_cache = True def __init__(self, source): super().__init__() self._inode_path_map = { pyfuse3.ROOT_INODE: source } self._lookup_cnt = defaultdict(lambda : 0) self._fd_inode_map = dict() self._inode_fd_map = dict() self._fd_open_count = dict() def _inode_to_path(self, inode): try: val = self._inode_path_map[inode] except KeyError: raise FUSEError(errno.ENOENT) if isinstance(val, set): # In case of hardlinks, pick any path val = next(iter(val)) return val def _add_path(self, inode, path): log.debug('_add_path for %d, %s', inode, path) self._lookup_cnt[inode] += 1 # With hardlinks, one inode may map to multiple paths. if inode not in self._inode_path_map: self._inode_path_map[inode] = path return val = self._inode_path_map[inode] if isinstance(val, set): val.add(path) elif val != path: self._inode_path_map[inode] = { path, val } async def forget(self, inode_list): for (inode, nlookup) in inode_list: if self._lookup_cnt[inode] > nlookup: self._lookup_cnt[inode] -= nlookup continue log.debug('forgetting about inode %d', inode) assert inode not in self._inode_fd_map del self._lookup_cnt[inode] try: del self._inode_path_map[inode] except KeyError: # may have been deleted pass async def lookup(self, inode_p, name, ctx=None): name = fsdecode(name) log.debug('lookup for %s in %d', name, inode_p) path = os.path.join(self._inode_to_path(inode_p), name) attr = self._getattr(path=path) if name != '.' and name != '..': self._add_path(attr.st_ino, path) return attr async def getattr(self, inode, ctx=None): if inode in self._inode_fd_map: return self._getattr(fd=self._inode_fd_map[inode]) else: return self._getattr(path=self._inode_to_path(inode)) def _getattr(self, path=None, fd=None): assert fd is None or path is None assert not(fd is None and path is None) try: if fd is None: stat = os.lstat(path) else: stat = os.fstat(fd) except OSError as exc: raise FUSEError(exc.errno) entry = pyfuse3.EntryAttributes() for attr in ('st_ino', 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev', 'st_size', 'st_atime_ns', 'st_mtime_ns', 'st_ctime_ns'): setattr(entry, attr, getattr(stat, attr)) entry.generation = 0 entry.entry_timeout = 0 entry.attr_timeout = 0 entry.st_blksize = 512 entry.st_blocks = ((entry.st_size+entry.st_blksize-1) // entry.st_blksize) return entry async def readlink(self, inode, ctx): path = self._inode_to_path(inode) try: target = os.readlink(path) except OSError as exc: raise FUSEError(exc.errno) return fsencode(target) async def opendir(self, inode, ctx): return inode async def readdir(self, inode, off, token): path = self._inode_to_path(inode) log.debug('reading %s', path) entries = [] for name in os.listdir(path): if name == '.' or name == '..': continue attr = self._getattr(path=os.path.join(path, name)) entries.append((attr.st_ino, name, attr)) log.debug('read %d entries, starting at %d', len(entries), off) # This is not fully posix compatible. If there are hardlinks # (two names with the same inode), we don't have a unique # offset to start in between them. Note that we cannot simply # count entries, because then we would skip over entries # (or return them more than once) if the number of directory # entries changes between two calls to readdir(). for (ino, name, attr) in sorted(entries): if ino <= off: continue if not pyfuse3.readdir_reply( token, fsencode(name), attr, ino): break self._add_path(attr.st_ino, os.path.join(path, name)) async def unlink(self, inode_p, name, ctx): name = fsdecode(name) parent = self._inode_to_path(inode_p) path = os.path.join(parent, name) try: inode = os.lstat(path).st_ino os.unlink(path) except OSError as exc: raise FUSEError(exc.errno) if inode in self._lookup_cnt: self._forget_path(inode, path) async def rmdir(self, inode_p, name, ctx): name = fsdecode(name) parent = self._inode_to_path(inode_p) path = os.path.join(parent, name) try: inode = os.lstat(path).st_ino os.rmdir(path) except OSError as exc: raise FUSEError(exc.errno) if inode in self._lookup_cnt: self._forget_path(inode, path) def _forget_path(self, inode, path): log.debug('forget %s for %d', path, inode) val = self._inode_path_map[inode] if isinstance(val, set): val.remove(path) if len(val) == 1: self._inode_path_map[inode] = next(iter(val)) else: del self._inode_path_map[inode] async def symlink(self, inode_p, name, target, ctx): name = fsdecode(name) target = fsdecode(target) parent = self._inode_to_path(inode_p) path = os.path.join(parent, name) try: os.symlink(target, path) os.chown(path, ctx.uid, ctx.gid, follow_symlinks=False) except OSError as exc: raise FUSEError(exc.errno) stat = os.lstat(path) self._add_path(stat.st_ino, path) return await self.getattr(stat.st_ino) async def rename(self, inode_p_old, name_old, inode_p_new, name_new, flags, ctx): if flags != 0: raise FUSEError(errno.EINVAL) name_old = fsdecode(name_old) name_new = fsdecode(name_new) parent_old = self._inode_to_path(inode_p_old) parent_new = self._inode_to_path(inode_p_new) path_old = os.path.join(parent_old, name_old) path_new = os.path.join(parent_new, name_new) try: os.rename(path_old, path_new) inode = os.lstat(path_new).st_ino except OSError as exc: raise FUSEError(exc.errno) if inode not in self._lookup_cnt: return val = self._inode_path_map[inode] if isinstance(val, set): assert len(val) > 1 val.add(path_new) val.remove(path_old) else: assert val == path_old self._inode_path_map[inode] = path_new async def link(self, inode, new_inode_p, new_name, ctx): new_name = fsdecode(new_name) parent = self._inode_to_path(new_inode_p) path = os.path.join(parent, new_name) try: os.link(self._inode_to_path(inode), path, follow_symlinks=False) except OSError as exc: raise FUSEError(exc.errno) self._add_path(inode, path) return await self.getattr(inode) async def setattr(self, inode, attr, fields, fh, ctx): # We use the f* functions if possible so that we can handle # a setattr() call for an inode without associated directory # handle. if fh is None: path_or_fh = self._inode_to_path(inode) truncate = os.truncate chmod = os.chmod chown = os.chown stat = os.lstat else: path_or_fh = fh truncate = os.ftruncate chmod = os.fchmod chown = os.fchown stat = os.fstat try: if fields.update_size: truncate(path_or_fh, attr.st_size) if fields.update_mode: # Under Linux, chmod always resolves symlinks so we should # actually never get a setattr() request for a symbolic # link. assert not stat_m.S_ISLNK(attr.st_mode) chmod(path_or_fh, stat_m.S_IMODE(attr.st_mode)) if fields.update_uid: chown(path_or_fh, attr.st_uid, -1, follow_symlinks=False) if fields.update_gid: chown(path_or_fh, -1, attr.st_gid, follow_symlinks=False) if fields.update_atime and fields.update_mtime: if fh is None: os.utime(path_or_fh, None, follow_symlinks=False, ns=(attr.st_atime_ns, attr.st_mtime_ns)) else: os.utime(path_or_fh, None, ns=(attr.st_atime_ns, attr.st_mtime_ns)) elif fields.update_atime or fields.update_mtime: # We can only set both values, so we first need to retrieve the # one that we shouldn't be changing. oldstat = stat(path_or_fh) if not fields.update_atime: attr.st_atime_ns = oldstat.st_atime_ns else: attr.st_mtime_ns = oldstat.st_mtime_ns if fh is None: os.utime(path_or_fh, None, follow_symlinks=False, ns=(attr.st_atime_ns, attr.st_mtime_ns)) else: os.utime(path_or_fh, None, ns=(attr.st_atime_ns, attr.st_mtime_ns)) except OSError as exc: raise FUSEError(exc.errno) return await self.getattr(inode) async def mknod(self, inode_p, name, mode, rdev, ctx): path = os.path.join(self._inode_to_path(inode_p), fsdecode(name)) try: os.mknod(path, mode=(mode & ~ctx.umask), device=rdev) os.chown(path, ctx.uid, ctx.gid) except OSError as exc: raise FUSEError(exc.errno) attr = self._getattr(path=path) self._add_path(attr.st_ino, path) return attr async def mkdir(self, inode_p, name, mode, ctx): path = os.path.join(self._inode_to_path(inode_p), fsdecode(name)) try: os.mkdir(path, mode=(mode & ~ctx.umask)) os.chown(path, ctx.uid, ctx.gid) except OSError as exc: raise FUSEError(exc.errno) attr = self._getattr(path=path) self._add_path(attr.st_ino, path) return attr async def statfs(self, ctx): root = self._inode_path_map[pyfuse3.ROOT_INODE] stat_ = pyfuse3.StatvfsData() try: statfs = os.statvfs(root) except OSError as exc: raise FUSEError(exc.errno) for attr in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', 'f_bavail', 'f_files', 'f_ffree', 'f_favail'): setattr(stat_, attr, getattr(statfs, attr)) stat_.f_namemax = statfs.f_namemax - (len(root)+1) return stat_ async def open(self, inode, flags, ctx): if inode in self._inode_fd_map: fd = self._inode_fd_map[inode] self._fd_open_count[fd] += 1 return pyfuse3.FileInfo(fh=fd) assert flags & os.O_CREAT == 0 try: fd = os.open(self._inode_to_path(inode), flags) except OSError as exc: raise FUSEError(exc.errno) self._inode_fd_map[inode] = fd self._fd_inode_map[fd] = inode self._fd_open_count[fd] = 1 return pyfuse3.FileInfo(fh=fd) async def create(self, inode_p, name, mode, flags, ctx): path = os.path.join(self._inode_to_path(inode_p), fsdecode(name)) try: fd = os.open(path, flags | os.O_CREAT | os.O_TRUNC) except OSError as exc: raise FUSEError(exc.errno) attr = self._getattr(fd=fd) self._add_path(attr.st_ino, path) self._inode_fd_map[attr.st_ino] = fd self._fd_inode_map[fd] = attr.st_ino self._fd_open_count[fd] = 1 return (pyfuse3.FileInfo(fh=fd), attr) async def read(self, fd, offset, length): os.lseek(fd, offset, os.SEEK_SET) return os.read(fd, length) async def write(self, fd, offset, buf): os.lseek(fd, offset, os.SEEK_SET) return os.write(fd, buf) async def release(self, fd): if self._fd_open_count[fd] > 1: self._fd_open_count[fd] -= 1 return del self._fd_open_count[fd] inode = self._fd_inode_map[fd] del self._inode_fd_map[inode] del self._fd_inode_map[fd] try: os.close(fd) except OSError as exc: raise FUSEError(exc.errno) def init_logging(debug=False): formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: ' '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S") handler = logging.StreamHandler() handler.setFormatter(formatter) root_logger = logging.getLogger() if debug: handler.setLevel(logging.DEBUG) root_logger.setLevel(logging.DEBUG) else: handler.setLevel(logging.INFO) root_logger.setLevel(logging.INFO) root_logger.addHandler(handler) def parse_args(args): '''Parse command line''' parser = ArgumentParser() parser.add_argument('source', type=str, help='Directory tree to mirror') parser.add_argument('mountpoint', type=str, help='Where to mount the file system') parser.add_argument('--debug', action='store_true', default=False, help='Enable debugging output') parser.add_argument('--debug-fuse', action='store_true', default=False, help='Enable FUSE debugging output') return parser.parse_args(args) def main(): options = parse_args(sys.argv[1:]) init_logging(options.debug) operations = Operations(options.source) log.debug('Mounting...') fuse_options = set(pyfuse3.default_options) fuse_options.add('fsname=passthroughfs') if options.debug_fuse: fuse_options.add('debug') pyfuse3.init(operations, options.mountpoint, fuse_options) try: log.debug('Entering main loop..') trio.run(pyfuse3.main) except: pyfuse3.close(unmount=False) raise log.debug('Unmounting..') pyfuse3.close() if __name__ == '__main__': main() pyfuse3-3.2.0/examples/tmpfs.py0000775000175000017500000004032413655322035020131 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' tmpfs.py - Example file system for pyfuse3. This file system stores all data in memory. Copyright © 2013 Nikolaus Rath 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. 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. ''' import os import sys # If we are running from the pyfuse3 source directory, try # to load the module from there first. basedir = os.path.abspath(os.path.join(os.path.dirname(sys.argv[0]), '..')) if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'pyfuse3.pyx'))): sys.path.insert(0, os.path.join(basedir, 'src')) import pyfuse3 import errno import stat from time import time import sqlite3 import logging from collections import defaultdict from pyfuse3 import FUSEError from argparse import ArgumentParser import trio try: import faulthandler except ImportError: pass else: faulthandler.enable() log = logging.getLogger() class Operations(pyfuse3.Operations): '''An example filesystem that stores all data in memory This is a very simple implementation with terrible performance. Don't try to store significant amounts of data. Also, there are some other flaws that have not been fixed to keep the code easier to understand: * atime, mtime and ctime are not updated * generation numbers are not supported * lookup counts are not maintained ''' enable_writeback_cache = True def __init__(self): super(Operations, self).__init__() self.db = sqlite3.connect(':memory:') self.db.text_factory = str self.db.row_factory = sqlite3.Row self.cursor = self.db.cursor() self.inode_open_count = defaultdict(int) self.init_tables() def init_tables(self): '''Initialize file system tables''' self.cursor.execute(""" CREATE TABLE inodes ( id INTEGER PRIMARY KEY, uid INT NOT NULL, gid INT NOT NULL, mode INT NOT NULL, mtime_ns INT NOT NULL, atime_ns INT NOT NULL, ctime_ns INT NOT NULL, target BLOB(256) , size INT NOT NULL DEFAULT 0, rdev INT NOT NULL DEFAULT 0, data BLOB ) """) self.cursor.execute(""" CREATE TABLE contents ( rowid INTEGER PRIMARY KEY AUTOINCREMENT, name BLOB(256) NOT NULL, inode INT NOT NULL REFERENCES inodes(id), parent_inode INT NOT NULL REFERENCES inodes(id), UNIQUE (name, parent_inode) )""") # Insert root directory now_ns = int(time() * 1e9) self.cursor.execute("INSERT INTO inodes (id,mode,uid,gid,mtime_ns,atime_ns,ctime_ns) " "VALUES (?,?,?,?,?,?,?)", (pyfuse3.ROOT_INODE, stat.S_IFDIR | stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH, os.getuid(), os.getgid(), now_ns, now_ns, now_ns)) self.cursor.execute("INSERT INTO contents (name, parent_inode, inode) VALUES (?,?,?)", (b'..', pyfuse3.ROOT_INODE, pyfuse3.ROOT_INODE)) def get_row(self, *a, **kw): self.cursor.execute(*a, **kw) try: row = next(self.cursor) except StopIteration: raise NoSuchRowError() try: next(self.cursor) except StopIteration: pass else: raise NoUniqueValueError() return row async def lookup(self, inode_p, name, ctx=None): if name == '.': inode = inode_p elif name == '..': inode = self.get_row("SELECT * FROM contents WHERE inode=?", (inode_p,))['parent_inode'] else: try: inode = self.get_row("SELECT * FROM contents WHERE name=? AND parent_inode=?", (name, inode_p))['inode'] except NoSuchRowError: raise(pyfuse3.FUSEError(errno.ENOENT)) return await self.getattr(inode, ctx) async def getattr(self, inode, ctx=None): row = self.get_row('SELECT * FROM inodes WHERE id=?', (inode,)) entry = pyfuse3.EntryAttributes() entry.st_ino = inode entry.generation = 0 entry.entry_timeout = 300 entry.attr_timeout = 300 entry.st_mode = row['mode'] entry.st_nlink = self.get_row("SELECT COUNT(inode) FROM contents WHERE inode=?", (inode,))[0] entry.st_uid = row['uid'] entry.st_gid = row['gid'] entry.st_rdev = row['rdev'] entry.st_size = row['size'] entry.st_blksize = 512 entry.st_blocks = 1 entry.st_atime_ns = row['atime_ns'] entry.st_mtime_ns = row['mtime_ns'] entry.st_ctime_ns = row['ctime_ns'] return entry async def readlink(self, inode, ctx): return self.get_row('SELECT * FROM inodes WHERE id=?', (inode,))['target'] async def opendir(self, inode, ctx): return inode async def readdir(self, inode, off, token): if off == 0: off = -1 cursor2 = self.db.cursor() cursor2.execute("SELECT * FROM contents WHERE parent_inode=? " 'AND rowid > ? ORDER BY rowid', (inode, off)) for row in cursor2: pyfuse3.readdir_reply( token, row['name'], await self.getattr(row['inode']), row['rowid']) async def unlink(self, inode_p, name,ctx): entry = await self.lookup(inode_p, name) if stat.S_ISDIR(entry.st_mode): raise pyfuse3.FUSEError(errno.EISDIR) self._remove(inode_p, name, entry) async def rmdir(self, inode_p, name, ctx): entry = await self.lookup(inode_p, name) if not stat.S_ISDIR(entry.st_mode): raise pyfuse3.FUSEError(errno.ENOTDIR) self._remove(inode_p, name, entry) def _remove(self, inode_p, name, entry): if self.get_row("SELECT COUNT(inode) FROM contents WHERE parent_inode=?", (entry.st_ino,))[0] > 0: raise pyfuse3.FUSEError(errno.ENOTEMPTY) self.cursor.execute("DELETE FROM contents WHERE name=? AND parent_inode=?", (name, inode_p)) if entry.st_nlink == 1 and entry.st_ino not in self.inode_open_count: self.cursor.execute("DELETE FROM inodes WHERE id=?", (entry.st_ino,)) async def symlink(self, inode_p, name, target, ctx): mode = (stat.S_IFLNK | stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IWOTH | stat.S_IXOTH) return await self._create(inode_p, name, mode, ctx, target=target) async def rename(self, inode_p_old, name_old, inode_p_new, name_new, flags, ctx): if flags != 0: raise FUSEError(errno.EINVAL) entry_old = await self.lookup(inode_p_old, name_old) try: entry_new = await self.lookup(inode_p_new, name_new) except pyfuse3.FUSEError as exc: if exc.errno != errno.ENOENT: raise target_exists = False else: target_exists = True if target_exists: self._replace(inode_p_old, name_old, inode_p_new, name_new, entry_old, entry_new) else: self.cursor.execute("UPDATE contents SET name=?, parent_inode=? WHERE name=? " "AND parent_inode=?", (name_new, inode_p_new, name_old, inode_p_old)) def _replace(self, inode_p_old, name_old, inode_p_new, name_new, entry_old, entry_new): if self.get_row("SELECT COUNT(inode) FROM contents WHERE parent_inode=?", (entry_new.st_ino,))[0] > 0: raise pyfuse3.FUSEError(errno.ENOTEMPTY) self.cursor.execute("UPDATE contents SET inode=? WHERE name=? AND parent_inode=?", (entry_old.st_ino, name_new, inode_p_new)) self.db.execute('DELETE FROM contents WHERE name=? AND parent_inode=?', (name_old, inode_p_old)) if entry_new.st_nlink == 1 and entry_new.st_ino not in self.inode_open_count: self.cursor.execute("DELETE FROM inodes WHERE id=?", (entry_new.st_ino,)) async def link(self, inode, new_inode_p, new_name, ctx): entry_p = await self.getattr(new_inode_p) if entry_p.st_nlink == 0: log.warn('Attempted to create entry %s with unlinked parent %d', new_name, new_inode_p) raise FUSEError(errno.EINVAL) self.cursor.execute("INSERT INTO contents (name, inode, parent_inode) VALUES(?,?,?)", (new_name, inode, new_inode_p)) return await self.getattr(inode) async def setattr(self, inode, attr, fields, fh, ctx): if fields.update_size: data = self.get_row('SELECT data FROM inodes WHERE id=?', (inode,))[0] if data is None: data = b'' if len(data) < attr.st_size: data = data + b'\0' * (attr.st_size - len(data)) else: data = data[:attr.st_size] self.cursor.execute('UPDATE inodes SET data=?, size=? WHERE id=?', (memoryview(data), attr.st_size, inode)) if fields.update_mode: self.cursor.execute('UPDATE inodes SET mode=? WHERE id=?', (attr.st_mode, inode)) if fields.update_uid: self.cursor.execute('UPDATE inodes SET uid=? WHERE id=?', (attr.st_uid, inode)) if fields.update_gid: self.cursor.execute('UPDATE inodes SET gid=? WHERE id=?', (attr.st_gid, inode)) if fields.update_atime: self.cursor.execute('UPDATE inodes SET atime_ns=? WHERE id=?', (attr.st_atime_ns, inode)) if fields.update_mtime: self.cursor.execute('UPDATE inodes SET mtime_ns=? WHERE id=?', (attr.st_mtime_ns, inode)) if fields.update_ctime: self.cursor.execute('UPDATE inodes SET ctime_ns=? WHERE id=?', (attr.st_ctime_ns, inode)) else: self.cursor.execute('UPDATE inodes SET ctime_ns=? WHERE id=?', (int(time()*1e9), inode)) return await self.getattr(inode) async def mknod(self, inode_p, name, mode, rdev, ctx): return await self._create(inode_p, name, mode, ctx, rdev=rdev) async def mkdir(self, inode_p, name, mode, ctx): return await self._create(inode_p, name, mode, ctx) async def statfs(self, ctx): stat_ = pyfuse3.StatvfsData() stat_.f_bsize = 512 stat_.f_frsize = 512 size = self.get_row('SELECT SUM(size) FROM inodes')[0] stat_.f_blocks = size // stat_.f_frsize stat_.f_bfree = max(size // stat_.f_frsize, 1024) stat_.f_bavail = stat_.f_bfree inodes = self.get_row('SELECT COUNT(id) FROM inodes')[0] stat_.f_files = inodes stat_.f_ffree = max(inodes , 100) stat_.f_favail = stat_.f_ffree return stat_ async def open(self, inode, flags, ctx): # Yeah, unused arguments #pylint: disable=W0613 self.inode_open_count[inode] += 1 # Use inodes as a file handles return pyfuse3.FileInfo(fh=inode) async def access(self, inode, mode, ctx): # Yeah, could be a function and has unused arguments #pylint: disable=R0201,W0613 return True async def create(self, inode_parent, name, mode, flags, ctx): #pylint: disable=W0612 entry = await self._create(inode_parent, name, mode, ctx) self.inode_open_count[entry.st_ino] += 1 return (pyfuse3.FileInfo(fh=entry.st_ino), entry) async def _create(self, inode_p, name, mode, ctx, rdev=0, target=None): if (await self.getattr(inode_p)).st_nlink == 0: log.warn('Attempted to create entry %s with unlinked parent %d', name, inode_p) raise FUSEError(errno.EINVAL) now_ns = int(time() * 1e9) self.cursor.execute('INSERT INTO inodes (uid, gid, mode, mtime_ns, atime_ns, ' 'ctime_ns, target, rdev) VALUES(?, ?, ?, ?, ?, ?, ?, ?)', (ctx.uid, ctx.gid, mode, now_ns, now_ns, now_ns, target, rdev)) inode = self.cursor.lastrowid self.db.execute("INSERT INTO contents(name, inode, parent_inode) VALUES(?,?,?)", (name, inode, inode_p)) return await self.getattr(inode) async def read(self, fh, offset, length): data = self.get_row('SELECT data FROM inodes WHERE id=?', (fh,))[0] if data is None: data = b'' return data[offset:offset+length] async def write(self, fh, offset, buf): data = self.get_row('SELECT data FROM inodes WHERE id=?', (fh,))[0] if data is None: data = b'' data = data[:offset] + buf + data[offset+len(buf):] self.cursor.execute('UPDATE inodes SET data=?, size=? WHERE id=?', (memoryview(data), len(data), fh)) return len(buf) async def release(self, fh): self.inode_open_count[fh] -= 1 if self.inode_open_count[fh] == 0: del self.inode_open_count[fh] if (await self.getattr(fh)).st_nlink == 0: self.cursor.execute("DELETE FROM inodes WHERE id=?", (fh,)) class NoUniqueValueError(Exception): def __str__(self): return 'Query generated more than 1 result row' class NoSuchRowError(Exception): def __str__(self): return 'Query produced 0 result rows' def init_logging(debug=False): formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s: ' '[%(name)s] %(message)s', datefmt="%Y-%m-%d %H:%M:%S") handler = logging.StreamHandler() handler.setFormatter(formatter) root_logger = logging.getLogger() if debug: handler.setLevel(logging.DEBUG) root_logger.setLevel(logging.DEBUG) else: handler.setLevel(logging.INFO) root_logger.setLevel(logging.INFO) root_logger.addHandler(handler) def parse_args(): '''Parse command line''' parser = ArgumentParser() parser.add_argument('mountpoint', type=str, help='Where to mount the file system') parser.add_argument('--debug', action='store_true', default=False, help='Enable debugging output') parser.add_argument('--debug-fuse', action='store_true', default=False, help='Enable FUSE debugging output') return parser.parse_args() if __name__ == '__main__': options = parse_args() init_logging(options.debug) operations = Operations() fuse_options = set(pyfuse3.default_options) fuse_options.add('fsname=tmpfs') fuse_options.discard('default_permissions') if options.debug_fuse: fuse_options.add('debug') pyfuse3.init(operations, options.mountpoint, fuse_options) try: trio.run(pyfuse3.main) except: pyfuse3.close(unmount=False) raise pyfuse3.close() pyfuse3-3.2.0/rst/0000775000175000017500000000000013773156367015430 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/rst/_static/0000775000175000017500000000000013773156367017056 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/rst/_static/.placeholder0000664000175000017500000000000013347452777021330 0ustar nikrationikratio00000000000000pyfuse3-3.2.0/rst/_templates/0000775000175000017500000000000013773156367017565 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/rst/_templates/localtoc.html0000664000175000017500000000013513347452777022253 0ustar nikrationikratio00000000000000

{{ _('Table Of Contents') }}

{{ toctree() }} pyfuse3-3.2.0/rst/about.rst0000664000175000017500000000012013347452777017266 0ustar nikrationikratio00000000000000======= About ======= .. include:: ../README.rst :start-after: start-intro pyfuse3-3.2.0/rst/asyncio.rst0000664000175000017500000000074513403544526017621 0ustar nikrationikratio00000000000000.. _asyncio: ================= asyncio Support ================= By default, pyfuse3 uses asynchronous I/O using Trio_ (and most of the documentation assumes that you are using Trio). If you'd rather use asyncio, import the *pyfuse3_asyncio* module and call its *enable()* function before using *pyfuse3*. For example:: import pyfuse3 import pyfuse3_asyncio pyfuse3_asyncio.enable() # Use pyfuse3 as usual from here on. .. _Trio: https://github.com/python-trio/trio pyfuse3-3.2.0/rst/changes.rst0000664000175000017500000000003413347452777017570 0ustar nikrationikratio00000000000000.. include:: ../Changes.rst pyfuse3-3.2.0/rst/conf.py0000664000175000017500000001517313772375711016731 0ustar nikrationikratio00000000000000# -*- coding: utf-8 -*- # # pyfuse3 documentation build configuration file, created by # sphinx-quickstart on Sat Oct 16 14:14:40 2010. # # This file is execfile()d with the current directory set to its containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. #sys.path.append(os.path.abspath('.')) #pylint: disable-all #@PydevCodeAnalysisIgnore # -- General configuration ----------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be extensions # coming with Sphinx (named 'sphinx.ext.*') or your custom ones. extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx_cython', 'sphinxcontrib.asyncio' ] # Link to Python standard library intersphinx_mapping = {'python': ('https://docs.python.org/3/', None), 'trio': ('https://trio.readthedocs.io/en/stable/', None),} # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix of source filenames. source_suffix = '.rst' autodoc_docstring_signature = True # The encoding of source files. source_encoding = 'utf-8' # The master toctree document. master_doc = 'index' # Warn about unresolved references nitpicky = True # General information about the project. project = u'pyfuse3' copyright = u'2010-2015, Nikolaus Rath' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '1.0' # The full version, including alpha/beta/rc tags. release = '1.0' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. #language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: #today = '' # Else, today_fmt is used as the format for a strftime call. #today_fmt = '%B %d, %Y' # List of documents that shouldn't be included in the build. unused_docs = [ ] # List of directories, relative to source directory, that shouldn't be searched # for source files. exclude_trees = [] # The reST default role (used for this markup: `text`) to use for all documents. default_role = 'py:obj' primary_domain = 'py' # If true, '()' will be appended to :func: etc. cross-reference text. add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' #pygments_style = 'colorful' highlight_language = 'python' # A list of ignored prefixes for module index sorting. #modindex_common_prefix = [] # -- Options for HTML output --------------------------------------------------- # The theme to use for HTML and HTML Help pages. Major themes that come with # Sphinx are currently 'default' and 'sphinxdoc'. html_theme = 'default' # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. #html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. #html_theme_path = [] # The name for this set of Sphinx documents. If None, it defaults to # " v documentation". #html_title = None # A shorter title for the navigation bar. Default is the same as html_title. #html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. #html_logo = None # The name of an image file (within the static path) to use as favicon of the # docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. #html_favicon = None # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # If not '', a 'Last updated on:' timestamp is inserted at every page bottom, # using the given strftime format. #html_last_updated_fmt = '%b %d, %Y' # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. #html_use_smartypants = True # Custom sidebar templates, maps document names to template names. #html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. #html_additional_pages = {} # If false, no module index is generated. html_use_modindex = False # If false, no index is generated. html_use_index = True # If true, the index is split into individual pages for each letter. html_split_index = False # If true, links to the reST sources are added to the pages. html_show_sourcelink = False # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. #html_use_opensearch = '' # If nonempty, this is the file name suffix for HTML files (e.g. ".xhtml"). #html_file_suffix = '' # Output file base name for HTML help builder. htmlhelp_basename = 'pyfuse3doc' # -- Options for LaTeX output -------------------------------------------------- # The paper size ('letter' or 'a4'). #latex_paper_size = 'letter' # The font size ('10pt', '11pt' or '12pt'). #latex_font_size = '10pt' # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, author, documentclass [howto/manual]). latex_documents = [ ('index', 'pyfuse3.tex', u'pyfuse3 Documentation', u'Nikolaus Rath', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. #latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. #latex_use_parts = False # Additional stuff for the LaTeX preamble. #latex_preamble = '' # Documents to append as an appendix to all manuals. #latex_appendices = [] # If false, no module index is generated. #latex_use_modindex = True pyfuse3-3.2.0/rst/data.rst0000664000175000017500000000756113636701554017074 0ustar nikrationikratio00000000000000================= Data Structures ================= .. currentmodule:: pyfuse3 .. py:data:: ENOATTR This errorcode is unfortunately missing in the `errno` module, so it is provided by pyfuse3 instead. .. py:data:: ROOT_INODE The inode of the root directory, i.e. the mount point of the file system. .. py:data:: RENAME_EXCHANGE A flag that may be passed to the `~Operations.rename` handler. When passed, the handler must atomically exchange the two paths (which must both exist). .. py:data:: RENAME_NOREPLACE A flag that may be passed to the `~Operations.rename` handler. When passed, the handler must not replace an existing target. .. py:data:: default_options This is a recommended set of options that should be passed to `pyfuse3.init` to get reasonable behavior and performance. pyfuse3 is compatible with any other combination of options as well, but you should only deviate from the defaults with good reason. (The :samp:`fsname=` option is guaranteed never to be included in the default options, so you can always safely add it to the set). The default options are: * ``default_permissions`` enables permission checking by kernel. Without this any umask (or uid/gid) would not have an effect. .. autoexception:: FUSEError .. autoclass:: RequestContext .. attribute:: pid .. attribute:: uid .. attribute:: gid .. attribute:: umask .. autoclass:: StatvfsData .. attribute:: f_bsize .. attribute:: f_frsize .. attribute:: f_blocks .. attribute:: f_bfree .. attribute:: f_bavail .. attribute:: f_files .. attribute:: f_ffree .. attribute:: f_favail .. attribute:: f_namemax .. autoclass:: EntryAttributes .. autoattribute:: st_ino .. autoattribute:: generation .. autoattribute:: entry_timeout .. autoattribute:: attr_timeout .. autoattribute:: st_mode .. autoattribute:: st_nlink .. autoattribute:: st_uid .. autoattribute:: st_gid .. autoattribute:: st_rdev .. autoattribute:: st_size .. autoattribute:: st_blksize .. autoattribute:: st_blocks .. autoattribute:: st_atime_ns .. autoattribute:: st_ctime_ns .. autoattribute:: st_mtime_ns .. autoclass:: FileInfo .. autoattribute:: fh This attribute must be set to the file handle to be returned from `Operations.open`. .. autoattribute:: direct_io If true, signals to the kernel that this file should not be cached or buffered. .. autoattribute:: keep_cache If true, signals to the kernel that previously cached data for this inode is still valid, and should not be invalidated. .. autoattribute:: nonseekable If true, indicates that the file does not support seeking. .. autoclass:: SetattrFields .. attribute:: update_atime If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_atime_ns` field contains an updated value. .. attribute:: update_mtime If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_mtime_ns` field contains an updated value. .. attribute:: update_mode If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_mode` field contains an updated value. .. attribute:: update_uid If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_uid` field contains an updated value. .. attribute:: update_gid If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_gid` field contains an updated value. .. attribute:: update_size If this attribute is true, it signals the `Operations.setattr` method that the `~EntryAttributes.st_size` field contains an updated value. pyfuse3-3.2.0/rst/example.rst0000664000175000017500000000145113403544476017606 0ustar nikrationikratio00000000000000.. _example file system: ====================== Example File Systems ====================== pyfuse3 comes with several example file systems in the :file:`examples` directory of the release tarball. For completeness, these examples are also included here. Single-file, Read-only File System ================================== (shipped as :file:`examples/lltest.py`) .. literalinclude:: ../examples/hello.py :linenos: :language: python In-memory File System ===================== (shipped as :file:`examples/tmpfs.py`) .. literalinclude:: ../examples/tmpfs.py :linenos: :language: python Passthrough / Overlay File System ================================= (shipped as :file:`examples/passthroughfs.py`) .. literalinclude:: ../examples/passthroughfs.py :linenos: :language: python pyfuse3-3.2.0/rst/fuse_api.rst0000664000175000017500000000110713772376363017753 0ustar nikrationikratio00000000000000==================== FUSE API Functions ==================== .. currentmodule:: pyfuse3 .. autofunction:: init .. autocofunction:: main .. autofunction:: terminate .. autofunction:: close .. autofunction:: invalidate_inode .. autofunction:: invalidate_entry .. autofunction:: invalidate_entry_async .. autofunction:: notify_store .. autofunction:: readdir_reply .. py:data:: trio_token Set to the value returned by `trio.lowlevel.current_trio_token()` while `main()` is running. Can be used by other threads to run code in the main loop through `trio.from_thread.run`. pyfuse3-3.2.0/rst/general.rst0000664000175000017500000000717613403544474017600 0ustar nikrationikratio00000000000000===================== General Information ===================== .. currentmodule:: pyfuse3 .. _getting_started: Getting started =============== A file system is implemented by subclassing the `pyfuse3.Operations` class and implementing the various request handlers. The handlers respond to requests received from the FUSE kernel module and perform functions like looking up the inode given a file name, looking up attributes of an inode, opening a (file) inode for reading or writing or listing the contents of a (directory) inode. By default, pyfuse3 uses asynchronous I/O using Trio_, and most of the documentation assumes that you are using Trio. If you'd rather use asyncio, take a look at :ref:`asyncio Support `. If you would like to use Trio (which is recommended) but you have not yet used Trio before, please read the `Trio tutorial`_ first. An instance of the operations class is passed to `pyfuse3.init` to mount the file system. To enter the request handling loop, run `pyfuse3.main` in a trio event loop. This function will return when the file system should be unmounted again, which is done by calling `pyfuse3.close`. All character data (directory entry names, extended attribute names and values, symbolic link targets etc) are passed as `bytes` and must be returned as `bytes`. For easier debugging, it is strongly recommended that applications using pyfuse3 also make use of the faulthandler_ module. .. _faulthandler: http://docs.python.org/3/library/faulthandler.html .. _Trio tutorial: https://trio.readthedocs.io/en/latest/tutorial.html .. _Trio: https://github.com/python-trio/trio Lookup Counts ============= Most file systems need to keep track which inodes are currently known to the kernel. This is, for example, necessary to correctly implement the *unlink* system call: when unlinking a directory entry whose associated inode is currently opened, the file system must defer removal of the inode (and thus the file contents) until it is no longer in use by any process. FUSE file systems achieve this by using "lookup counts". A lookup count is a number that's associated with an inode. An inode with a lookup count of zero is currently not known to the kernel. This means that if there are no directory entries referring to such an inode it can be safely removed, or (if a file system implements dynamic inode numbers), the inode number can be safely recycled. The lookup count of an inode is increased by every operation that could make the inode "known" to the kernel. This includes e.g. `~Operations.lookup`, `~Operations.create` and `~Operations.readdir` (to determine if a given request handler affects the lookup count, please refer to its description in the `Operations` class). The lookup count is decreased by calls to the `~Operations.forget` handler. FUSE and VFS Locking ==================== FUSE and the kernel's VFS layer provide some basic locking that FUSE file systems automatically take advantage of. Specifically: * Calls to `~Operations.rename`, `~Operations.create`, `~Operations.symlink`, `~Operations.mknod`, `~Operations.link` and `~Operations.mkdir` acquire a write-lock on the inode of the directory in which the respective operation takes place (two in case of rename). * Calls to `~Operations.lookup` acquire a read-lock on the inode of the parent directory (meaning that lookups in the same directory may run concurrently, but never at the same time as e.g. a rename or mkdir operation). * Unless writeback caching is enabled, calls to `~Operations.write` for the same inode are automatically serialized (i.e., there are never concurrent calls for the same inode even when multithreading is enabled). pyfuse3-3.2.0/rst/gotchas.rst0000664000175000017500000000154513347530014017575 0ustar nikrationikratio00000000000000================ Common Gotchas ================ .. currentmodule:: pyfuse3 This chapter lists some common gotchas that should be avoided. Removing inodes in unlink handler ================================= If your file system is mounted at :file:`mnt`, the following code should complete without errors:: with open('mnt/file_one', 'w+') as fh1: fh1.write('foo') fh1.flush() with open('mnt/file_one', 'a') as fh2: os.unlink('mnt/file_one') assert 'file_one' not in os.listdir('mnt') fh2.write('bar') os.close(os.dup(fh1.fileno())) fh1.seek(0) assert fh1.read() == 'foobar' If you're getting an error, then you probably did a mistake when implementing the `~Operations.unlink` handler and are removing the file contents when you should be deferring removal to the `~Operations.forget` handler. pyfuse3-3.2.0/rst/index.rst0000664000175000017500000000062713403544112017251 0ustar nikrationikratio00000000000000============================= pyfuse3 Documentation ============================= Table of Contents ----------------- .. module:: pyfuse3 .. toctree:: :maxdepth: 1 about.rst install.rst general.rst asyncio.rst fuse_api.rst data.rst operations.rst util.rst gotchas.rst example.rst changes.rst Indices and tables ------------------ * :ref:`genindex` * :ref:`search` pyfuse3-3.2.0/rst/install.rst0000664000175000017500000000426213350426565017623 0ustar nikrationikratio00000000000000============== Installation ============== .. highlight:: sh Dependencies ============ In order to build and run pyfuse3 you need the following software: * Linux kernel 3.9 or newer. * Version 3.3.0 or newer of the libfuse_ library, including development headers (typically distributions provide them in a *libfuse3-devel* or *libfuse3-dev* package). * Python_ 3.5 or newer installed with development headers * The Trio_ Python module, version 0.7 or newer. * The `setuptools`_ Python module, version 1.0 or newer. * the `pkg-config`_ tool * the `attr`_ library * A C compiler (only for building) To run the unit tests, you will need * The `py.test`_ Python module, version 3.3.0 or newer Stable releases =============== To install a stable pyfuse3 release: 1. Download and unpack the release tarball from https://pypi.python.org/pypi/pyfuse3/ 2. Run ``python3 setup.py build_ext --inplace`` to build the C extension 3. Run ``python3 -m pytest test/`` to run a self-test. If this fails, ask for help on the `FUSE mailing list`_ or report a bug in the `issue tracker `_. 4. To install system-wide for all users, run ``sudo python setup.py install``. To install into :file:`~/.local`, run ``python3 setup.py install --user``. Development Version =================== If you have checked out the unstable development version, a bit more effort is required. You need to also have Cython_ (0.28.1 or newer) and Sphinx_ (1.1 or newer) installed, and the necessary commands are:: python3 setup.py build_cython python3 setup.py build_ext --inplace python3 -m pytest test/ python3 setup.py build_sphinx python3 setup.py install .. _Cython: http://www.cython.org/ .. _Sphinx: http://sphinx.pocoo.org/ .. _Python: http://www.python.org/ .. _Trio: https://github.com/python-trio/trio .. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel .. _`py.test`: https://pypi.python.org/pypi/pytest/ .. _libfuse: http://github.com/libfuse/libfuse .. _attr: http://savannah.nongnu.org/projects/attr/ .. _`pkg-config`: http://www.freedesktop.org/wiki/Software/pkg-config .. _setuptools: https://pypi.python.org/pypi/setuptools pyfuse3-3.2.0/rst/operations.rst0000664000175000017500000000235113350426564020334 0ustar nikrationikratio00000000000000================== Request Handlers ================== (You can use the :ref:`genindex` to directly jump to a specific handler). .. currentmodule:: pyfuse3 .. autoclass:: Operations :members: .. attribute:: supports_dot_lookup = True If set, indicates that the filesystem supports lookup of the ``.`` and ``..`` entries. This is required if the file system will be shared over NFS. .. attribute:: enable_writeback_cache = True Enables write-caching in the kernel if available. This means that individual write request may be buffered and merged in the kernel before they are send to the filesystem. .. attribute:: enable_acl = False Enable ACL support. When enabled, the kernel will cache and have responsibility for enforcing ACLs. ACL will be stored as xattrs and passed to userspace, which is responsible for updating the ACLs in the filesystem, keeping the file mode in sync with the ACL, and ensuring inheritance of default ACLs when new filesystem nodes are created. Note that this requires that the file system is able to parse and interpret the xattr representation of ACLs. Enabling this feature implicitly turns on the ``default_permissions`` option. pyfuse3-3.2.0/rst/util.rst0000664000175000017500000000062713354207241017123 0ustar nikrationikratio00000000000000==================== Utility Functions ==================== The following functions do not necessarily translate to calls to the FUSE library. They are provided because they're potentially useful when implementing file systems in Python. .. currentmodule:: pyfuse3 .. autofunction:: setxattr .. autofunction:: getxattr .. autofunction:: listdir .. autofunction:: get_sup_groups .. autofunction:: syncfs pyfuse3-3.2.0/setup.cfg0000664000175000017500000000016013773156367016436 0ustar nikrationikratio00000000000000[sdist] formats = gztar [build_sphinx] source-dir = rst build-dir = doc [egg_info] tag_build = tag_date = 0 pyfuse3-3.2.0/setup.py0000775000175000017500000002257413772577363016351 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 #-*- coding: us-ascii -*- ''' setup.py Installation script for pyfuse3. Copyright (c) 2010 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' import sys import os import subprocess import warnings import re # Disable Cython support in setuptools. It fails under some conditions # (http://trac.cython.org/ticket/859), and we have our own build_cython command # anyway. try: import Cython.Distutils.build_ext except ImportError: pass else: # We can't delete Cython.Distutils.build_ext directly, # because the build_ext class (that is imported from # the build_ext module in __init__.py) shadows the # build_ext module. module = sys.modules['Cython.Distutils.build_ext'] del module.build_ext try: import setuptools except ImportError: raise SystemExit('Setuptools package not found. Please install from ' 'https://pypi.python.org/pypi/setuptools') from setuptools import Extension from distutils.version import LooseVersion # Add util to load path basedir = os.path.abspath(os.path.dirname(sys.argv[0])) sys.path.insert(0, os.path.join(basedir, 'util')) # When running from Git repo, enable all warnings DEVELOPER_MODE = os.path.exists(os.path.join(basedir, 'MANIFEST.in')) if DEVELOPER_MODE: print('found MANIFEST.in, running in developer mode') warnings.resetwarnings() # We can't use `error`, because e.g. Sphinx triggers a # DeprecationWarning. warnings.simplefilter('default') # Add src to load path, important for Sphinx autodoc # to work properly sys.path.insert(0, os.path.join(basedir, 'src')) PYFUSE3_VERSION = '3.2.0' def main(): try: from sphinx.application import Sphinx #pylint: disable-msg=W0612 except ImportError: pass else: fix_docutils() with open(os.path.join(basedir, 'README.rst'), 'r') as fh: long_desc = fh.read() compile_args = pkg_config('fuse3', cflags=True, ldflags=False, min_ver='3.2.0') compile_args += ['-DFUSE_USE_VERSION=32', '-Wall', '-Wextra', '-Wconversion', '-Wsign-compare', '-DPYFUSE3_VERSION="%s"' % PYFUSE3_VERSION] # We may have unused functions if we compile for older FUSE versions compile_args.append('-Wno-unused-function') # Nothing wrong with that if you know what you are doing # (which Cython does) compile_args.append('-Wno-implicit-fallthrough') # Due to platform specific conditions, these are unavoidable compile_args.append('-Wno-unused-function') compile_args.append('-Wno-unused-parameter') # Enable all fatal warnings only in developer mode. # (otherwise we break forward compatibility because compilation with newer # compiler may fail if additional warnings are added) if DEVELOPER_MODE: compile_args.append('-Werror') compile_args.append('-Wfatal-errors') # Unreachable code is expected because we need to support multiple # platforms and architectures. compile_args.append('-Wno-error=unreachable-code') # Value-changing conversions should always be explicit. compile_args.append('-Werror=conversion') # Note that (i > -1) is false if i is unsigned (-1 will be converted to # a large positive value). We certainly don't want to do this by # accident. compile_args.append('-Werror=sign-compare') link_args = pkg_config('fuse3', cflags=False, ldflags=True, min_ver='3.2.0') link_args.append('-lpthread') c_sources = ['src/pyfuse3.c'] if os.uname()[0] in ('Linux', 'GNU/kFreeBSD'): link_args.append('-lrt') elif os.uname()[0] == 'Darwin': c_sources.append('src/darwin_compat.c') setuptools.setup( name='pyfuse3', zip_safe=True, version=PYFUSE3_VERSION, description='Python 3 bindings for libfuse 3 with async I/O support', long_description=long_desc, author='Nikolaus Rath', author_email='Nikolaus@rath.org', url='https://github.com/libfuse/pyfuse3', license='LGPL', classifiers=['Development Status :: 4 - Beta', 'Intended Audience :: Developers', 'Programming Language :: Python', 'Topic :: Software Development :: Libraries :: Python Modules', 'Topic :: System :: Filesystems', 'License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)', 'Operating System :: POSIX :: Linux', 'Operating System :: MacOS :: MacOS X', 'Operating System :: POSIX :: BSD :: FreeBSD'], platforms=[ 'Linux' ], keywords=['FUSE', 'python' ], install_requires=['trio >= 0.15'], tests_require=['pytest >= 3.4.0', 'pytest-trio'], python_requires='>=3.5', package_dir={'': 'src'}, py_modules=['_pyfuse3', 'pyfuse3_asyncio'], provides=['pyfuse3'], ext_modules=[Extension('pyfuse3', c_sources, extra_compile_args=compile_args, extra_link_args=link_args)], cmdclass={'upload_docs': upload_docs, 'build_cython': build_cython }, command_options={ 'build_sphinx': { 'version': ('setup.py', PYFUSE3_VERSION), 'release': ('setup.py', PYFUSE3_VERSION), }}, ) def pkg_config(pkg, cflags=True, ldflags=False, min_ver=None): '''Frontend to ``pkg-config``''' if min_ver: cmd = ['pkg-config', pkg, '--atleast-version', min_ver ] if subprocess.call(cmd) != 0: cmd = ['pkg-config', '--modversion', pkg ] proc = subprocess.Popen(cmd, stdout=subprocess.PIPE) version = proc.communicate()[0].strip() if not version: raise SystemExit(2) # pkg-config generates error message already else: raise SystemExit('%s version too old (found: %s, required: %s)' % (pkg, version, min_ver)) cmd = ['pkg-config', pkg ] if cflags: cmd.append('--cflags') if ldflags: cmd.append('--libs') proc = subprocess.Popen(cmd, stdout=subprocess.PIPE) cflags = proc.stdout.readline().rstrip() proc.stdout.close() if proc.wait() != 0: raise SystemExit(2) # pkg-config generates error message already return cflags.decode('us-ascii').split() class upload_docs(setuptools.Command): user_options = [] boolean_options = [] description = "Upload documentation" def initialize_options(self): pass def finalize_options(self): pass def run(self): subprocess.check_call(['rsync', '-aHv', '--del', os.path.join(basedir, 'doc', 'html') + '/', 'ebox.rath.org:/srv/www.rath.org/pyfuse3-docs/']) class build_cython(setuptools.Command): user_options = [] boolean_options = [] description = "Compile .pyx to .c" def initialize_options(self): pass def finalize_options(self): self.extensions = self.distribution.ext_modules def run(self): cython = None for c in ('cython3', 'cython'): try: version = subprocess.check_output([c, '--version'], universal_newlines=True, stderr=subprocess.STDOUT) cython = c except FileNotFoundError: pass if cython is None: raise SystemExit('Cython needs to be installed for this command') from None hit = re.match('^Cython version (.+)$', version) if not hit or LooseVersion(hit.group(1)) < "0.24": raise SystemExit('Need Cython 0.24 or newer, found ' + version) cmd = [cython, '-Wextra', '--force', '-3', '--fast-fail', '--directive', 'embedsignature=True', '--include-dir', os.path.join(basedir, 'Include'), '--verbose' ] if DEVELOPER_MODE: cmd.append('-Werror') # Work around http://trac.cython.org/cython_trac/ticket/714 cmd += ['-X', 'warn.maybe_uninitialized=False' ] for extension in self.extensions: for file_ in extension.sources: (file_, ext) = os.path.splitext(file_) path = os.path.join(basedir, file_) if ext != '.c': continue if os.path.exists(path + '.pyx'): if subprocess.call(cmd + [path + '.pyx']) != 0: raise SystemExit('Cython compilation failed') def fix_docutils(): '''Work around https://bitbucket.org/birkenfeld/sphinx/issue/1154/''' import docutils.parsers from docutils.parsers import rst old_getclass = docutils.parsers.get_parser_class # Check if bug is there try: old_getclass('rst') except AttributeError: pass else: return def get_parser_class(parser_name): """Return the Parser class from the `parser_name` module.""" if parser_name in ('rst', 'restructuredtext'): return rst.Parser else: return old_getclass(parser_name) docutils.parsers.get_parser_class = get_parser_class assert docutils.parsers.get_parser_class('rst') is rst.Parser if __name__ == '__main__': main() pyfuse3-3.2.0/src/0000775000175000017500000000000013773156367015407 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/src/_pyfuse3.py0000664000175000017500000005175213655320761017516 0ustar nikrationikratio00000000000000''' _pyfuse3.py Pure-Python components of pyfuse3. Copyright © 2018 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' import errno import functools import logging import os # Will be injected by pyfuse3 extension module FUSEError = None __all__ = [ 'Operations', 'async_wrapper' ] log = logging.getLogger(__name__) # Any top level trio coroutines (i.e., coroutines that are passed # to trio.run) must be pure-Python. This wrapper ensures that this # is the case for Cython-defined async functions. def async_wrapper(fn): @functools.wraps(fn) async def wrapper(*args, **kwargs): await fn(*args, **kwargs) return wrapper class Operations: ''' This class defines the request handler methods that an pyfuse3 file system may implement. If a particular request handler has not been implemented, it must raise `FUSEError` with an errorcode of `errno.ENOSYS`. Further requests of this type will then be handled directly by the FUSE kernel module without calling the handler again. The only exception that request handlers are allowed to raise is `FUSEError`. This will cause the specified errno to be returned by the syscall that is being handled. It is recommended that file systems are derived from this class and only overwrite the handlers that they actually implement. (The methods defined in this class all just raise ``FUSEError(ENOSYS)`` or do nothing). ''' supports_dot_lookup = True enable_writeback_cache = False enable_acl = False def init(self): '''Initialize operations This method will be called just before the file system starts handling requests. It must not raise any exceptions (not even `FUSEError`), since it is not handling a particular client request. ''' pass async def lookup(self, parent_inode, name, ctx): '''Look up a directory entry by name and get its attributes. This method should return an `EntryAttributes` instance for the directory entry *name* in the directory with inode *parent_inode*. If there is no such entry, the method should either return an `EntryAttributes` instance with zero ``st_ino`` value (in which case the negative lookup will be cached as specified by ``entry_timeout``), or it should raise `FUSEError` with an errno of `errno.ENOENT` (in this case the negative result will not be cached). *ctx* will be a `RequestContext` instance. The file system must be able to handle lookups for :file:`.` and :file:`..`, no matter if these entries are returned by `readdir` or not. (Successful) execution of this handler increases the lookup count for the returned inode by one. ''' raise FUSEError(errno.ENOSYS) async def forget(self, inode_list): '''Decrease lookup counts for inodes in *inode_list* *inode_list* is a list of ``(inode, nlookup)`` tuples. This method should reduce the lookup count for each *inode* by *nlookup*. If the lookup count reaches zero, the inode is currently not known to the kernel. In this case, the file system will typically check if there are still directory entries referring to this inode and, if not, remove the inode. If the file system is unmounted, it may not have received `forget` calls to bring all lookup counts to zero. The filesystem needs to take care to clean up inodes that at that point still have non-zero lookup count (e.g. by explicitly calling `forget` with the current lookup count for every such inode after `main` has returned). This method must not raise any exceptions (not even `FUSEError`), since it is not handling a particular client request. ''' pass async def getattr(self, inode, ctx): '''Get attributes for *inode* *ctx* will be a `RequestContext` instance. This method should return an `EntryAttributes` instance with the attributes of *inode*. The `~EntryAttributes.entry_timeout` attribute is ignored in this context. ''' raise FUSEError(errno.ENOSYS) async def setattr(self, inode, attr, fields, fh, ctx): '''Change attributes of *inode* *fields* will be an `SetattrFields` instance that specifies which attributes are to be updated. *attr* will be an `EntryAttributes` instance for *inode* that contains the new values for changed attributes, and undefined values for all other attributes. Most file systems will additionally set the `~EntryAttributes.st_ctime_ns` attribute to the current time (to indicate that the inode metadata was changed). If the syscall that is being processed received a file descriptor argument (like e.g. :manpage:`ftruncate(2)` or :manpage:`fchmod(2)`), *fh* will be the file handle returned by the corresponding call to the `open` handler. If the syscall was path based (like e.g. :manpage:`truncate(2)` or :manpage:`chmod(2)`), *fh* will be `None`. *ctx* will be a `RequestContext` instance. The method should return an `EntryAttributes` instance (containing both the changed and unchanged values). ''' raise FUSEError(errno.ENOSYS) async def readlink(self, inode, ctx): '''Return target of symbolic link *inode*. *ctx* will be a `RequestContext` instance. ''' raise FUSEError(errno.ENOSYS) async def mknod(self, parent_inode, name, mode, rdev, ctx): '''Create (possibly special) file This method must create a (special or regular) file *name* in the directory with inode *parent_inode*. Whether the file is special or regular is determined by its *mode*. If the file is neither a block nor character device, *rdev* can be ignored. *ctx* will be a `RequestContext` instance. The method must return an `EntryAttributes` instance with the attributes of the newly created directory entry. (Successful) execution of this handler increases the lookup count for the returned inode by one. ''' raise FUSEError(errno.ENOSYS) async def mkdir(self, parent_inode, name, mode, ctx): '''Create a directory This method must create a new directory *name* with mode *mode* in the directory with inode *parent_inode*. *ctx* will be a `RequestContext` instance. This method must return an `EntryAttributes` instance with the attributes of the newly created directory entry. (Successful) execution of this handler increases the lookup count for the returned inode by one. ''' raise FUSEError(errno.ENOSYS) async def unlink(self, parent_inode, name, ctx): '''Remove a (possibly special) file This method must remove the (special or regular) file *name* from the direcory with inode *parent_inode*. *ctx* will be a `RequestContext` instance. If the inode associated with *file* (i.e., not the *parent_inode*) has a non-zero lookup count, or if there are still other directory entries referring to this inode (due to hardlinks), the file system must remove only the directory entry (so that future calls to `readdir` for *parent_inode* will no longer include *name*, but e.g. calls to `getattr` for *file*'s inode still succeed). (Potential) removal of the associated inode with the file contents and metadata must be deferred to the `forget` method to be carried out when the lookup count reaches zero (and of course only if at that point there are no more directory entries associated with the inode either). ''' raise FUSEError(errno.ENOSYS) async def rmdir(self, parent_inode, name, ctx): '''Remove directory *name* This method must remove the directory *name* from the direcory with inode *parent_inode*. *ctx* will be a `RequestContext` instance. If there are still entries in the directory, the method should raise ``FUSEError(errno.ENOTEMPTY)``. If the inode associated with *name* (i.e., not the *parent_inode*) has a non-zero lookup count, the file system must remove only the directory entry (so that future calls to `readdir` for *parent_inode* will no longer include *name*, but e.g. calls to `getattr` for *file*'s inode still succeed). Removal of the associated inode holding the directory contents and metadata must be deferred to the `forget` method to be carried out when the lookup count reaches zero. (Since hard links to directories are not allowed by POSIX, this method is not required to check if there are still other directory entries refering to the same inode. This conveniently avoids the ambigiouties associated with the ``.`` and ``..`` entries). ''' raise FUSEError(errno.ENOSYS) async def symlink(self, parent_inode, name, target, ctx): '''Create a symbolic link This method must create a symbolink link named *name* in the directory with inode *parent_inode*, pointing to *target*. *ctx* will be a `RequestContext` instance. The method must return an `EntryAttributes` instance with the attributes of the newly created directory entry. (Successful) execution of this handler increases the lookup count for the returned inode by one. ''' raise FUSEError(errno.ENOSYS) async def rename(self, parent_inode_old, name_old, parent_inode_new, name_new, flags, ctx): '''Rename a directory entry. This method must rename *name_old* in the directory with inode *parent_inode_old* to *name_new* in the directory with inode *parent_inode_new*. If *name_new* already exists, it should be overwritten. *flags* may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If `RENAME_NOREPLACE` is specified, the filesystem must not overwrite *name_new* if it exists and return an error instead. If `RENAME_EXCHANGE` is specified, the filesystem must atomically exchange the two files, i.e. both must exist and neither may be deleted. *ctx* will be a `RequestContext` instance. Let the inode associated with *name_old* in *parent_inode_old* be *inode_moved*, and the inode associated with *name_new* in *parent_inode_new* (if it exists) be called *inode_deref*. If *inode_deref* exists and has a non-zero lookup count, or if there are other directory entries referring to *inode_deref*), the file system must update only the directory entry for *name_new* to point to *inode_moved* instead of *inode_deref*. (Potential) removal of *inode_deref* (containing the previous contents of *name_new*) must be deferred to the `forget` method to be carried out when the lookup count reaches zero (and of course only if at that point there are no more directory entries associated with *inode_deref* either). ''' raise FUSEError(errno.ENOSYS) async def link(self, inode, new_parent_inode, new_name, ctx): '''Create directory entry *name* in *parent_inode* refering to *inode*. *ctx* will be a `RequestContext` instance. The method must return an `EntryAttributes` instance with the attributes of the newly created directory entry. (Successful) execution of this handler increases the lookup count for the returned inode by one. ''' raise FUSEError(errno.ENOSYS) async def open(self, inode, flags, ctx): '''Open a inode *inode* with *flags*. *ctx* will be a `RequestContext` instance. *flags* will be a bitwise or of the open flags described in the :manpage:`open(2)` manpage and defined in the `os` module (with the exception of ``O_CREAT``, ``O_EXCL``, ``O_NOCTTY`` and ``O_TRUNC``) This method must return a `FileInfo` instance. The `FileInfo.fh` field must contain an integer file handle, which will be passed to the `read`, `write`, `flush`, `fsync` and `release` methods to identify the open file. The `FileInfo` instance may also have relevant configuration attributes set; see the `FileInfo` documentation for more information. ''' raise FUSEError(errno.ENOSYS) async def read(self, fh, off, size): '''Read *size* bytes from *fh* at position *off* *fh* will by an integer filehandle returned by a prior `open` or `create` call. This function should return exactly the number of bytes requested except on EOF or error, otherwise the rest of the data will be substituted with zeroes. ''' raise FUSEError(errno.ENOSYS) async def write(self, fh, off, buf): '''Write *buf* into *fh* at *off* *fh* will by an integer filehandle returned by a prior `open` or `create` call. This method must return the number of bytes written. However, unless the file system has been mounted with the ``direct_io`` option, the file system *must* always write *all* the provided data (i.e., return ``len(buf)``). ''' raise FUSEError(errno.ENOSYS) async def flush(self, fh): '''Handle close() syscall. *fh* will by an integer filehandle returned by a prior `open` or `create` call. This method is called whenever a file descriptor is closed. It may be called multiple times for the same open file (e.g. if the file handle has been duplicated). ''' raise FUSEError(errno.ENOSYS) async def release(self, fh): '''Release open file This method will be called when the last file descriptor of *fh* has been closed, i.e. when the file is no longer opened by any client process. *fh* will by an integer filehandle returned by a prior `open` or `create` call. Once `release` has been called, no future requests for *fh* will be received (until the value is re-used in the return value of another `open` or `create` call). This method may return an error by raising `FUSEError`, but the error will be discarded because there is no corresponding client request. ''' raise FUSEError(errno.ENOSYS) async def fsync(self, fh, datasync): '''Flush buffers for open file *fh* If *datasync* is true, only the file contents should be flushed (in contrast to the metadata about the file). *fh* will by an integer filehandle returned by a prior `open` or `create` call. ''' raise FUSEError(errno.ENOSYS) async def opendir(self, inode, ctx): '''Open the directory with inode *inode* *ctx* will be a `RequestContext` instance. This method should return an integer file handle. The file handle will be passed to the `readdir`, `fsyncdir` and `releasedir` methods to identify the directory. ''' raise FUSEError(errno.ENOSYS) async def readdir(self, fh, start_id, token): '''Read entries in open directory *fh*. This method should list the contents of directory *fh* (as returned by a prior `opendir` call), starting at the entry identified by *start_id*. Instead of returning the directory entries directly, the method must call `readdir_reply` for each directory entry. If `readdir_reply` returns True, the file system must increase the lookup count for the provided directory entry by one and call `readdir_reply` again for the next entry (if any). If `readdir_reply` returns False, the lookup count must *not* be increased and the method should return without further calls to `readdir_reply`. The *start_id* parameter will be either zero (in which case listing should begin with the first entry) or it will correspond to a value that was previously passed by the file system to the `readdir_reply` function in the *next_id* parameter. If entries are added or removed during a `readdir` cycle, they may or may not be returned. However, they must not cause other entries to be skipped or returned more than once. :file:`.` and :file:`..` entries may be included but are not required. However, if they are reported the filesystem *must not* increase the lookup count for the corresponding inodes (even if `readdir_reply` returns True). ''' raise FUSEError(errno.ENOSYS) async def releasedir(self, fh): '''Release open directory This method will be called exactly once for each `opendir` call. After *fh* has been released, no further `readdir` requests will be received for it (until it is opened again with `opendir`). ''' raise FUSEError(errno.ENOSYS) async def fsyncdir(self, fh, datasync): '''Flush buffers for open directory *fh* If *datasync* is true, only the directory contents should be flushed (in contrast to metadata about the directory itself). ''' raise FUSEError(errno.ENOSYS) async def statfs(self, ctx): '''Get file system statistics *ctx* will be a `RequestContext` instance. The method must return an appropriately filled `StatvfsData` instance. ''' raise FUSEError(errno.ENOSYS) def stacktrace(self): '''Asynchronous debugging This method will be called when the ``fuse_stacktrace`` extended attribute is set on the mountpoint. The default implementation logs the current stack trace of every running Python thread. This can be quite useful to debug file system deadlocks. ''' import sys import traceback code = list() for threadId, frame in sys._current_frames().items(): code.append("\n# ThreadID: %s" % threadId) for filename, lineno, name, line in traceback.extract_stack(frame): code.append('%s:%d, in %s' % (os.path.basename(filename), lineno, name)) if line: code.append(" %s" % (line.strip())) log.error("\n".join(code)) async def setxattr(self, inode, name, value, ctx): '''Set extended attribute *name* of *inode* to *value*. *ctx* will be a `RequestContext` instance. The attribute may or may not exist already. Both *name* and *value* will be of type `bytes`. *name* is guaranteed not to contain zero-bytes (``\\0``). ''' raise FUSEError(errno.ENOSYS) async def getxattr(self, inode, name, ctx): '''Return extended attribute *name* of *inode* *ctx* will be a `RequestContext` instance. If the attribute does not exist, the method must raise `FUSEError` with an error code of `ENOATTR`. *name* will be of type `bytes`, but is guaranteed not to contain zero-bytes (``\\0``). ''' raise FUSEError(errno.ENOSYS) async def listxattr(self, inode, ctx): '''Get list of extended attributes for *inode* *ctx* will be a `RequestContext` instance. This method must return a sequence of `bytes` objects. The objects must not include zero-bytes (``\\0``). ''' raise FUSEError(errno.ENOSYS) async def removexattr(self, inode, name, ctx): '''Remove extended attribute *name* of *inode* *ctx* will be a `RequestContext` instance. If the attribute does not exist, the method must raise `FUSEError` with an error code of `ENOATTR`. *name* will be of type `bytes`, but is guaranteed not to contain zero-bytes (``\\0``). ''' raise FUSEError(errno.ENOSYS) async def access(self, inode, mode, ctx): '''Check if requesting process has *mode* rights on *inode*. *ctx* will be a `RequestContext` instance. The method must return a boolean value. If the ``default_permissions`` mount option is given, this method is not called. When implementing this method, the `get_sup_groups` function may be useful. ''' raise FUSEError(errno.ENOSYS) async def create(self, parent_inode, name, mode, flags, ctx): '''Create a file with permissions *mode* and open it with *flags* *ctx* will be a `RequestContext` instance. The method must return a tuple of the form *(fi, attr)*, where *fi* is a FileInfo instance handle like the one returned by `open` and *attr* is an `EntryAttributes` instance with the attributes of the newly created directory entry. (Successful) execution of this handler increases the lookup count for the returned inode by one. ''' raise FUSEError(errno.ENOSYS) pyfuse3-3.2.0/src/darwin_compat.c0000664000175000017500000001400113347452777020377 0ustar nikrationikratio00000000000000/* * Copyright (c) 2006-2008 Amit Singh/Google Inc. * Copyright (c) 2012 Anatol Pomozov * Copyright (c) 2011-2013 Benjamin Fleischer */ #include "darwin_compat.h" #include #include #include /* * Semaphore implementation based on: * * Copyright (C) 2000,02 Free Software Foundation, Inc. * This file is part of the GNU C Library. * Written by Gal Le Mignot * * The GNU C Library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * The GNU C Library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with the GNU C Library; see the file COPYING.LIB. If not, * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /* Semaphores */ #define __SEM_ID_NONE ((int)0x0) #define __SEM_ID_LOCAL ((int)0xcafef00d) /* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_init.html */ int darwin_sem_init(darwin_sem_t *sem, int pshared, unsigned int value) { if (pshared) { errno = ENOSYS; return -1; } sem->id = __SEM_ID_NONE; if (pthread_cond_init(&sem->__data.local.count_cond, NULL)) { goto cond_init_fail; } if (pthread_mutex_init(&sem->__data.local.count_lock, NULL)) { goto mutex_init_fail; } sem->__data.local.count = value; sem->id = __SEM_ID_LOCAL; return 0; mutex_init_fail: pthread_cond_destroy(&sem->__data.local.count_cond); cond_init_fail: return -1; } /* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_destroy.html */ int darwin_sem_destroy(darwin_sem_t *sem) { int res = 0; pthread_mutex_lock(&sem->__data.local.count_lock); sem->id = __SEM_ID_NONE; pthread_cond_broadcast(&sem->__data.local.count_cond); if (pthread_cond_destroy(&sem->__data.local.count_cond)) { res = -1; } pthread_mutex_unlock(&sem->__data.local.count_lock); if (pthread_mutex_destroy(&sem->__data.local.count_lock)) { res = -1; } return res; } int darwin_sem_getvalue(darwin_sem_t *sem, unsigned int *sval) { int res = 0; pthread_mutex_lock(&sem->__data.local.count_lock); if (sem->id != __SEM_ID_LOCAL) { res = -1; errno = EINVAL; } else { *sval = sem->__data.local.count; } pthread_mutex_unlock(&sem->__data.local.count_lock); return res; } /* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_post.html */ int darwin_sem_post(darwin_sem_t *sem) { int res = 0; pthread_mutex_lock(&sem->__data.local.count_lock); if (sem->id != __SEM_ID_LOCAL) { res = -1; errno = EINVAL; } else if (sem->__data.local.count < DARWIN_SEM_VALUE_MAX) { sem->__data.local.count++; if (sem->__data.local.count == 1) { pthread_cond_signal(&sem->__data.local.count_cond); } } else { errno = ERANGE; res = -1; } pthread_mutex_unlock(&sem->__data.local.count_lock); return res; } /* http://www.opengroup.org/onlinepubs/009695399/functions/sem_timedwait.html */ int darwin_sem_timedwait(darwin_sem_t *sem, const struct timespec *abs_timeout) { int res = 0; if (abs_timeout && (abs_timeout->tv_nsec < 0 || abs_timeout->tv_nsec >= 1000000000)) { errno = EINVAL; return -1; } pthread_cleanup_push((void(*)(void*))&pthread_mutex_unlock, &sem->__data.local.count_lock); pthread_mutex_lock(&sem->__data.local.count_lock); if (sem->id != __SEM_ID_LOCAL) { errno = EINVAL; res = -1; } else { if (!sem->__data.local.count) { res = pthread_cond_timedwait(&sem->__data.local.count_cond, &sem->__data.local.count_lock, abs_timeout); } if (res) { assert(res == ETIMEDOUT); res = -1; errno = ETIMEDOUT; } else if (sem->id != __SEM_ID_LOCAL) { res = -1; errno = EINVAL; } else { sem->__data.local.count--; } } pthread_cleanup_pop(1); return res; } /* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_trywait.html */ int darwin_sem_trywait(darwin_sem_t *sem) { int res = 0; pthread_mutex_lock(&sem->__data.local.count_lock); if (sem->id != __SEM_ID_LOCAL) { res = -1; errno = EINVAL; } else if (sem->__data.local.count) { sem->__data.local.count--; } else { res = -1; errno = EAGAIN; } pthread_mutex_unlock (&sem->__data.local.count_lock); return res; } /* http://www.opengroup.org/onlinepubs/007908799/xsh/sem_wait.html */ int darwin_sem_wait(darwin_sem_t *sem) { /* Must be volatile or will be clobbered by longjmp */ volatile int res = 0; pthread_cleanup_push((void(*)(void*))&pthread_mutex_unlock, &sem->__data.local.count_lock); pthread_mutex_lock(&sem->__data.local.count_lock); if (sem->id != __SEM_ID_LOCAL) { errno = EINVAL; res = -1; } else { if (!sem->__data.local.count) { pthread_cond_wait(&sem->__data.local.count_cond, &sem->__data.local.count_lock); if (!sem->__data.local.count) { /* spurious wakeup, assume it is an interruption */ res = -1; errno = EINTR; goto out; } } if (sem->id != __SEM_ID_LOCAL) { res = -1; errno = EINVAL; } else { sem->__data.local.count--; } } out: pthread_cleanup_pop(1); return res; } pyfuse3-3.2.0/src/darwin_compat.h0000664000175000017500000000254013347452777020411 0ustar nikrationikratio00000000000000/* * Copyright (c) 2006-2008 Amit Singh/Google Inc. * Copyright (c) 2011-2013 Benjamin Fleischer */ #ifndef _DARWIN_COMPAT_ #define _DARWIN_COMPAT_ #include /* Semaphores */ typedef struct darwin_sem { int id; union { struct { unsigned int count; pthread_mutex_t count_lock; pthread_cond_t count_cond; } local; } __data; } darwin_sem_t; #define DARWIN_SEM_VALUE_MAX ((int32_t)32767) int darwin_sem_init(darwin_sem_t *sem, int pshared, unsigned int value); int darwin_sem_destroy(darwin_sem_t *sem); int darwin_sem_getvalue(darwin_sem_t *sem, unsigned int *value); int darwin_sem_post(darwin_sem_t *sem); int darwin_sem_timedwait(darwin_sem_t *sem, const struct timespec *abs_timeout); int darwin_sem_trywait(darwin_sem_t *sem); int darwin_sem_wait(darwin_sem_t *sem); /* Caller must not include */ typedef darwin_sem_t sem_t; #define sem_init(s, p, v) darwin_sem_init(s, p, v) #define sem_destroy(s) darwin_sem_destroy(s) #define sem_getvalue(s, v) darwin_sem_getvalue(s, v) #define sem_post(s) darwin_sem_post(s) #define sem_timedwait(s, t) darwin_sem_timedwait(s, t) #define sem_trywait(s) darwin_sem_trywait(s) #define sem_wait(s) darwin_sem_wait(s) #define SEM_VALUE_MAX DARWIN_SEM_VALUE_MAX #endif /* _DARWIN_COMPAT_ */ pyfuse3-3.2.0/src/gettime.h0000664000175000017500000000167513347530014017205 0ustar nikrationikratio00000000000000/* * gettime.h * * Platform-independent interface to system clock * * Copyright © 2015 Nikolaus Rath * * This file is part of pyfuse3. This work may be distributed under the * terms of the GNU LGPL. */ /* * Linux */ #if PLATFORM == PLATFORM_LINUX #include static int gettime_realtime(struct timespec *tp) { return clock_gettime(CLOCK_REALTIME, tp); } /* * FreeBSD & NetBSD */ #elif PLATFORM == PLATFORM_BSD #include static int gettime_realtime(struct timespec *tp) { return clock_gettime(CLOCK_REALTIME, tp); } /* * Darwin */ #elif PLATFORM == PLATFORM_DARWIN #include static int gettime_realtime(struct timespec *tp) { struct timeval tv; int res; res = gettimeofday(&tv, NULL); if(res != 0) return -1; tp->tv_sec = tv.tv_sec; tp->tv_nsec = tv.tv_usec * 1000; return 0; } /* * Unknown system */ #else #error This should not happen #endif pyfuse3-3.2.0/src/handlers.pxi0000664000175000017500000006153413740136074017725 0ustar nikrationikratio00000000000000''' handlers.pxi This file defines the FUSE request handlers. It is included by pyfuse3.pyx. Copyright © 2013 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' @cython.freelist(60) cdef class _Container: """For internal use by pyfuse3 only.""" # This serves as a generic container to pass C variables # through Python. Which fields have valid data depends on # context. cdef dev_t rdev cdef fuse_file_info fi cdef fuse_ino_t ino cdef fuse_ino_t parent cdef fuse_req_t req cdef int flags cdef mode_t mode cdef off_t off cdef size_t size cdef struct_stat stat cdef uint64_t fh cdef void fuse_init (void *userdata, fuse_conn_info *conn): if not conn.capable & FUSE_CAP_READDIRPLUS: raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!') conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) if (operations.supports_dot_lookup and conn.capable & FUSE_CAP_EXPORT_SUPPORT): conn.want |= FUSE_CAP_EXPORT_SUPPORT if (operations.enable_writeback_cache and conn.capable & FUSE_CAP_WRITEBACK_CACHE): conn.want |= FUSE_CAP_WRITEBACK_CACHE if (operations.enable_acl and conn.capable & FUSE_CAP_POSIX_ACL): conn.want |= FUSE_CAP_POSIX_ACL # Blocking rather than async, in case we decide to let the # init hander modify `conn` in the future. operations.init() cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, const_char *name): cdef _Container c = _Container() c.req = req c.parent = parent save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) async def fuse_lookup_async (_Container c, name): cdef EntryAttributes entry cdef int ret ctx = get_request_context(c.req) try: entry = await operations.lookup( c.parent, name, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_entry(c.req, &entry.fuse_param) if ret != 0: log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup): save_retval(operations.forget([(ino, nlookup)])) fuse_reply_none(req) cdef void fuse_forget_multi(fuse_req_t req, size_t count, fuse_forget_data *forgets): forget_list = list() for el in forgets[:count]: forget_list.append((el.ino, el.nlookup)) save_retval(operations.forget(forget_list)) fuse_reply_none(req) cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.ino = ino save_retval(fuse_getattr_async(c)) async def fuse_getattr_async (_Container c): cdef int ret cdef EntryAttributes entry ctx = get_request_context(c.req) try: entry = await operations.getattr(c.ino, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) if ret != 0: log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, struct_stat *stat, int to_set, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.ino = ino c.stat = stat[0] c.flags = to_set if fi is NULL: fh = None else: fh = fi.fh save_retval(fuse_setattr_async(c, fh)) async def fuse_setattr_async (_Container c, fh): cdef int ret cdef timespec now cdef EntryAttributes entry cdef SetattrFields fields cdef struct_stat *attr cdef int to_set = c.flags ctx = get_request_context(c.req) entry = EntryAttributes() fields = SetattrFields.__new__(SetattrFields) string.memcpy(entry.attr, &c.stat, sizeof(struct_stat)) attr = entry.attr if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): ret = libc_extra.gettime_realtime(&now) if ret != 0: log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', strerror(errno.errno)) if to_set & FUSE_SET_ATTR_ATIME: fields.update_atime = True elif to_set & FUSE_SET_ATTR_ATIME_NOW: fields.update_atime = True attr.st_atime = now.tv_sec SET_ATIME_NS(attr, now.tv_nsec) if to_set & FUSE_SET_ATTR_MTIME: fields.update_mtime = True elif to_set & FUSE_SET_ATTR_MTIME_NOW: fields.update_mtime = True attr.st_mtime = now.tv_sec SET_MTIME_NS(attr, now.tv_nsec) fields.update_ctime = bool(to_set & FUSE_SET_ATTR_CTIME) fields.update_mode = bool(to_set & FUSE_SET_ATTR_MODE) fields.update_uid = bool(to_set & FUSE_SET_ATTR_UID) fields.update_gid = bool(to_set & FUSE_SET_ATTR_GID) fields.update_size = bool(to_set & FUSE_SET_ATTR_SIZE) try: entry = await operations.setattr(c.ino, entry, fields, fh, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) if ret != 0: log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino): cdef _Container c = _Container() c.req = req c.ino = ino save_retval(fuse_readlink_async(c)) async def fuse_readlink_async (_Container c): cdef int ret cdef char* name ctx = get_request_context(c.req) try: target = await operations.readlink(c.ino, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: name = PyBytes_AsString(target) ret = fuse_reply_readlink(c.req, name) if ret != 0: log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode, dev_t rdev): cdef _Container c = _Container() c.req = req c.parent = parent c.mode = mode c.rdev = rdev save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) async def fuse_mknod_async (_Container c, name): cdef int ret cdef EntryAttributes entry ctx = get_request_context(c.req) try: entry = await operations.mknod( c.parent, name, c.mode, c.rdev, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_entry(c.req, &entry.fuse_param) if ret != 0: log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode): cdef _Container c = _Container() c.req = req c.parent = parent c.mode = mode save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) async def fuse_mkdir_async (_Container c, name): cdef int ret cdef EntryAttributes entry # Force the entry type to directory. We need to explicitly cast, # because on BSD the S_* are not of type mode_t. c.mode = (c.mode & ~ S_IFMT) | S_IFDIR ctx = get_request_context(c.req) try: entry = await operations.mkdir( c.parent, name, c.mode, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_entry(c.req, &entry.fuse_param) if ret != 0: log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name): cdef _Container c = _Container() c.req = req c.parent = parent save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) async def fuse_unlink_async (_Container c, name): cdef int ret ctx = get_request_context(c.req) try: await operations.unlink(c.parent, name, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name): cdef _Container c = _Container() c.req = req c.parent = parent save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) async def fuse_rmdir_async (_Container c, name): cdef int ret ctx = get_request_context(c.req) try: await operations.rmdir(c.parent, name, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, const_char *name): cdef _Container c = _Container() c.req = req c.parent = parent save_retval(fuse_symlink_async( c, PyBytes_FromString(name), PyBytes_FromString(link))) async def fuse_symlink_async (_Container c, name, link): cdef int ret cdef EntryAttributes entry ctx = get_request_context(c.req) try: entry = await operations.symlink( c.parent, name, link, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_entry(c.req, &entry.fuse_param) if ret != 0: log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, fuse_ino_t newparent, const_char *newname, unsigned flags): cdef _Container c = _Container() c.req = req c.parent = parent c.ino = newparent c.flags = flags save_retval(fuse_rename_async( c, PyBytes_FromString(name), PyBytes_FromString(newname))) async def fuse_rename_async (_Container c, name, newname): cdef int ret cdef unsigned flags = c.flags cdef fuse_ino_t newparent = c.ino ctx = get_request_context(c.req) try: await operations.rename(c.parent, name, newparent, newname, flags, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, const_char *newname): cdef _Container c = _Container() c.req = req c.ino = ino c.parent = newparent save_retval(fuse_link_async(c, PyBytes_FromString(newname))) async def fuse_link_async (_Container c, newname): cdef int ret cdef EntryAttributes entry ctx = get_request_context(c.req) try: entry = await operations.link( c.ino, c.parent, newname, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_entry(c.req, &entry.fuse_param) if ret != 0: log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.ino = ino c.fi = fi[0] save_retval(fuse_open_async(c)) async def fuse_open_async (_Container c): cdef int ret cdef FileInfo fi ctx = get_request_context(c.req) try: fi = await operations.open(c.ino, c.fi.flags, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: fi._copy_to_fuse(&c.fi) ret = fuse_reply_open(c.req, &c.fi) if ret != 0: log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.size = size c.off = off c.fh = fi.fh save_retval(fuse_read_async(c)) async def fuse_read_async (_Container c): cdef int ret cdef Py_buffer pybuf try: buf = await operations.read(c.fh, c.off, c.size) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: PyObject_GetBuffer(buf, &pybuf, PyBUF_CONTIG_RO) ret = fuse_reply_buf(c.req, pybuf.buf, pybuf.len) PyBuffer_Release(&pybuf) if ret != 0: log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, size_t size, off_t off, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.size = size c.off = off c.fh = fi.fh if size > PY_SSIZE_T_MAX: raise OverflowError('Value too long to convert to Python') pbuf = PyBytes_FromStringAndSize(buf, size) save_retval(fuse_write_async(c, pbuf)) async def fuse_write_async (_Container c, pbuf): cdef int ret cdef size_t len_ try: len_ = await operations.write(c.fh, c.off, pbuf) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_write(c.req, len_) if ret != 0: log.error('fuse_write(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_write_buf(fuse_req_t req, fuse_ino_t ino, fuse_bufvec *bufv, off_t off, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.off = off c.fh = fi.fh buf = PyBytes_from_bufvec(bufv) save_retval(fuse_write_buf_async(c, buf)) async def fuse_write_buf_async (_Container c, buf): cdef int ret cdef size_t len_ try: len_ = await operations.write(c.fh, c.off, buf) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_write(c.req, len_) if ret != 0: log.error('fuse_write_buf(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.fh = fi.fh save_retval(fuse_flush_async(c)) async def fuse_flush_async (_Container c): cdef int ret try: await operations.flush(c.fh) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.fh = fi.fh save_retval(fuse_release_async(c)) async def fuse_release_async (_Container c): cdef int ret try: await operations.release(c.fh) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.flags = datasync c.fh = fi.fh save_retval(fuse_fsync_async(c)) async def fuse_fsync_async (_Container c): cdef int ret try: await operations.fsync(c.fh, c.flags != 0) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.ino = ino c.fi = fi[0] save_retval(fuse_opendir_async(c)) async def fuse_opendir_async (_Container c): cdef int ret ctx = get_request_context(c.req) try: c.fi.fh = await operations.opendir(c.ino, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_open(c.req, &c.fi) if ret != 0: log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) @cython.freelist(10) cdef class ReaddirToken: cdef fuse_req_t req cdef char *buf_start cdef char *buf cdef size_t size cdef void fuse_readdirplus (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, fuse_file_info *fi): global py_retval cdef _Container c = _Container() c.req = req c.size = size c.off = off c.fh = fi.fh save_retval(fuse_readdirplus_async(c)) async def fuse_readdirplus_async (_Container c): cdef int ret cdef ReaddirToken token = ReaddirToken() token.buf_start = NULL token.size = c.size token.req = c.req try: await operations.readdir(c.fh, c.off, token) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: if token.buf_start == NULL: ret = fuse_reply_buf(c.req, NULL, 0) else: ret = fuse_reply_buf(c.req, token.buf_start, c.size - token.size) finally: stdlib.free(token.buf_start) if ret != 0: log.error('fuse_readdirplus(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.fh = fi.fh save_retval(fuse_releasedir_async(c)) async def fuse_releasedir_async (_Container c): cdef int ret try: await operations.releasedir(c.fh) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.flags = datasync c.fh = fi.fh save_retval(fuse_fsyncdir_async(c)) async def fuse_fsyncdir_async (_Container c): cdef int ret try: await operations.fsyncdir(c.fh, c.flags != 0) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino): cdef _Container c = _Container() c.req = req save_retval(fuse_statfs_async(c)) async def fuse_statfs_async (_Container c): cdef int ret cdef StatvfsData stats ctx = get_request_context(c.req) try: stats = await operations.statfs(ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_statfs(c.req, &stats.stat) if ret != 0: log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, const_char *cvalue, size_t size, int flags): cdef _Container c = _Container() c.req = req c.ino = ino c.size = size c.flags = flags name = PyBytes_FromString(cname) if c.size > PY_SSIZE_T_MAX: raise OverflowError('Value too long to convert to Python') value = PyBytes_FromStringAndSize(cvalue, c.size) save_retval(fuse_setxattr_async(c, name, value)) async def fuse_setxattr_async (_Container c, name, value): cdef int ret # Special case for deadlock debugging if c.ino == FUSE_ROOT_ID and name == 'fuse_stacktrace': operations.stacktrace() fuse_reply_err(c.req, 0) return # Make sure we know all the flags if c.flags & ~(libc_extra.XATTR_CREATE | libc_extra.XATTR_REPLACE): raise ValueError('unknown flag(s): %o' % c.flags) ctx = get_request_context(c.req) try: if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist try: await operations.getxattr(c.ino, name) except FUSEError as e: if e.errno != ENOATTR: raise else: raise FUSEError(errno.EEXIST) elif c.flags & libc_extra.XATTR_REPLACE: # Attribute must exist await operations.getxattr(c.ino, name) await operations.setxattr(c.ino, name, value, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *name, size_t size): cdef _Container c = _Container() c.req = req c.ino = ino c.size = size save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) async def fuse_getxattr_async (_Container c, name): cdef int ret cdef ssize_t len_s cdef size_t len_ cdef char *cbuf ctx = get_request_context(c.req) try: buf = await operations.getxattr(c.ino, name, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: PyBytes_AsStringAndSize(buf, &cbuf, &len_s) len_ = len_s # guaranteed positive if c.size == 0: ret = fuse_reply_xattr(c.req, len_) elif len_ <= c.size: ret = fuse_reply_buf(c.req, cbuf, len_) else: ret = fuse_reply_err(c.req, errno.ERANGE) if ret != 0: log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size): cdef _Container c = _Container() c.req = req c.ino = ino c.size = size save_retval(fuse_listxattr_async(c)) async def fuse_listxattr_async (_Container c): cdef int ret cdef ssize_t len_s cdef size_t len_ cdef char *cbuf ctx = get_request_context(c.req) try: res = await operations.listxattr(c.ino, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: buf = b'\0'.join(res) + b'\0' PyBytes_AsStringAndSize(buf, &cbuf, &len_s) len_ = len_s # guaranteed positive if len_ == 1: # No attributes len_ = 0 if c.size == 0: ret = fuse_reply_xattr(c.req, len_) elif len_ <= c.size: ret = fuse_reply_buf(c.req, cbuf, len_) else: ret = fuse_reply_err(c.req, errno.ERANGE) if ret != 0: log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *name): cdef _Container c = _Container() c.req = req c.ino = ino save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) async def fuse_removexattr_async (_Container c, name): cdef int ret ctx = get_request_context(c.req) try: await operations.removexattr(c.ino, name, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: ret = fuse_reply_err(c.req, 0) if ret != 0: log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask): cdef _Container c = _Container() c.req = req c.ino = ino c.flags = mask save_retval(fuse_access_async(c)) async def fuse_access_async (_Container c): cdef int ret cdef int mask = c.flags ctx = get_request_context(c.req) try: allowed = await operations.access(c.ino, mask, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: if allowed: ret = fuse_reply_err(c.req, 0) else: ret = fuse_reply_err(c.req, EACCES) if ret != 0: log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *name, mode_t mode, fuse_file_info *fi): cdef _Container c = _Container() c.req = req c.parent = parent c.mode = mode c.fi = fi[0] save_retval(fuse_create_async(c, PyBytes_FromString(name))) async def fuse_create_async (_Container c, name): cdef int ret cdef EntryAttributes entry cdef FileInfo fi ctx = get_request_context(c.req) try: tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) except FUSEError as e: ret = fuse_reply_err(c.req, e.errno) else: fi = tmp[0] entry = tmp[1] fi._copy_to_fuse(&c.fi) ret = fuse_reply_create(c.req, &entry.fuse_param, &c.fi) if ret != 0: log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) pyfuse3-3.2.0/src/internal.pxi0000664000175000017500000002041213772373213017732 0ustar nikrationikratio00000000000000''' misc.pxi This file defines functions and data structures that are used internally by pyfuse3. It is included by pyfuse3.pyx. Copyright © 2013 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' cdef void save_retval(object val): global py_retval if py_retval is not None and val is not None: log.error('py_retval was not awaited - please report a bug at ' 'https://github.com/libfuse/pyfuse3/issues!') py_retval = val cdef object get_request_context(fuse_req_t req): '''Get RequestContext() object''' cdef const_fuse_ctx* context cdef RequestContext ctx context = fuse_req_ctx(req) ctx = RequestContext.__new__(RequestContext) ctx.pid = context.pid ctx.uid = context.uid ctx.gid = context.gid ctx.umask = context.umask return ctx cdef void init_fuse_ops(): '''Initialize fuse_lowlevel_ops structure''' string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) fuse_ops.init = fuse_init fuse_ops.lookup = fuse_lookup fuse_ops.forget = fuse_forget fuse_ops.getattr = fuse_getattr fuse_ops.setattr = fuse_setattr fuse_ops.readlink = fuse_readlink fuse_ops.mknod = fuse_mknod fuse_ops.mkdir = fuse_mkdir fuse_ops.unlink = fuse_unlink fuse_ops.rmdir = fuse_rmdir fuse_ops.symlink = fuse_symlink fuse_ops.rename = fuse_rename fuse_ops.link = fuse_link fuse_ops.open = fuse_open fuse_ops.read = fuse_read fuse_ops.write = fuse_write fuse_ops.flush = fuse_flush fuse_ops.release = fuse_release fuse_ops.fsync = fuse_fsync fuse_ops.opendir = fuse_opendir fuse_ops.readdirplus = fuse_readdirplus fuse_ops.releasedir = fuse_releasedir fuse_ops.fsyncdir = fuse_fsyncdir fuse_ops.statfs = fuse_statfs ASSIGN_NOT_DARWIN(fuse_ops.setxattr, &fuse_setxattr) ASSIGN_NOT_DARWIN(fuse_ops.getxattr, &fuse_getxattr) fuse_ops.listxattr = fuse_listxattr fuse_ops.removexattr = fuse_removexattr fuse_ops.access = fuse_access fuse_ops.create = fuse_create fuse_ops.forget_multi = fuse_forget_multi fuse_ops.write_buf = fuse_write_buf cdef make_fuse_args(args, fuse_args* f_args): cdef char* arg cdef int i cdef ssize_t size_s cdef size_t size args_new = [ b'pyfuse3' ] for el in args: args_new.append(b'-o') args_new.append(el.encode('us-ascii')) args = args_new f_args.argc = len(args) if f_args.argc == 0: f_args.argv = NULL return f_args.allocated = 1 f_args.argv = stdlib.calloc( f_args.argc, sizeof(char*)) if f_args.argv is NULL: cpython.exc.PyErr_NoMemory() try: for (i, el) in enumerate(args): PyBytes_AsStringAndSize(el, &arg, &size_s) size = size_s # guaranteed positive f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) if f_args.argv[i] is NULL: cpython.exc.PyErr_NoMemory() string.strncpy(f_args.argv[i], arg, size+1) except: for i in range(f_args.argc): # Freeing a NULL pointer (if this element has not been allocated # yet) is fine. stdlib.free(f_args.argv[i]) stdlib.free(f_args.argv) raise def _notify_loop(): '''Process async invalidate_entry calls.''' while True: req = _notify_queue.get() if req is None: log.debug('terminating notify thread') break (inode_p, name, deleted, ignore_enoent) = req try: invalidate_entry(inode_p, name, deleted) except Exception as exc: if ignore_enoent and isinstance(exc, FileNotFoundError): pass else: log.exception('Failed to submit invalidate_entry request for ' 'parent inode %d, name %s', req[0], req[1]) cdef str2bytes(s): '''Convert *s* to bytes''' return s.encode(fse, 'surrogateescape') cdef bytes2str(s): '''Convert *s* to str''' return s.decode(fse, 'surrogateescape') cdef strerror(int errno): try: return os.strerror(errno) except ValueError: return 'errno: %d' % errno cdef PyBytes_from_bufvec(fuse_bufvec *src): cdef fuse_bufvec dst cdef size_t len_ cdef ssize_t res len_ = fuse_buf_size(src) - src.off if len_ > PY_SSIZE_T_MAX: raise OverflowError('Value too long to convert to Python') buf = PyBytes_FromStringAndSize(NULL, len_) dst.count = 1 dst.idx = 0 dst.off = 0 dst.buf[0].mem = PyBytes_AS_STRING(buf) dst.buf[0].size = len_ dst.buf[0].flags = 0 res = fuse_buf_copy(&dst, src, 0) if res < 0: raise OSError(errno.errno, 'fuse_buf_copy failed with ' + strerror(errno.errno)) elif res < len_: # This is expected to be rare return buf[:res] else: return buf cdef void* calloc_or_raise(size_t nmemb, size_t size) except NULL: cdef void* mem mem = stdlib.calloc(nmemb, size) if mem is NULL: raise MemoryError() return mem cdef class _WorkerData: """For internal use by pyfuse3 only.""" cdef int task_count cdef int task_serial cdef object read_lock cdef int active_readers def __init__(self): self.read_lock = trio.Lock() self.active_readers = 0 cdef get_name(self): self.task_serial += 1 return 'pyfuse-%02d' % self.task_serial # Delay initialization so that pyfuse3_asyncio can replace # the trio module. cdef _WorkerData worker_data async def _wait_fuse_readable(): '''Wait for FUSE fd to become readable Return True if the fd is readable, or False if the main loop should terminate. ''' #name = trio.lowlevel.current_task().name worker_data.active_readers += 1 try: #log.debug('%s: Waiting for read lock...', name) async with worker_data.read_lock: #log.debug('%s: Waiting for fuse fd to become readable...', name) if fuse_session_exited(session): log.debug('FUSE session exit flag set while waiting for FUSE fd ' 'to become readable.') return False await trio.lowlevel.wait_readable(session_fd) #log.debug('%s: fuse fd readable, unparking next task.', name) except trio.ClosedResourceError: log.debug('FUSE fd about to be closed.') return False finally: worker_data.active_readers -= 1 return True @async_wrapper async def _session_loop(nursery, int min_tasks, int max_tasks): cdef int res cdef fuse_buf buf name = trio.lowlevel.current_task().name buf.mem = NULL buf.size = 0 buf.pos = 0 buf.flags = 0 while not fuse_session_exited(session): if worker_data.active_readers > min_tasks: log.debug('%s: too many idle tasks (%d total, %d waiting), terminating.', name, worker_data.task_count, worker_data.active_readers) break if not await _wait_fuse_readable(): break res = fuse_session_receive_buf(session, &buf) if not worker_data.active_readers and worker_data.task_count < max_tasks: worker_data.task_count += 1 log.debug('%s: No tasks waiting, starting another worker (now %d total).', name, worker_data.task_count) nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, name=worker_data.get_name()) if res == -errno.EINTR: continue elif res < 0: raise OSError(-res, 'fuse_session_receive_buf failed with ' + strerror(-res)) elif res == 0: break # When fuse_session_process_buf() calls back into one of our handler # methods, the handler will start a co-routine and store it in # py_retval. #log.debug('%s: processing request...', name) save_retval(None) fuse_session_process_buf(session, &buf) if py_retval is not None: await py_retval #log.debug('%s: processing complete.', name) log.debug('%s: terminated', name) stdlib.free(buf.mem) worker_data.task_count -= 1 pyfuse3-3.2.0/src/macros.c0000664000175000017500000000347713354212533017031 0ustar nikrationikratio00000000000000/* macros.c - Pre-processor macros Copyright © 2013 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. */ /* * Macros to access the nanosecond attributes in struct stat in a * platform independent way. Stolen from fuse_misc.h. */ #if PLATFORM == PLATFORM_LINUX #define GET_ATIME_NS(stbuf) ((stbuf)->st_atim.tv_nsec) #define GET_CTIME_NS(stbuf) ((stbuf)->st_ctim.tv_nsec) #define GET_MTIME_NS(stbuf) ((stbuf)->st_mtim.tv_nsec) #define SET_ATIME_NS(stbuf, val) (stbuf)->st_atim.tv_nsec = (val) #define SET_CTIME_NS(stbuf, val) (stbuf)->st_ctim.tv_nsec = (val) #define SET_MTIME_NS(stbuf, val) (stbuf)->st_mtim.tv_nsec = (val) #define GET_BIRTHTIME_NS(stbuf) (0) #define GET_BIRTHTIME(stbuf) (0) #define SET_BIRTHTIME_NS(stbuf, val) do {} while (0) #define SET_BIRTHTIME(stbuf, val) do {} while (0) /* BSD and OS-X */ #else #define GET_BIRTHTIME(stbuf) ((stbuf)->st_birthtime) #define SET_BIRTHTIME(stbuf, val) ((stbuf)->st_birthtime = (val)) #define GET_ATIME_NS(stbuf) ((stbuf)->st_atimespec.tv_nsec) #define GET_CTIME_NS(stbuf) ((stbuf)->st_ctimespec.tv_nsec) #define GET_MTIME_NS(stbuf) ((stbuf)->st_mtimespec.tv_nsec) #define GET_BIRTHTIME_NS(stbuf) ((stbuf)->st_birthtimespec.tv_nsec) #define SET_ATIME_NS(stbuf, val) ((stbuf)->st_atimespec.tv_nsec = (val)) #define SET_CTIME_NS(stbuf, val) ((stbuf)->st_ctimespec.tv_nsec = (val)) #define SET_MTIME_NS(stbuf, val) ((stbuf)->st_mtimespec.tv_nsec = (val)) #define SET_BIRTHTIME_NS(stbuf, val) ((stbuf)->st_birthtimespec.tv_nsec = (val)) #endif #if PLATFORM == PLATFORM_LINUX || PLATFORM == PLATFORM_BSD #define ASSIGN_DARWIN(x,y) #define ASSIGN_NOT_DARWIN(x,y) ((x) = (y)) #elif PLATFORM == PLATFORM_DARWIN #define ASSIGN_DARWIN(x,y) ((x) = (y)) #define ASSIGN_NOT_DARWIN(x,y) #else #error This should not happen #endif pyfuse3-3.2.0/src/macros.pxd0000664000175000017500000000144613354212434017374 0ustar nikrationikratio00000000000000''' macros.pxd Cython definitions for macros.c Copyright © 2018 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' from posix.stat cimport struct_stat cdef extern from "macros.c" nogil: long GET_BIRTHTIME(struct_stat* buf) long GET_ATIME_NS(struct_stat* buf) long GET_CTIME_NS(struct_stat* buf) long GET_MTIME_NS(struct_stat* buf) long GET_BIRTHTIME_NS(struct_stat* buf) void SET_BIRTHTIME(struct_stat* buf, long val) void SET_ATIME_NS(struct_stat* buf, long val) void SET_CTIME_NS(struct_stat* buf, long val) void SET_MTIME_NS(struct_stat* buf, long val) void SET_BIRTHTIME_NS(struct_stat* buf, long val) void ASSIGN_DARWIN(void*, void*) void ASSIGN_NOT_DARWIN(void*, void*) pyfuse3-3.2.0/src/pyfuse3.c0000664000175000017500001116235413773155600017153 0ustar nikrationikratio00000000000000/* Generated by Cython 0.29.21 */ #define PY_SSIZE_T_CLEAN #include "Python.h" #ifndef Py_PYTHON_H #error Python headers needed to compile C extensions, please install development version of Python. #elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) #error Cython requires Python 2.6+ or Python 3.3+. #else #define CYTHON_ABI "0_29_21" #define CYTHON_HEX_VERSION 0x001D15F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif #if !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif #ifndef __cdecl #define __cdecl #endif #ifndef __fastcall #define __fastcall #endif #endif #ifndef DL_IMPORT #define DL_IMPORT(t) t #endif #ifndef DL_EXPORT #define DL_EXPORT(t) t #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG #if PY_VERSION_HEX >= 0x02070000 #define HAVE_LONG_LONG #endif #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG #endif #ifndef Py_HUGE_VAL #define Py_HUGE_VAL HUGE_VAL #endif #ifdef PYPY_VERSION #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #undef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #undef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 1 #undef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 0 #undef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif defined(PYSTON_VERSION) #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 1 #define CYTHON_COMPILING_IN_CPYTHON 0 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #undef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 0 #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 #undef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #else #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 #undef CYTHON_USE_ASYNC_SLOTS #define CYTHON_USE_ASYNC_SLOTS 0 #elif !defined(CYTHON_USE_ASYNC_SLOTS) #define CYTHON_USE_ASYNC_SLOTS 1 #endif #if PY_VERSION_HEX < 0x02070000 #undef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 0 #elif !defined(CYTHON_USE_PYLONG_INTERNALS) #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS #define CYTHON_USE_PYLIST_INTERNALS 1 #endif #ifndef CYTHON_USE_UNICODE_INTERNALS #define CYTHON_USE_UNICODE_INTERNALS 1 #endif #if PY_VERSION_HEX < 0x030300F0 #undef CYTHON_USE_UNICODE_WRITER #define CYTHON_USE_UNICODE_WRITER 0 #elif !defined(CYTHON_USE_UNICODE_WRITER) #define CYTHON_USE_UNICODE_WRITER 1 #endif #ifndef CYTHON_AVOID_BORROWED_REFS #define CYTHON_AVOID_BORROWED_REFS 0 #endif #ifndef CYTHON_ASSUME_SAFE_MACROS #define CYTHON_ASSUME_SAFE_MACROS 1 #endif #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif #ifndef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 1 #endif #ifndef CYTHON_PEP489_MULTI_PHASE_INIT #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) #endif #ifndef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) #endif #ifndef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) #endif #ifndef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) #endif #endif #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif #if CYTHON_USE_PYLONG_INTERNALS #include "longintrepr.h" #undef SHIFT #undef BASE #undef MASK #ifdef SIZEOF_VOID_P enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; #endif #endif #ifndef __has_attribute #define __has_attribute(x) 0 #endif #ifndef __has_cpp_attribute #define __has_cpp_attribute(x) 0 #endif #ifndef CYTHON_RESTRICT #if defined(__GNUC__) #define CYTHON_RESTRICT __restrict__ #elif defined(_MSC_VER) && _MSC_VER >= 1400 #define CYTHON_RESTRICT __restrict #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_RESTRICT restrict #else #define CYTHON_RESTRICT #endif #endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif # elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) # define CYTHON_UNUSED __attribute__ ((__unused__)) # else # define CYTHON_UNUSED # endif #endif #ifndef CYTHON_MAYBE_UNUSED_VAR # if defined(__cplusplus) template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } # else # define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) # endif #endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED # else # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif #define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) #ifdef _MSC_VER #ifndef _MSC_STDINT_H_ #if _MSC_VER < 1300 typedef unsigned char uint8_t; typedef unsigned int uint32_t; #else typedef unsigned __int8 uint8_t; typedef unsigned __int32 uint32_t; #endif #endif #else #include #endif #ifndef CYTHON_FALLTHROUGH #if defined(__cplusplus) && __cplusplus >= 201103L #if __has_cpp_attribute(fallthrough) #define CYTHON_FALLTHROUGH [[fallthrough]] #elif __has_cpp_attribute(clang::fallthrough) #define CYTHON_FALLTHROUGH [[clang::fallthrough]] #elif __has_cpp_attribute(gnu::fallthrough) #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] #endif #endif #ifndef CYTHON_FALLTHROUGH #if __has_attribute(fallthrough) #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) #else #define CYTHON_FALLTHROUGH #endif #endif #if defined(__clang__ ) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif #ifndef CYTHON_INLINE #if defined(__clang__) #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) #elif defined(__GNUC__) #define CYTHON_INLINE __inline__ #elif defined(_MSC_VER) #define CYTHON_INLINE __inline #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define CYTHON_INLINE inline #else #define CYTHON_INLINE #endif #endif #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) #define Py_OptimizeFlag 0 #endif #define __PYX_BUILD_PY_SSIZE_T "n" #define CYTHON_FORMAT_SSIZE_T "z" #if PY_MAJOR_VERSION < 3 #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #define __Pyx_DefaultClassType PyClass_Type #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #if PY_VERSION_HEX >= 0x030800A4 && PY_VERSION_HEX < 0x030800B2 #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, 0, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #else #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) #endif #define __Pyx_DefaultClassType PyType_Type #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 #endif #ifndef Py_TPFLAGS_HAVE_INDEX #define Py_TPFLAGS_HAVE_INDEX 0 #endif #ifndef Py_TPFLAGS_HAVE_NEWBUFFER #define Py_TPFLAGS_HAVE_NEWBUFFER 0 #endif #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif #if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) #ifndef METH_FASTCALL #define METH_FASTCALL 0x80 #endif typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames); #else #define __Pyx_PyCFunctionFast _PyCFunctionFast #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords #endif #if CYTHON_FAST_PYCCALL #define __Pyx_PyFastCFunction_Check(func)\ ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) #else #define __Pyx_PyFastCFunction_Check(func) 0 #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) #define PyObject_Malloc(s) PyMem_Malloc(s) #define PyObject_Free(p) PyMem_Free(p) #define PyObject_Realloc(p) PyMem_Realloc(p) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 #define PyMem_RawMalloc(n) PyMem_Malloc(n) #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) #define PyMem_RawFree(p) PyMem_Free(p) #endif #if CYTHON_COMPILING_IN_PYSTON #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) #else #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) #endif #if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 #define __Pyx_PyThreadState_Current PyThreadState_GET() #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 typedef int Py_tss_t; static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { *key = PyThread_create_key(); return 0; } static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); *key = Py_tss_NEEDS_INIT; return key; } static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { PyObject_Free(key); } static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { return *key != Py_tss_NEEDS_INIT; } static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { PyThread_delete_key(*key); *key = Py_tss_NEEDS_INIT; } static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { return PyThread_set_key_value(*key, value); } static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { return PyThread_get_key_value(*key); } #endif #if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() #endif #if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) #else #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS #define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) #else #define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) #endif #if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) #define CYTHON_PEP393_ENABLED 1 #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ 0 : _PyUnicode_Ready((PyObject *)(op))) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_LENGTH(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) #define __Pyx_PyUnicode_KIND(u) PyUnicode_KIND(u) #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, ch) #if defined(PyUnicode_IS_READY) && defined(PyUnicode_GET_SIZE) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) #else #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #endif #else #define CYTHON_PEP393_ENABLED 0 #define PyUnicode_1BYTE_KIND 1 #define PyUnicode_2BYTE_KIND 2 #define PyUnicode_4BYTE_KIND 4 #define __Pyx_PyUnicode_READY(op) (0) #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) #else #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) #endif #if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) #endif #define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) #define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) #else #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) #endif #if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) #define PyObject_ASCII(o) PyObject_Repr(o) #endif #if PY_MAJOR_VERSION >= 3 #define PyBaseString_Type PyUnicode_Type #define PyStringObject PyUnicodeObject #define PyString_Type PyUnicode_Type #define PyString_Check PyUnicode_Check #define PyString_CheckExact PyUnicode_CheckExact #ifndef PyObject_Unicode #define PyObject_Unicode PyObject_Str #endif #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) #else #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif #ifndef PySet_CheckExact #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) #else #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) #else #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) #endif #if PY_MAJOR_VERSION >= 3 #define PyIntObject PyLongObject #define PyInt_Type PyLong_Type #define PyInt_Check(op) PyLong_Check(op) #define PyInt_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong #define PyInt_FromSize_t PyLong_FromSize_t #define PyInt_FromSsize_t PyLong_FromSsize_t #define PyInt_AsLong PyLong_AsLong #define PyInt_AS_LONG PyLong_AS_LONG #define PyInt_AsSsize_t PyLong_AsSsize_t #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject #endif #if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY #ifndef PyUnicode_InternFromString #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) #endif #endif #if PY_VERSION_HEX < 0x030200A4 typedef long Py_hash_t; #define __Pyx_PyInt_FromHash_t PyInt_FromLong #define __Pyx_PyInt_AsHash_t PyInt_AsLong #else #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t PyInt_AsSsize_t #endif #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) #else #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) #endif #if CYTHON_USE_ASYNC_SLOTS #if PY_VERSION_HEX >= 0x030500B1 #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) #else #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) #endif #else #define __Pyx_PyType_AsAsync(obj) NULL #endif #ifndef __Pyx_PyAsyncMethodsStruct typedef struct { unaryfunc am_await; unaryfunc am_aiter; unaryfunc am_anext; } __Pyx_PyAsyncMethodsStruct; #endif #if defined(WIN32) || defined(MS_WINDOWS) #define _USE_MATH_DEFINES #endif #include #ifdef NAN #define __PYX_NAN() ((float) NAN) #else static CYTHON_INLINE float __PYX_NAN() { float value; memset(&value, 0xFF, sizeof(value)); return value; } #endif #if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) #define __Pyx_truncl trunc #else #define __Pyx_truncl truncl #endif #define __PYX_MARK_ERR_POS(f_index, lineno) \ { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } #ifndef __PYX_EXTERN_C #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else #define __PYX_EXTERN_C extern #endif #endif #define __PYX_HAVE__pyfuse3 #define __PYX_HAVE_API__pyfuse3 /* Early includes */ #include "pyfuse3.h" #include #include #include #include #include #include #include #include #include #include "xattr.h" #include "gettime.h" #include #include #include #include "macros.c" #include #include #include #ifdef _OPENMP #include #endif /* _OPENMP */ #if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) #define CYTHON_WITHOUT_ASSERTIONS #endif typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; #define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 #define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) #define __PYX_DEFAULT_STRING_ENCODING "" #define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString #define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #define __Pyx_uchar_cast(c) ((unsigned char)c) #define __Pyx_long_cast(x) ((long)x) #define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ (sizeof(type) < sizeof(Py_ssize_t)) ||\ (sizeof(type) > sizeof(Py_ssize_t) &&\ likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX) &&\ (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ v == (type)PY_SSIZE_T_MIN))) ||\ (sizeof(type) == sizeof(Py_ssize_t) &&\ (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ v == (type)PY_SSIZE_T_MAX))) ) static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { return (size_t) i < (size_t) limit; } #if defined (__cplusplus) && __cplusplus >= 201103L #include #define __Pyx_sst_abs(value) std::abs(value) #elif SIZEOF_INT >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) abs(value) #elif SIZEOF_LONG >= SIZEOF_SIZE_T #define __Pyx_sst_abs(value) labs(value) #elif defined (_MSC_VER) #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L #define __Pyx_sst_abs(value) llabs(value) #elif defined (__GNUC__) #define __Pyx_sst_abs(value) __builtin_llabs(value) #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); #define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #if PY_MAJOR_VERSION < 3 #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize #else #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize #endif #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) #define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) #define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) #define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) #define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) #define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) #define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { const Py_UNICODE *u_end = u; while (*u_end++) ; return (size_t)(u_end - u - 1); } #define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) #define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode #define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode #define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) #define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); #define __Pyx_PySequence_Tuple(obj)\ (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); #if CYTHON_ASSUME_SAFE_MACROS #define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) #else #define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) #endif #define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) #if PY_MAJOR_VERSION >= 3 #define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) #else #define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) #endif #define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; PyObject* ascii_chars_u = NULL; PyObject* ascii_chars_b = NULL; const char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; if (strcmp(default_encoding_c, "ascii") == 0) { __Pyx_sys_getdefaultencoding_not_ascii = 0; } else { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { ascii_chars[c] = c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); if (!ascii_chars_u) goto bad; ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { PyErr_Format( PyExc_ValueError, "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", default_encoding_c); goto bad; } Py_DECREF(ascii_chars_u); Py_DECREF(ascii_chars_b); } Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); Py_XDECREF(ascii_chars_u); Py_XDECREF(ascii_chars_b); return -1; } #endif #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) #else #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) #if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; PyObject* default_encoding = NULL; char* default_encoding_c; sys = PyImport_ImportModule("sys"); if (!sys) goto bad; default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); Py_DECREF(sys); if (!default_encoding) goto bad; default_encoding_c = PyBytes_AsString(default_encoding); if (!default_encoding_c) goto bad; __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); Py_DECREF(default_encoding); return 0; bad: Py_XDECREF(default_encoding); return -1; } #endif #endif /* Test for GCC > 2.95 */ #if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) #define likely(x) __builtin_expect(!!(x), 1) #define unlikely(x) __builtin_expect(!!(x), 0) #else /* !__GNUC__ or GCC < 2.95 */ #define likely(x) (x) #define unlikely(x) (x) #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } static PyObject *__pyx_m = NULL; static PyObject *__pyx_d; static PyObject *__pyx_b; static PyObject *__pyx_cython_runtime = NULL; static PyObject *__pyx_empty_tuple; static PyObject *__pyx_empty_bytes; static PyObject *__pyx_empty_unicode; static int __pyx_lineno; static int __pyx_clineno = 0; static const char * __pyx_cfilenm= __FILE__; static const char *__pyx_filename; static const char *__pyx_f[] = { "stringsource", "src/handlers.pxi", "src/internal.pxi", "src/pyfuse3.pyx", "type.pxd", }; /* NoFastGil.proto */ #define __Pyx_PyGILState_Ensure PyGILState_Ensure #define __Pyx_PyGILState_Release PyGILState_Release #define __Pyx_FastGIL_Remember() #define __Pyx_FastGIL_Forget() #define __Pyx_FastGilFuncInit() /* ForceInitThreads.proto */ #ifndef __PYX_FORCE_INIT_THREADS #define __PYX_FORCE_INIT_THREADS 0 #endif /*--- Type declarations ---*/ struct __pyx_obj_7pyfuse3__Container; struct __pyx_obj_7pyfuse3_ReaddirToken; struct __pyx_obj_7pyfuse3__WorkerData; struct __pyx_obj_7pyfuse3_RequestContext; struct __pyx_obj_7pyfuse3_SetattrFields; struct __pyx_obj_7pyfuse3_EntryAttributes; struct __pyx_obj_7pyfuse3_FileInfo; struct __pyx_obj_7pyfuse3_StatvfsData; struct __pyx_obj_7pyfuse3_FUSEError; struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async; struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable; struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop; struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main; /* "src/handlers.pxi":14 * * @cython.freelist(60) * cdef class _Container: # <<<<<<<<<<<<<< * """For internal use by pyfuse3 only.""" * */ struct __pyx_obj_7pyfuse3__Container { PyObject_HEAD dev_t rdev; struct fuse_file_info fi; fuse_ino_t ino; fuse_ino_t parent; fuse_req_t req; int flags; mode_t mode; off_t off; size_t size; struct stat stat; uint64_t fh; }; /* "src/handlers.pxi":562 * * @cython.freelist(10) * cdef class ReaddirToken: # <<<<<<<<<<<<<< * cdef fuse_req_t req * cdef char *buf_start */ struct __pyx_obj_7pyfuse3_ReaddirToken { PyObject_HEAD fuse_req_t req; char *buf_start; char *buf; size_t size; }; /* "src/internal.pxi":181 * return mem * * cdef class _WorkerData: # <<<<<<<<<<<<<< * """For internal use by pyfuse3 only.""" * */ struct __pyx_obj_7pyfuse3__WorkerData { PyObject_HEAD struct __pyx_vtabstruct_7pyfuse3__WorkerData *__pyx_vtab; int task_count; int task_serial; PyObject *read_lock; int active_readers; }; /* "pyfuse3.pyx":127 * * @cython.freelist(10) * cdef class RequestContext: # <<<<<<<<<<<<<< * ''' * Instances of this class are passed to some `Operations` methods to */ struct __pyx_obj_7pyfuse3_RequestContext { PyObject_HEAD uid_t uid; pid_t pid; gid_t gid; mode_t umask; }; /* "pyfuse3.pyx":144 * * @cython.freelist(10) * cdef class SetattrFields: # <<<<<<<<<<<<<< * ''' * `SetattrFields` instances are passed to the `~Operations.setattr` handler */ struct __pyx_obj_7pyfuse3_SetattrFields { PyObject_HEAD PyObject *update_atime; PyObject *update_mtime; PyObject *update_ctime; PyObject *update_mode; PyObject *update_uid; PyObject *update_gid; PyObject *update_size; }; /* "pyfuse3.pyx":171 * * @cython.freelist(30) * cdef class EntryAttributes: # <<<<<<<<<<<<<< * ''' * Instances of this class store attributes of directory entries. */ struct __pyx_obj_7pyfuse3_EntryAttributes { PyObject_HEAD struct fuse_entry_param fuse_param; struct stat *attr; }; /* "pyfuse3.pyx":351 * * @cython.freelist(10) * cdef class FileInfo: # <<<<<<<<<<<<<< * ''' * Instances of this class store options and data that `Operations.open` */ struct __pyx_obj_7pyfuse3_FileInfo { PyObject_HEAD struct __pyx_vtabstruct_7pyfuse3_FileInfo *__pyx_vtab; uint64_t fh; int direct_io; int keep_cache; int nonseekable; }; /* "pyfuse3.pyx":391 * * @cython.freelist(1) * cdef class StatvfsData: # <<<<<<<<<<<<<< * ''' * Instances of this class store information about the file system. */ struct __pyx_obj_7pyfuse3_StatvfsData { PyObject_HEAD struct statvfs stat; }; /* "pyfuse3.pyx":481 * # As of Cython 0.28.1, @cython.freelist cannot be used for * # classes that derive from a builtin type. * cdef class FUSEError(Exception): # <<<<<<<<<<<<<< * ''' * This exception may be raised by request handlers to indicate that */ struct __pyx_obj_7pyfuse3_FUSEError { PyBaseExceptionObject __pyx_base; int errno_; }; /* "src/handlers.pxi":59 * save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) * * async def fuse_lookup_async (_Container c, name): # <<<<<<<<<<<<<< * cdef EntryAttributes entry * cdef int ret */ struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_entry; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":98 * save_retval(fuse_getattr_async(c)) * * async def fuse_getattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_entry; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":127 * save_retval(fuse_setattr_async(c, fh)) * * async def fuse_setattr_async (_Container c, fh): # <<<<<<<<<<<<<< * cdef int ret * cdef timespec now */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async { PyObject_HEAD struct stat *__pyx_v_attr; struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_entry; PyObject *__pyx_v_fh; struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_fields; struct timespec __pyx_v_now; int __pyx_v_ret; int __pyx_v_to_set; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":184 * save_retval(fuse_readlink_async(c)) * * async def fuse_readlink_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; char *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_v_target; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":209 * save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) * * async def fuse_mknod_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_entry; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":234 * save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) * * async def fuse_mkdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_entry; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":260 * save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) * * async def fuse_unlink_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":281 * save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) * * async def fuse_rmdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":304 * c, PyBytes_FromString(name), PyBytes_FromString(link))) * * async def fuse_symlink_async (_Container c, name, link): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_entry; PyObject *__pyx_v_link; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":332 * * * async def fuse_rename_async (_Container c, name, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef unsigned flags = c.flags */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; unsigned int __pyx_v_flags; PyObject *__pyx_v_name; PyObject *__pyx_v_newname; fuse_ino_t __pyx_v_newparent; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":357 * save_retval(fuse_link_async(c, PyBytes_FromString(newname))) * * async def fuse_link_async (_Container c, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_entry; PyObject *__pyx_v_newname; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":381 * save_retval(fuse_open_async(c)) * * async def fuse_open_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef FileInfo fi */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_fi; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":408 * save_retval(fuse_read_async(c)) * * async def fuse_read_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef Py_buffer pybuf */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async { PyObject_HEAD PyObject *__pyx_v_buf; struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; Py_buffer __pyx_v_pybuf; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":438 * save_retval(fuse_write_async(c, pbuf)) * * async def fuse_write_async (_Container c, pbuf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; size_t __pyx_v_len_; PyObject *__pyx_v_pbuf; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":462 * save_retval(fuse_write_buf_async(c, buf)) * * async def fuse_write_buf_async (_Container c, buf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async { PyObject_HEAD PyObject *__pyx_v_buf; struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; size_t __pyx_v_len_; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":483 * save_retval(fuse_flush_async(c)) * * async def fuse_flush_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":503 * save_retval(fuse_release_async(c)) * * async def fuse_release_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":525 * save_retval(fuse_fsync_async(c)) * * async def fuse_fsync_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":546 * save_retval(fuse_opendir_async(c)) * * async def fuse_opendir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":578 * save_retval(fuse_readdirplus_async(c)) * * async def fuse_readdirplus_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ReaddirToken token = ReaddirToken() */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; int __pyx_v_ret; struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_v_token; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":607 * save_retval(fuse_releasedir_async(c)) * * async def fuse_releasedir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":630 * save_retval(fuse_fsyncdir_async(c)) * * async def fuse_fsyncdir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_e; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":650 * save_retval(fuse_statfs_async(c)) * * async def fuse_statfs_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef StatvfsData stats */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; int __pyx_v_ret; struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_stats; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":681 * save_retval(fuse_setxattr_async(c, name, value)) * * async def fuse_setxattr_async (_Container c, name, value): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_v_value; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; PyObject *__pyx_t_3; PyObject *__pyx_t_4; PyObject *__pyx_t_5; }; /* "src/handlers.pxi":726 * save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) * * async def fuse_getxattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async { PyObject_HEAD PyObject *__pyx_v_buf; struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; char *__pyx_v_cbuf; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; size_t __pyx_v_len_; Py_ssize_t __pyx_v_len_s; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":759 * save_retval(fuse_listxattr_async(c)) * * async def fuse_listxattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async { PyObject_HEAD PyObject *__pyx_v_buf; struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; char *__pyx_v_cbuf; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; size_t __pyx_v_len_; Py_ssize_t __pyx_v_len_s; PyObject *__pyx_v_res; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":797 * save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) * * async def fuse_removexattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":819 * save_retval(fuse_access_async(c)) * * async def fuse_access_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef int mask = c.flags */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async { PyObject_HEAD PyObject *__pyx_v_allowed; struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; int __pyx_v_mask; int __pyx_v_ret; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/handlers.pxi":848 * save_retval(fuse_create_async(c, PyBytes_FromString(name))) * * async def fuse_create_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async { PyObject_HEAD struct __pyx_obj_7pyfuse3__Container *__pyx_v_c; PyObject *__pyx_v_ctx; PyObject *__pyx_v_e; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_entry; struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_fi; PyObject *__pyx_v_name; int __pyx_v_ret; PyObject *__pyx_v_tmp; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; }; /* "src/internal.pxi":201 * cdef _WorkerData worker_data * * async def _wait_fuse_readable(): # <<<<<<<<<<<<<< * '''Wait for FUSE fd to become readable * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable { PyObject_HEAD PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; PyObject *__pyx_t_3; PyObject *__pyx_t_4; PyObject *__pyx_t_5; PyObject *__pyx_t_6; PyObject *__pyx_t_7; PyObject *__pyx_t_8; PyObject *__pyx_t_9; PyObject *__pyx_t_10; PyObject *__pyx_t_11; }; /* "src/internal.pxi":230 * * @async_wrapper * async def _session_loop(nursery, int min_tasks, int max_tasks): # <<<<<<<<<<<<<< * cdef int res * cdef fuse_buf buf */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop { PyObject_HEAD struct fuse_buf __pyx_v_buf; int __pyx_v_max_tasks; int __pyx_v_min_tasks; PyObject *__pyx_v_name; PyObject *__pyx_v_nursery; int __pyx_v_res; }; /* "pyfuse3.pyx":763 * * @async_wrapper * async def main(int min_tasks=1, int max_tasks=99): # <<<<<<<<<<<<<< * '''Run FUSE main loop''' * */ struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main { PyObject_HEAD int __pyx_v_max_tasks; int __pyx_v_min_tasks; PyObject *__pyx_v_nursery; PyObject *__pyx_t_0; PyObject *__pyx_t_1; PyObject *__pyx_t_2; PyObject *__pyx_t_3; PyObject *__pyx_t_4; PyObject *__pyx_t_5; PyObject *__pyx_t_6; PyObject *__pyx_t_7; }; /* "src/internal.pxi":181 * return mem * * cdef class _WorkerData: # <<<<<<<<<<<<<< * """For internal use by pyfuse3 only.""" * */ struct __pyx_vtabstruct_7pyfuse3__WorkerData { PyObject *(*get_name)(struct __pyx_obj_7pyfuse3__WorkerData *); }; static struct __pyx_vtabstruct_7pyfuse3__WorkerData *__pyx_vtabptr_7pyfuse3__WorkerData; /* "pyfuse3.pyx":351 * * @cython.freelist(10) * cdef class FileInfo: # <<<<<<<<<<<<<< * ''' * Instances of this class store options and data that `Operations.open` */ struct __pyx_vtabstruct_7pyfuse3_FileInfo { PyObject *(*_copy_to_fuse)(struct __pyx_obj_7pyfuse3_FileInfo *, struct fuse_file_info *); }; static struct __pyx_vtabstruct_7pyfuse3_FileInfo *__pyx_vtabptr_7pyfuse3_FileInfo; /* --- Runtime support code (head) --- */ /* Refnanny.proto */ #ifndef CYTHON_REFNANNY #define CYTHON_REFNANNY 0 #endif #if CYTHON_REFNANNY typedef struct { void (*INCREF)(void*, PyObject*, int); void (*DECREF)(void*, PyObject*, int); void (*GOTREF)(void*, PyObject*, int); void (*GIVEREF)(void*, PyObject*, int); void* (*SetupContext)(const char*, int, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; #ifdef WITH_THREAD #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) #endif #define __Pyx_RefNannyFinishContext()\ __Pyx_RefNanny->FinishContext(&__pyx_refnanny) #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) #define __Pyx_GOTREF(r) #define __Pyx_GIVEREF(r) #define __Pyx_XINCREF(r) Py_XINCREF(r) #define __Pyx_XDECREF(r) Py_XDECREF(r) #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ } while (0) #define __Pyx_DECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_DECREF(tmp);\ } while (0) #define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) #define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) /* PyObjectGetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) #endif /* GetBuiltinName.proto */ static PyObject *__Pyx_GetBuiltinName(PyObject *name); /* PyObjectCall.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); #else #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif /* PyThreadStateGet.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; #define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; #define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign #define __Pyx_PyErr_Occurred() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) #define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) #define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) #define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #endif #else #define __Pyx_PyErr_Clear() PyErr_Clear() #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) #define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) #define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL #define __Pyx_PyFunction_FastCall(func, args, nargs)\ __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); #else #define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) #endif #define __Pyx_BUILD_ASSERT_EXPR(cond)\ (sizeof(char [1 - 2*!(cond)]) - 1) #ifndef Py_MEMBER_SIZE #define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) #endif static size_t __pyx_pyframe_localsplus_offset = 0; #include "frameobject.h" #define __Pxy_PyFrame_Initialize_Offsets()\ ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) #define __Pyx_PyFrame_GetLocalsplus(frame)\ (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) #endif /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif /* PyObjectCallNoArg.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); #else #define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL) #endif /* PyCFunctionFastCall.proto */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); #else #define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) #endif /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); /* WriteUnraisableException.proto */ static void __Pyx_WriteUnraisable(const char *name, int clineno, int lineno, const char *filename, int full_traceback, int nogil); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS #define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) #define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ (version_var) = __PYX_GET_DICT_VERSION(dict);\ (cache_var) = (value); #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ (VAR) = __pyx_dict_cached_value;\ } else {\ (VAR) = __pyx_dict_cached_value = (LOOKUP);\ __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ }\ } static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); #else #define __PYX_GET_DICT_VERSION(dict) (0) #define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) #define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); #endif /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS #define __Pyx_GetModuleGlobalName(var, name) {\ static PY_UINT64_T __pyx_dict_version = 0;\ static PyObject *__pyx_dict_cached_value = NULL;\ (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } #define __Pyx_GetModuleGlobalNameUncached(var, name) {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ } static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); #else #define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) #define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); #endif /* RaiseArgTupleInvalid.proto */ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); /* RaiseDoubleKeywords.proto */ static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); /* ParseKeywords.proto */ static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\ PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\ const char* function_name); /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ __Pyx__ArgTypeTest(obj, type, name, exact)) static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); /* FetchCommonType.proto */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); /* GetTopmostException.proto */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); #endif /* SaveResetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); #else #define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) #define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) #endif /* SwapException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); #endif /* PyObjectCall2Args.proto */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); /* PyObjectGetMethod.proto */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); /* PyObjectCallMethod1.proto */ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); /* CoroutineBase.proto */ typedef PyObject *(*__pyx_coroutine_body_t)(PyObject *, PyThreadState *, PyObject *); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_ExcInfoStruct _PyErr_StackItem #else typedef struct { PyObject *exc_type; PyObject *exc_value; PyObject *exc_traceback; } __Pyx_ExcInfoStruct; #endif typedef struct { PyObject_HEAD __pyx_coroutine_body_t body; PyObject *closure; __Pyx_ExcInfoStruct gi_exc_state; PyObject *gi_weakreflist; PyObject *classobj; PyObject *yieldfrom; PyObject *gi_name; PyObject *gi_qualname; PyObject *gi_modulename; PyObject *gi_code; int resume_label; char is_running; } __pyx_CoroutineObject; static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name); static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name); static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); static int __Pyx_Coroutine_clear(PyObject *self); static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); static PyObject *__Pyx_Coroutine_Close(PyObject *self); static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); #if CYTHON_USE_EXC_INFO_STACK #define __Pyx_Coroutine_SwapException(self) #define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) #else #define __Pyx_Coroutine_SwapException(self) {\ __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ } #define __Pyx_Coroutine_ResetAndClearException(self) {\ __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ } #endif #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) #else #define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) #endif static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr #endif /* PatchModuleWithCoroutine.proto */ static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code); /* PatchGeneratorABC.proto */ static int __Pyx_patch_abc(void); /* Coroutine.proto */ #define __Pyx_Coroutine_USED static PyTypeObject *__pyx_CoroutineType = 0; static PyTypeObject *__pyx_CoroutineAwaitType = 0; #define __Pyx_Coroutine_CheckExact(obj) (Py_TYPE(obj) == __pyx_CoroutineType) #define __Pyx_Coroutine_Check(obj) __Pyx_Coroutine_CheckExact(obj) #define __Pyx_CoroutineAwait_CheckExact(obj) (Py_TYPE(obj) == __pyx_CoroutineAwaitType) #define __Pyx_Coroutine_New(body, code, closure, name, qualname, module_name)\ __Pyx__Coroutine_New(__pyx_CoroutineType, body, code, closure, name, qualname, module_name) static int __pyx_Coroutine_init(void); static PyObject *__Pyx__Coroutine_await(PyObject *coroutine); typedef struct { PyObject_HEAD PyObject *coroutine; } __pyx_CoroutineAwaitObject; static PyObject *__Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self, PyObject *arg); static PyObject *__Pyx_CoroutineAwait_Throw(__pyx_CoroutineAwaitObject *self, PyObject *args); /* GetAwaitIter.proto */ static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o); static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *o); /* CoroutineYieldFrom.proto */ static CYTHON_INLINE PyObject* __Pyx_Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source); /* ExtTypeTest.proto */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); /* PyErrExceptionMatches.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); #else #define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif /* GetException.proto */ #if CYTHON_FAST_THREAD_STATE #define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); #endif /* ListAppend.proto */ #if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { PyListObject* L = (PyListObject*) list; Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); PyList_SET_ITEM(list, len, x); __Pyx_SET_SIZE(list, len + 1); return 0; } return PyList_Append(list, x); } #else #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #endif /* IncludeStringH.proto */ #include /* BytesEquals.proto */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); /* UnicodeEquals.proto */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); /* StringJoin.proto */ #if PY_MAJOR_VERSION < 3 #define __Pyx_PyString_Join __Pyx_PyBytes_Join #define __Pyx_PyBaseString_Join(s, v) (PyUnicode_CheckExact(s) ? PyUnicode_Join(s, v) : __Pyx_PyBytes_Join(s, v)) #else #define __Pyx_PyString_Join PyUnicode_Join #define __Pyx_PyBaseString_Join PyUnicode_Join #endif #if CYTHON_COMPILING_IN_CPYTHON #if PY_MAJOR_VERSION < 3 #define __Pyx_PyBytes_Join _PyString_Join #else #define __Pyx_PyBytes_Join _PyBytes_Join #endif #else static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values); #endif /* GetItemInt.proto */ #define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ __Pyx_GetItemInt_Generic(o, to_py_func(i)))) #define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); #define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, int wraparound, int boundscheck); static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, int wraparound, int boundscheck); /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); /* RaiseNeedMoreValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); /* IterFinish.proto */ static CYTHON_INLINE int __Pyx_IterFinish(void); /* UnpackItemEndCheck.proto */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); /* KeywordStringCheck.proto */ static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); /* GetAttr.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); /* PyObjectLookupSpecial.proto */ #if CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_LookupSpecial(PyObject* obj, PyObject* attr_name) { PyObject *res; PyTypeObject *tp = Py_TYPE(obj); #if PY_MAJOR_VERSION < 3 if (unlikely(PyInstance_Check(obj))) return __Pyx_PyObject_GetAttrStr(obj, attr_name); #endif res = _PyType_Lookup(tp, attr_name); if (likely(res)) { descrgetfunc f = Py_TYPE(res)->tp_descr_get; if (!f) { Py_INCREF(res); } else { res = f(res, obj, (PyObject *)tp); } } else { PyErr_SetObject(PyExc_AttributeError, attr_name); } return res; } #else #define __Pyx_PyObject_LookupSpecial(o,n) __Pyx_PyObject_GetAttrStr(o,n) #endif /* ReturnWithStopIteration.proto */ #define __Pyx_ReturnWithStopIteration(value)\ if (value == Py_None) PyErr_SetNone(PyExc_StopIteration); else __Pyx__ReturnWithStopIteration(value) static void __Pyx__ReturnWithStopIteration(PyObject* value); /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); #else #define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) #define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) #define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) #endif #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* PyObjectCallMethod0.proto */ static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); /* RaiseNoneIterError.proto */ static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); /* UnpackTupleError.proto */ static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); /* UnpackTuple2.proto */ #define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\ (likely(is_tuple || PyTuple_Check(tuple)) ?\ (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\ __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\ (__Pyx_UnpackTupleError(tuple, 2), -1)) :\ __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple)) static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); static int __Pyx_unpack_tuple2_generic( PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); /* dict_iter.proto */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_is_dict); static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); /* PyObjectSetAttrStr.proto */ #if CYTHON_USE_TYPE_SLOTS #define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); #else #define __Pyx_PyObject_DelAttrStr(o,n) PyObject_DelAttr(o,n) #define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) #endif /* None.proto */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); /* SliceObject.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice( PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** py_start, PyObject** py_stop, PyObject** py_slice, int has_cstart, int has_cstop, int wraparound); /* Import.proto */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); /* HasAttr.proto */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); /* PyObject_GenericGetAttr.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); #else #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif /* PyObjectGetAttrStrNoError.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); /* SetupReduce.proto */ static int __Pyx_setup_reduce(PyObject* type_obj); /* SetVTable.proto */ static int __Pyx_SetVtable(PyObject *dict, void *vtable); /* TypeImport.proto */ #ifndef __PYX_HAVE_RT_ImportType_proto #define __PYX_HAVE_RT_ImportType_proto enum __Pyx_ImportType_CheckSize { __Pyx_ImportType_CheckSize_Error = 0, __Pyx_ImportType_CheckSize_Warn = 1, __Pyx_ImportType_CheckSize_Ignore = 2 }; static PyTypeObject *__Pyx_ImportType(PyObject* module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size); #endif /* decode_c_string_utf16.proto */ static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 0; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { int byteorder = -1; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { int byteorder = 1; return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); } /* decode_c_string.proto */ static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); /* Globals.proto */ static PyObject* __Pyx_Globals(void); /* pyfrozenset_new.proto */ static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK #define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) #else static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ typedef struct { PyCodeObject* code_object; int code_line; } __Pyx_CodeObjectCacheEntry; struct __Pyx_CodeObjectCache { int count; int max_count; __Pyx_CodeObjectCacheEntry* entries; }; static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); static PyCodeObject *__pyx_find_code_object(int code_line); static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_gid_t(gid_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_pid_t(pid_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uid_t(uid_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_mode_t(mode_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fuse_ino_t(fuse_ino_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_dev_t(dev_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_off_t(off_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_nlink_t(nlink_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_blkcnt_t(blkcnt_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_blksize_t(blksize_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fsblkcnt_t(fsblkcnt_t value); /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fsfilcnt_t(fsfilcnt_t value); /* CIntFromPy.proto */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE gid_t __Pyx_PyInt_As_gid_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE pid_t __Pyx_PyInt_As_pid_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE uid_t __Pyx_PyInt_As_uid_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE mode_t __Pyx_PyInt_As_mode_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE fuse_ino_t __Pyx_PyInt_As_fuse_ino_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE off_t __Pyx_PyInt_As_off_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE ino_t __Pyx_PyInt_As_ino_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE nlink_t __Pyx_PyInt_As_nlink_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE dev_t __Pyx_PyInt_As_dev_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE blkcnt_t __Pyx_PyInt_As_blkcnt_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE blksize_t __Pyx_PyInt_As_blksize_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE fsblkcnt_t __Pyx_PyInt_As_fsblkcnt_t(PyObject *); /* CIntFromPy.proto */ static CYTHON_INLINE fsfilcnt_t __Pyx_PyInt_As_fsfilcnt_t(PyObject *); /* CheckBinaryVersion.proto */ static int __Pyx_check_binary_version(void); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); static PyObject *__pyx_f_7pyfuse3_11_WorkerData_get_name(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_self); /* proto*/ static PyObject *__pyx_f_7pyfuse3_8FileInfo__copy_to_fuse(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, struct fuse_file_info *__pyx_v_out); /* proto*/ /* Module declarations from 'fuse_opt' */ /* Module declarations from 'posix.types' */ /* Module declarations from 'libc.stdint' */ /* Module declarations from 'fuse_common' */ /* Module declarations from 'posix.stat' */ /* Module declarations from 'posix.signal' */ /* Module declarations from 'posix.time' */ /* Module declarations from 'libc_extra' */ /* Module declarations from 'libc.string' */ /* Module declarations from 'libc.stdlib' */ /* Module declarations from 'fuse_lowlevel' */ /* Module declarations from 'macros' */ /* Module declarations from 'libc' */ /* Module declarations from 'libc.errno' */ /* Module declarations from 'posix' */ /* Module declarations from 'posix.unistd' */ /* Module declarations from 'libc.stdio' */ /* Module declarations from '__builtin__' */ /* Module declarations from 'cpython.type' */ static PyTypeObject *__pyx_ptype_7cpython_4type_type = 0; /* Module declarations from 'cpython.exc' */ /* Module declarations from 'cpython' */ /* Module declarations from 'cpython.object' */ /* Module declarations from 'cpython.bytes' */ /* Module declarations from 'cpython.buffer' */ /* Module declarations from 'cython' */ /* Module declarations from 'pyfuse3' */ static PyTypeObject *__pyx_ptype_7pyfuse3__Container = 0; static PyTypeObject *__pyx_ptype_7pyfuse3_ReaddirToken = 0; static PyTypeObject *__pyx_ptype_7pyfuse3__WorkerData = 0; static PyTypeObject *__pyx_ptype_7pyfuse3_RequestContext = 0; static PyTypeObject *__pyx_ptype_7pyfuse3_SetattrFields = 0; static PyTypeObject *__pyx_ptype_7pyfuse3_EntryAttributes = 0; static PyTypeObject *__pyx_ptype_7pyfuse3_FileInfo = 0; static PyTypeObject *__pyx_ptype_7pyfuse3_StatvfsData = 0; static PyTypeObject *__pyx_ptype_7pyfuse3_FUSEError = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct__fuse_lookup_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_9_fuse_rename_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_10_fuse_link_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_11_fuse_open_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_12_fuse_read_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_13_fuse_write_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_15_fuse_flush_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_16_fuse_release_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_27_fuse_access_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_28_fuse_create_async = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_30__session_loop = 0; static PyTypeObject *__pyx_ptype_7pyfuse3___pyx_scope_struct_31_main = 0; static PyObject *__pyx_v_7pyfuse3_operations = 0; static PyObject *__pyx_v_7pyfuse3_mountpoint_b = 0; static struct fuse_session *__pyx_v_7pyfuse3_session; static struct fuse_lowlevel_ops __pyx_v_7pyfuse3_fuse_ops; static int __pyx_v_7pyfuse3_session_fd; static PyObject *__pyx_v_7pyfuse3_py_retval = 0; static PyObject *__pyx_v_7pyfuse3__notify_queue = 0; static struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_7pyfuse3_worker_data = 0; static void __pyx_f_7pyfuse3_fuse_init(void *, struct fuse_conn_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_lookup(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_forget(fuse_req_t, fuse_ino_t, uint64_t); /*proto*/ static void __pyx_f_7pyfuse3_fuse_forget_multi(fuse_req_t, size_t, struct fuse_forget_data *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_getattr(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_setattr(fuse_req_t, fuse_ino_t, struct stat *, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_readlink(fuse_req_t, fuse_ino_t); /*proto*/ static void __pyx_f_7pyfuse3_fuse_mknod(fuse_req_t, fuse_ino_t, const char *, mode_t, dev_t); /*proto*/ static void __pyx_f_7pyfuse3_fuse_mkdir(fuse_req_t, fuse_ino_t, const char *, mode_t); /*proto*/ static void __pyx_f_7pyfuse3_fuse_unlink(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_rmdir(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_symlink(fuse_req_t, const char *, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_rename(fuse_req_t, fuse_ino_t, const char *, fuse_ino_t, const char *, unsigned int); /*proto*/ static void __pyx_f_7pyfuse3_fuse_link(fuse_req_t, fuse_ino_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_open(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_read(fuse_req_t, fuse_ino_t, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_write(fuse_req_t, fuse_ino_t, const char *, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_write_buf(fuse_req_t, fuse_ino_t, struct fuse_bufvec *, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_flush(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_release(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_fsync(fuse_req_t, fuse_ino_t, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_opendir(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_readdirplus(fuse_req_t, fuse_ino_t, size_t, off_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_releasedir(fuse_req_t, fuse_ino_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_fsyncdir(fuse_req_t, fuse_ino_t, int, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_statfs(fuse_req_t, fuse_ino_t); /*proto*/ static void __pyx_f_7pyfuse3_fuse_setxattr(fuse_req_t, fuse_ino_t, const char *, const char *, size_t, int); /*proto*/ static void __pyx_f_7pyfuse3_fuse_getxattr(fuse_req_t, fuse_ino_t, const char *, size_t); /*proto*/ static void __pyx_f_7pyfuse3_fuse_listxattr(fuse_req_t, fuse_ino_t, size_t); /*proto*/ static void __pyx_f_7pyfuse3_fuse_removexattr(fuse_req_t, fuse_ino_t, const char *); /*proto*/ static void __pyx_f_7pyfuse3_fuse_access(fuse_req_t, fuse_ino_t, int); /*proto*/ static void __pyx_f_7pyfuse3_fuse_create(fuse_req_t, fuse_ino_t, const char *, mode_t, struct fuse_file_info *); /*proto*/ static void __pyx_f_7pyfuse3_save_retval(PyObject *); /*proto*/ static PyObject *__pyx_f_7pyfuse3_get_request_context(fuse_req_t); /*proto*/ static void __pyx_f_7pyfuse3_init_fuse_ops(void); /*proto*/ static PyObject *__pyx_f_7pyfuse3_make_fuse_args(PyObject *, struct fuse_args *); /*proto*/ static PyObject *__pyx_f_7pyfuse3_str2bytes(PyObject *); /*proto*/ static PyObject *__pyx_f_7pyfuse3_bytes2str(PyObject *); /*proto*/ static PyObject *__pyx_f_7pyfuse3_strerror(int); /*proto*/ static PyObject *__pyx_f_7pyfuse3_PyBytes_from_bufvec(struct fuse_bufvec *); /*proto*/ static void *__pyx_f_7pyfuse3_calloc_or_raise(size_t, size_t); /*proto*/ static PyObject *__pyx_f_7pyfuse3___pyx_unpickle__WorkerData__set_state(struct __pyx_obj_7pyfuse3__WorkerData *, PyObject *); /*proto*/ static PyObject *__pyx_f_7pyfuse3___pyx_unpickle_RequestContext__set_state(struct __pyx_obj_7pyfuse3_RequestContext *, PyObject *); /*proto*/ #define __Pyx_MODULE_NAME "pyfuse3" extern int __pyx_module_is_main_pyfuse3; int __pyx_module_is_main_pyfuse3 = 0; /* Implementation of 'pyfuse3' */ static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_RuntimeError; static PyObject *__pyx_builtin_OverflowError; static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_enumerate; static PyObject *__pyx_builtin_range; static PyObject *__pyx_builtin_OSError; static PyObject *__pyx_builtin_MemoryError; static PyObject *__pyx_builtin_open; static const char __pyx_k_c[] = "c"; static const char __pyx_k_e[] = "e"; static const char __pyx_k_g[] = "g"; static const char __pyx_k_o[] = "-o"; static const char __pyx_k_r[] = "r"; static const char __pyx_k_t[] = "t"; static const char __pyx_k_x[] = "x"; static const char __pyx_k_fd[] = "fd"; static const char __pyx_k_fh[] = "fh"; static const char __pyx_k_fi[] = "fi"; static const char __pyx_k_os[] = "os"; static const char __pyx_k__33[] = "\000"; static const char __pyx_k_buf[] = "buf"; static const char __pyx_k_ctx[] = "ctx"; static const char __pyx_k_exc[] = "exc"; static const char __pyx_k_fse[] = "fse"; static const char __pyx_k_get[] = "get"; static const char __pyx_k_ino[] = "ino"; static const char __pyx_k_len[] = "len_"; static const char __pyx_k_log[] = "log"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_now[] = "now"; static const char __pyx_k_off[] = "off"; static const char __pyx_k_ops[] = "ops"; static const char __pyx_k_pid[] = "pid"; static const char __pyx_k_put[] = "put"; static const char __pyx_k_req[] = "req"; static const char __pyx_k_res[] = "res"; static const char __pyx_k_ret[] = "ret"; static const char __pyx_k_sys[] = "sys"; static const char __pyx_k_tmp[] = "tmp"; static const char __pyx_k_Lock[] = "Lock"; static const char __pyx_k_args[] = "args"; static const char __pyx_k_attr[] = "attr"; static const char __pyx_k_cbuf[] = "cbuf"; static const char __pyx_k_data[] = "data"; static const char __pyx_k_dict[] = "__dict__"; static const char __pyx_k_dirp[] = "dirp"; static const char __pyx_k_exit[] = "__exit__"; static const char __pyx_k_gids[] = "gids"; static const char __pyx_k_init[] = "init"; static const char __pyx_k_join[] = "join"; static const char __pyx_k_line[] = "line"; static const char __pyx_k_link[] = "link"; static const char __pyx_k_main[] = "main"; static const char __pyx_k_mask[] = "mask"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_open[] = "open"; static const char __pyx_k_path[] = "path"; static const char __pyx_k_pbuf[] = "pbuf"; static const char __pyx_k_read[] = "read"; static const char __pyx_k_send[] = "send"; static const char __pyx_k_slen[] = "slen"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_trio[] = "trio"; static const char __pyx_k_user[] = "user"; static const char __pyx_k_Queue[] = "Queue"; static const char __pyx_k_aexit[] = "__aexit__"; static const char __pyx_k_await[] = "__await__"; static const char __pyx_k_close[] = "close"; static const char __pyx_k_cname[] = "cname"; static const char __pyx_k_cpath[] = "cpath"; static const char __pyx_k_debug[] = "debug"; static const char __pyx_k_enter[] = "__enter__"; static const char __pyx_k_entry[] = "entry"; static const char __pyx_k_errno[] = "errno"; static const char __pyx_k_error[] = "error"; static const char __pyx_k_flags[] = "flags"; static const char __pyx_k_flush[] = "flush"; static const char __pyx_k_fsync[] = "fsync"; static const char __pyx_k_inode[] = "inode"; static const char __pyx_k_items[] = "items"; static const char __pyx_k_len_s[] = "len_s"; static const char __pyx_k_mkdir[] = "mkdir"; static const char __pyx_k_mknod[] = "mknod"; static const char __pyx_k_names[] = "names"; static const char __pyx_k_pybuf[] = "pybuf"; static const char __pyx_k_queue[] = "queue"; static const char __pyx_k_range[] = "range"; static const char __pyx_k_rmdir[] = "rmdir"; static const char __pyx_k_split[] = "split"; static const char __pyx_k_start[] = "start"; static const char __pyx_k_stats[] = "stats"; static const char __pyx_k_throw[] = "throw"; static const char __pyx_k_token[] = "token"; static const char __pyx_k_value[] = "value"; static const char __pyx_k_write[] = "write"; static const char __pyx_k_Groups[] = "Groups:"; static const char __pyx_k_Thread[] = "Thread"; static const char __pyx_k_access[] = "access"; static const char __pyx_k_aenter[] = "__aenter__"; static const char __pyx_k_bufvec[] = "bufvec"; static const char __pyx_k_create[] = "create"; static const char __pyx_k_cvalue[] = "cvalue"; static const char __pyx_k_daemon[] = "daemon"; static const char __pyx_k_decode[] = "decode"; static const char __pyx_k_encode[] = "encode"; static const char __pyx_k_f_args[] = "f_args"; static const char __pyx_k_fields[] = "fields"; static const char __pyx_k_forget[] = "forget"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_lookup[] = "lookup"; static const char __pyx_k_main_2[] = "__main__"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_name_b[] = "name_b"; static const char __pyx_k_offset[] = "offset"; static const char __pyx_k_path_b[] = "path_b"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; static const char __pyx_k_rename[] = "rename"; static const char __pyx_k_st_gid[] = "st_gid"; static const char __pyx_k_st_ino[] = "st_ino"; static const char __pyx_k_st_uid[] = "st_uid"; static const char __pyx_k_statfs[] = "statfs"; static const char __pyx_k_syncfs[] = "syncfs"; static const char __pyx_k_system[] = "system"; static const char __pyx_k_target[] = "target"; static const char __pyx_k_to_set[] = "to_set"; static const char __pyx_k_unlink[] = "unlink"; static const char __pyx_k_update[] = "update"; static const char __pyx_k_ENOATTR[] = "ENOATTR"; static const char __pyx_k_OSError[] = "OSError"; static const char __pyx_k_abspath[] = "abspath"; static const char __pyx_k_allowed[] = "allowed"; static const char __pyx_k_bufsize[] = "bufsize"; static const char __pyx_k_deleted[] = "deleted"; static const char __pyx_k_errno_d[] = "errno: %d"; static const char __pyx_k_f_bfree[] = "f_bfree"; static const char __pyx_k_f_bsize[] = "f_bsize"; static const char __pyx_k_f_ffree[] = "f_ffree"; static const char __pyx_k_f_files[] = "f_files"; static const char __pyx_k_getattr[] = "getattr"; static const char __pyx_k_inode_p[] = "inode_p"; static const char __pyx_k_listdir[] = "listdir"; static const char __pyx_k_logging[] = "logging"; static const char __pyx_k_newname[] = "newname"; static const char __pyx_k_next_id[] = "next_id"; static const char __pyx_k_nursery[] = "nursery"; static const char __pyx_k_opendir[] = "opendir"; static const char __pyx_k_options[] = "options"; static const char __pyx_k_os_path[] = "os.path"; static const char __pyx_k_pyfuse3[] = "pyfuse3"; static const char __pyx_k_readdir[] = "readdir"; static const char __pyx_k_release[] = "release"; static const char __pyx_k_setattr[] = "setattr"; static const char __pyx_k_st_mode[] = "st_mode"; static const char __pyx_k_st_rdev[] = "st_rdev"; static const char __pyx_k_st_size[] = "st_size"; static const char __pyx_k_symlink[] = "symlink"; static const char __pyx_k_unmount[] = "unmount"; static const char __pyx_k_version[] = "__version__"; static const char __pyx_k_FileInfo[] = "FileInfo"; static const char __pyx_k_f_bavail[] = "f_bavail"; static const char __pyx_k_f_blocks[] = "f_blocks"; static const char __pyx_k_f_favail[] = "f_favail"; static const char __pyx_k_f_frsize[] = "f_frsize"; static const char __pyx_k_fsyncdir[] = "fsyncdir"; static const char __pyx_k_getstate[] = "__getstate__"; static const char __pyx_k_getxattr[] = "getxattr"; static const char __pyx_k_lowlevel[] = "lowlevel"; static const char __pyx_k_pyx_type[] = "__pyx_type"; static const char __pyx_k_readlink[] = "readlink"; static const char __pyx_k_setstate[] = "__setstate__"; static const char __pyx_k_setxattr[] = "setxattr"; static const char __pyx_k_st_nlink[] = "st_nlink"; static const char __pyx_k_strerror[] = "strerror"; static const char __pyx_k_us_ascii[] = "us-ascii"; static const char __pyx_k_Container[] = "_Container"; static const char __pyx_k_FUSEError[] = "FUSEError"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_attr_only[] = "attr_only"; static const char __pyx_k_direct_io[] = "direct_io"; static const char __pyx_k_enumerate[] = "enumerate"; static const char __pyx_k_exception[] = "exception"; static const char __pyx_k_f_namemax[] = "f_namemax"; static const char __pyx_k_getLogger[] = "getLogger"; static const char __pyx_k_listxattr[] = "listxattr"; static const char __pyx_k_max_tasks[] = "max_tasks"; static const char __pyx_k_min_tasks[] = "min_tasks"; static const char __pyx_k_namespace[] = "namespace"; static const char __pyx_k_newparent[] = "newparent"; static const char __pyx_k_pyfuse3_2[] = "_pyfuse3"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; static const char __pyx_k_st_blocks[] = "st_blocks"; static const char __pyx_k_terminate[] = "terminate"; static const char __pyx_k_threading[] = "threading"; static const char __pyx_k_Operations[] = "Operations"; static const char __pyx_k_ROOT_INODE[] = "ROOT_INODE"; static const char __pyx_k_ValueError[] = "ValueError"; static const char __pyx_k_WorkerData[] = "_WorkerData"; static const char __pyx_k_cnamespace[] = "cnamespace"; static const char __pyx_k_enable_acl[] = "enable_acl"; static const char __pyx_k_generation[] = "generation"; static const char __pyx_k_keep_cache[] = "keep_cache"; static const char __pyx_k_mountpoint[] = "mountpoint"; static const char __pyx_k_pyfuse_02d[] = "pyfuse-%02d"; static const char __pyx_k_pyx_result[] = "__pyx_result"; static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; static const char __pyx_k_releasedir[] = "releasedir"; static const char __pyx_k_size_guess[] = "size_guess"; static const char __pyx_k_st_blksize[] = "st_blksize"; static const char __pyx_k_stacktrace[] = "stacktrace"; static const char __pyx_k_start_soon[] = "start_soon"; static const char __pyx_k_startswith[] = "startswith"; static const char __pyx_k_trio_token[] = "trio_token"; static const char __pyx_k_MemoryError[] = "MemoryError"; static const char __pyx_k_O_DIRECTORY[] = "O_DIRECTORY"; static const char __pyx_k_PickleError[] = "PickleError"; static const char __pyx_k_StatvfsData[] = "StatvfsData"; static const char __pyx_k_nonseekable[] = "nonseekable"; static const char __pyx_k_notify_loop[] = "_notify_loop"; static const char __pyx_k_removexattr[] = "removexattr"; static const char __pyx_k_st_atime_ns[] = "st_atime_ns"; static const char __pyx_k_st_ctime_ns[] = "st_ctime_ns"; static const char __pyx_k_st_mtime_ns[] = "st_mtime_ns"; static const char __pyx_k_ReaddirToken[] = "ReaddirToken"; static const char __pyx_k_RuntimeError[] = "RuntimeError"; static const char __pyx_k_attr_timeout[] = "attr_timeout"; static const char __pyx_k_current_task[] = "current_task"; static const char __pyx_k_notify_store[] = "notify_store"; static const char __pyx_k_open_nursery[] = "open_nursery"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; static const char __pyx_k_s_terminated[] = "%s: terminated"; static const char __pyx_k_session_loop[] = "_session_loop"; static const char __pyx_k_stringsource[] = "stringsource"; static const char __pyx_k_NANOS_PER_SEC[] = "_NANOS_PER_SEC"; static const char __pyx_k_OverflowError[] = "OverflowError"; static const char __pyx_k_PicklingError[] = "PicklingError"; static const char __pyx_k_SetattrFields[] = "SetattrFields"; static const char __pyx_k_async_wrapper[] = "async_wrapper"; static const char __pyx_k_entry_timeout[] = "entry_timeout"; static const char __pyx_k_ignore_enoent[] = "ignore_enoent"; static const char __pyx_k_proc_d_status[] = "/proc/%d/status"; static const char __pyx_k_readdir_reply[] = "readdir_reply"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_wait_readable[] = "wait_readable"; static const char __pyx_k_RequestContext[] = "RequestContext"; static const char __pyx_k_get_sup_groups[] = "get_sup_groups"; static const char __pyx_k_notify_closing[] = "notify_closing"; static const char __pyx_k_EntryAttributes[] = "EntryAttributes"; static const char __pyx_k_RENAME_EXCHANGE[] = "RENAME_EXCHANGE"; static const char __pyx_k_default_options[] = "default_options"; static const char __pyx_k_fuse_link_async[] = "fuse_link_async"; static const char __pyx_k_fuse_open_async[] = "fuse_open_async"; static const char __pyx_k_fuse_read_async[] = "fuse_read_async"; static const char __pyx_k_fuse_stacktrace[] = "fuse_stacktrace"; static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; static const char __pyx_k_src_pyfuse3_pyx[] = "src/pyfuse3.pyx"; static const char __pyx_k_st_birthtime_ns[] = "st_birthtime_ns"; static const char __pyx_k_surrogateescape[] = "surrogateescape"; static const char __pyx_k_RENAME_NOREPLACE[] = "RENAME_NOREPLACE"; static const char __pyx_k_fuse_flush_async[] = "fuse_flush_async"; static const char __pyx_k_fuse_fsync_async[] = "fuse_fsync_async"; static const char __pyx_k_fuse_mkdir_async[] = "fuse_mkdir_async"; static const char __pyx_k_fuse_mknod_async[] = "fuse_mknod_async"; static const char __pyx_k_fuse_rmdir_async[] = "fuse_rmdir_async"; static const char __pyx_k_fuse_write_async[] = "fuse_write_async"; static const char __pyx_k_invalidate_entry[] = "invalidate_entry"; static const char __pyx_k_invalidate_inode[] = "invalidate_inode"; static const char __pyx_k_src_handlers_pxi[] = "src/handlers.pxi"; static const char __pyx_k_src_internal_pxi[] = "src/internal.pxi"; static const char __pyx_k_unknown_flag_s_o[] = "unknown flag(s): %o"; static const char __pyx_k_FileNotFoundError[] = "FileNotFoundError"; static const char __pyx_k_Unable_to_parse_s[] = "Unable to parse %s"; static const char __pyx_k_fuse_access_async[] = "fuse_access_async"; static const char __pyx_k_fuse_create_async[] = "fuse_create_async"; static const char __pyx_k_fuse_lookup_async[] = "fuse_lookup_async"; static const char __pyx_k_fuse_rename_async[] = "fuse_rename_async"; static const char __pyx_k_fuse_statfs_async[] = "fuse_statfs_async"; static const char __pyx_k_fuse_unlink_async[] = "fuse_unlink_async"; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; static const char __pyx_k_current_trio_token[] = "current_trio_token"; static const char __pyx_k_fuse_getattr_async[] = "fuse_getattr_async"; static const char __pyx_k_fuse_opendir_async[] = "fuse_opendir_async"; static const char __pyx_k_fuse_release_async[] = "fuse_release_async"; static const char __pyx_k_fuse_setattr_async[] = "fuse_setattr_async"; static const char __pyx_k_fuse_symlink_async[] = "fuse_symlink_async"; static const char __pyx_k_wait_fuse_readable[] = "_wait_fuse_readable"; static const char __pyx_k_ClosedResourceError[] = "ClosedResourceError"; static const char __pyx_k_default_permissions[] = "default_permissions"; static const char __pyx_k_fuse_fsyncdir_async[] = "fuse_fsyncdir_async"; static const char __pyx_k_fuse_getxattr_async[] = "fuse_getxattr_async"; static const char __pyx_k_fuse_readlink_async[] = "fuse_readlink_async"; static const char __pyx_k_fuse_setxattr_async[] = "fuse_setxattr_async"; static const char __pyx_k_supports_dot_lookup[] = "supports_dot_lookup"; static const char __pyx_k_Initializing_pyfuse3[] = "Initializing pyfuse3"; static const char __pyx_k_fuse_listxattr_async[] = "fuse_listxattr_async"; static const char __pyx_k_fuse_write_buf_async[] = "fuse_write_buf_async"; static const char __pyx_k_fuse_releasedir_async[] = "fuse_releasedir_async"; static const char __pyx_k_getfilesystemencoding[] = "getfilesystemencoding"; static const char __pyx_k_Starting_notify_worker[] = "Starting notify worker."; static const char __pyx_k_enable_writeback_cache[] = "enable_writeback_cache"; static const char __pyx_k_fuse_readdirplus_async[] = "fuse_readdirplus_async"; static const char __pyx_k_fuse_removexattr_async[] = "fuse_removexattr_async"; static const char __pyx_k_invalidate_entry_async[] = "invalidate_entry_async"; static const char __pyx_k_fuse_session_new_failed[] = "fuse_session_new() failed"; static const char __pyx_k_Calling_fuse_session_new[] = "Calling fuse_session_new"; static const char __pyx_k_pyx_unpickle__WorkerData[] = "__pyx_unpickle__WorkerData"; static const char __pyx_k_fuse_buf_copy_failed_with[] = "fuse_buf_copy failed with "; static const char __pyx_k_fuse_session_mount_failed[] = "fuse_session_mount failed"; static const char __pyx_k_terminating_notify_thread[] = "terminating notify thread"; static const char __pyx_k_Calling_fuse_session_mount[] = "Calling fuse_session_mount"; static const char __pyx_k_FUSE_fd_about_to_be_closed[] = "FUSE fd about to be closed."; static const char __pyx_k_pyx_unpickle_RequestContext[] = "__pyx_unpickle_RequestContext"; static const char __pyx_k_Calling_fuse_session_destroy[] = "Calling fuse_session_destroy"; static const char __pyx_k_Calling_fuse_session_unmount[] = "Calling fuse_session_unmount"; static const char __pyx_k_Need_to_call_init_before_main[] = "Need to call init() before main()"; static const char __pyx_k_Kernel_too_old_pyfuse3_requires[] = "Kernel too old, pyfuse3 requires kernel 3.9 or newer!"; static const char __pyx_k_fuse_getattr_fuse_reply__failed[] = "fuse_getattr(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_opendir_fuse_reply__failed[] = "fuse_opendir(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_release_fuse_reply__failed[] = "fuse_release(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_session_receive_buf_failed[] = "fuse_session_receive_buf failed with "; static const char __pyx_k_fuse_setattr_fuse_reply__failed[] = "fuse_setattr(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_symlink_fuse_reply__failed[] = "fuse_symlink(): fuse_reply_* failed with %s"; static const char __pyx_k_mountpoint__argument_must_be_of[] = "*mountpoint_* argument must be of type str"; static const char __pyx_k_name_argument_must_be_of_type_s[] = "*name* argument must be of type str"; static const char __pyx_k_namespace_parameter_must_be_sys[] = "*namespace* parameter must be \"system\" or \"user\", not %s"; static const char __pyx_k_path_argument_must_be_of_type_s[] = "*path* argument must be of type str"; static const char __pyx_k_pyfuse3_pxy_Copyright_2013_Niko[] = "\npyfuse3.pxy\n\nCopyright \302\251 2013 Nikolaus Rath \n\nThis file is part of pyfuse3. This work may be distributed under\nthe terms of the GNU LGPL.\n"; static const char __pyx_k_s_No_tasks_waiting_starting_ano[] = "%s: No tasks waiting, starting another worker (now %d total)."; static const char __pyx_k_s_too_many_idle_tasks_d_total_d[] = "%s: too many idle tasks (%d total, %d waiting), terminating."; static const char __pyx_k_self_req_cannot_be_converted_to[] = "self.req cannot be converted to a Python object for pickling"; static const char __pyx_k_FUSE_session_exit_flag_set_while[] = "FUSE session exit flag set while waiting for FUSE fd to become readable."; static const char __pyx_k_Failed_to_submit_invalidate_entr[] = "Failed to submit invalidate_entry request for parent inode %d, name %s"; static const char __pyx_k_Incompatible_checksums_s_vs_0x22[] = "Incompatible checksums (%s vs 0x223b7a8 = (gid, pid, uid, umask))"; static const char __pyx_k_Incompatible_checksums_s_vs_0xe8[] = "Incompatible checksums (%s vs 0xe8d9c4e = (active_readers, read_lock, task_count, task_serial))"; static const char __pyx_k_RequestContext_instances_can_t_b[] = "RequestContext instances can't be pickled"; static const char __pyx_k_SetattrFields_instances_can_t_be[] = "SetattrFields instances can't be pickled"; static const char __pyx_k_Value_too_long_to_convert_to_Pyt[] = "Value too long to convert to Python"; static const char __pyx_k_fuse_access_fuse_reply__failed_w[] = "fuse_access(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_create_fuse_reply__failed_w[] = "fuse_create(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_flush_fuse_reply__failed_wi[] = "fuse_flush(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_fsync_fuse_reply__failed_wi[] = "fuse_fsync(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_fsyncdir_fuse_reply__failed[] = "fuse_fsyncdir(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_getxattr_fuse_reply__failed[] = "fuse_getxattr(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_link_fuse_reply__failed_wit[] = "fuse_link(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_listxattr_fuse_reply__faile[] = "fuse_listxattr(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_lookup_fuse_reply__failed_w[] = "fuse_lookup(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_lowlevel_notify_delete_retu[] = "fuse_lowlevel_notify_delete returned: "; static const char __pyx_k_fuse_lowlevel_notify_inval_entry[] = "fuse_lowlevel_notify_inval_entry returned: "; static const char __pyx_k_fuse_lowlevel_notify_inval_inode[] = "fuse_lowlevel_notify_inval_inode returned: "; static const char __pyx_k_fuse_lowlevel_notify_store_retur[] = "fuse_lowlevel_notify_store returned: "; static const char __pyx_k_fuse_mkdir_fuse_reply__failed_wi[] = "fuse_mkdir(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_mknod_fuse_reply__failed_wi[] = "fuse_mknod(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_read_fuse_reply__failed_wit[] = "fuse_read(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_readdirplus_fuse_reply__fai[] = "fuse_readdirplus(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_readlink_fuse_reply__failed[] = "fuse_readlink(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_releasedir_fuse_reply__fail[] = "fuse_releasedir(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_removexattr_fuse_reply__fai[] = "fuse_removexattr(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_rename_fuse_reply__failed_w[] = "fuse_rename(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_rmdir_fuse_reply__failed_wi[] = "fuse_rmdir(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_setattr_clock_gettime_CLOCK[] = "fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s"; static const char __pyx_k_fuse_setxattr_fuse_reply__failed[] = "fuse_setxattr(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_statfs_fuse_reply__failed_w[] = "fuse_statfs(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_unlink_fuse_reply__failed_w[] = "fuse_unlink(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_write_buf_fuse_reply__faile[] = "fuse_write_buf(): fuse_reply_* failed with %s"; static const char __pyx_k_fuse_write_fuse_reply__failed_wi[] = "fuse_write(): fuse_reply_* failed with %s"; static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; static const char __pyx_k_py_retval_was_not_awaited_please[] = "py_retval was not awaited - please report a bug at https://github.com/libfuse/pyfuse3/issues!"; static PyObject *__pyx_kp_u_Calling_fuse_session_destroy; static PyObject *__pyx_kp_u_Calling_fuse_session_mount; static PyObject *__pyx_kp_u_Calling_fuse_session_new; static PyObject *__pyx_kp_u_Calling_fuse_session_unmount; static PyObject *__pyx_n_s_ClosedResourceError; static PyObject *__pyx_n_s_Container; static PyObject *__pyx_n_u_ENOATTR; static PyObject *__pyx_n_s_EntryAttributes; static PyObject *__pyx_n_s_FUSEError; static PyObject *__pyx_kp_u_FUSE_fd_about_to_be_closed; static PyObject *__pyx_kp_u_FUSE_session_exit_flag_set_while; static PyObject *__pyx_kp_u_Failed_to_submit_invalidate_entr; static PyObject *__pyx_n_s_FileInfo; static PyObject *__pyx_n_s_FileNotFoundError; static PyObject *__pyx_kp_u_Groups; static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0x22; static PyObject *__pyx_kp_s_Incompatible_checksums_s_vs_0xe8; static PyObject *__pyx_kp_u_Initializing_pyfuse3; static PyObject *__pyx_kp_u_Kernel_too_old_pyfuse3_requires; static PyObject *__pyx_n_s_Lock; static PyObject *__pyx_n_s_MemoryError; static PyObject *__pyx_n_s_NANOS_PER_SEC; static PyObject *__pyx_kp_u_Need_to_call_init_before_main; static PyObject *__pyx_n_s_OSError; static PyObject *__pyx_n_s_O_DIRECTORY; static PyObject *__pyx_n_s_Operations; static PyObject *__pyx_n_s_OverflowError; static PyObject *__pyx_n_s_PickleError; static PyObject *__pyx_n_s_PicklingError; static PyObject *__pyx_n_s_Queue; static PyObject *__pyx_n_u_RENAME_EXCHANGE; static PyObject *__pyx_n_u_RENAME_NOREPLACE; static PyObject *__pyx_n_s_ROOT_INODE; static PyObject *__pyx_n_s_ReaddirToken; static PyObject *__pyx_n_s_RequestContext; static PyObject *__pyx_kp_u_RequestContext_instances_can_t_b; static PyObject *__pyx_n_s_RuntimeError; static PyObject *__pyx_n_s_SetattrFields; static PyObject *__pyx_kp_u_SetattrFields_instances_can_t_be; static PyObject *__pyx_kp_u_Starting_notify_worker; static PyObject *__pyx_n_s_StatvfsData; static PyObject *__pyx_n_s_Thread; static PyObject *__pyx_n_s_TypeError; static PyObject *__pyx_kp_u_Unable_to_parse_s; static PyObject *__pyx_n_s_ValueError; static PyObject *__pyx_kp_u_Value_too_long_to_convert_to_Pyt; static PyObject *__pyx_n_s_WorkerData; static PyObject *__pyx_kp_b__33; static PyObject *__pyx_n_s_abspath; static PyObject *__pyx_n_s_access; static PyObject *__pyx_n_s_aenter; static PyObject *__pyx_n_s_aexit; static PyObject *__pyx_n_s_allowed; static PyObject *__pyx_n_s_args; static PyObject *__pyx_n_s_async_wrapper; static PyObject *__pyx_n_s_attr; static PyObject *__pyx_n_s_attr_only; static PyObject *__pyx_n_u_attr_timeout; static PyObject *__pyx_n_s_await; static PyObject *__pyx_n_s_buf; static PyObject *__pyx_n_s_bufsize; static PyObject *__pyx_n_s_bufvec; static PyObject *__pyx_n_s_c; static PyObject *__pyx_n_s_cbuf; static PyObject *__pyx_n_s_cline_in_traceback; static PyObject *__pyx_n_s_close; static PyObject *__pyx_n_s_cname; static PyObject *__pyx_n_s_cnamespace; static PyObject *__pyx_n_s_cpath; static PyObject *__pyx_n_s_create; static PyObject *__pyx_n_s_ctx; static PyObject *__pyx_n_s_current_task; static PyObject *__pyx_n_s_current_trio_token; static PyObject *__pyx_n_s_cvalue; static PyObject *__pyx_n_s_daemon; static PyObject *__pyx_n_s_data; static PyObject *__pyx_n_s_debug; static PyObject *__pyx_n_s_decode; static PyObject *__pyx_n_s_default_options; static PyObject *__pyx_n_u_default_permissions; static PyObject *__pyx_n_s_deleted; static PyObject *__pyx_n_s_dict; static PyObject *__pyx_n_s_direct_io; static PyObject *__pyx_n_s_dirp; static PyObject *__pyx_n_s_e; static PyObject *__pyx_n_s_enable_acl; static PyObject *__pyx_n_s_enable_writeback_cache; static PyObject *__pyx_n_s_encode; static PyObject *__pyx_n_s_enter; static PyObject *__pyx_n_s_entry; static PyObject *__pyx_n_u_entry_timeout; static PyObject *__pyx_n_s_enumerate; static PyObject *__pyx_n_s_errno; static PyObject *__pyx_kp_u_errno_d; static PyObject *__pyx_n_s_error; static PyObject *__pyx_n_s_exc; static PyObject *__pyx_n_s_exception; static PyObject *__pyx_n_s_exit; static PyObject *__pyx_n_s_f_args; static PyObject *__pyx_n_u_f_bavail; static PyObject *__pyx_n_u_f_bfree; static PyObject *__pyx_n_u_f_blocks; static PyObject *__pyx_n_u_f_bsize; static PyObject *__pyx_n_u_f_favail; static PyObject *__pyx_n_u_f_ffree; static PyObject *__pyx_n_u_f_files; static PyObject *__pyx_n_u_f_frsize; static PyObject *__pyx_n_u_f_namemax; static PyObject *__pyx_n_s_fd; static PyObject *__pyx_n_s_fh; static PyObject *__pyx_n_s_fi; static PyObject *__pyx_n_s_fields; static PyObject *__pyx_n_s_flags; static PyObject *__pyx_n_s_flush; static PyObject *__pyx_n_s_forget; static PyObject *__pyx_n_s_fse; static PyObject *__pyx_n_s_fsync; static PyObject *__pyx_n_s_fsyncdir; static PyObject *__pyx_n_s_fuse_access_async; static PyObject *__pyx_kp_u_fuse_access_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_buf_copy_failed_with; static PyObject *__pyx_n_s_fuse_create_async; static PyObject *__pyx_kp_u_fuse_create_fuse_reply__failed_w; static PyObject *__pyx_n_s_fuse_flush_async; static PyObject *__pyx_kp_u_fuse_flush_fuse_reply__failed_wi; static PyObject *__pyx_n_s_fuse_fsync_async; static PyObject *__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi; static PyObject *__pyx_n_s_fuse_fsyncdir_async; static PyObject *__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed; static PyObject *__pyx_n_s_fuse_getattr_async; static PyObject *__pyx_kp_u_fuse_getattr_fuse_reply__failed; static PyObject *__pyx_n_s_fuse_getxattr_async; static PyObject *__pyx_kp_u_fuse_getxattr_fuse_reply__failed; static PyObject *__pyx_n_s_fuse_link_async; static PyObject *__pyx_kp_u_fuse_link_fuse_reply__failed_wit; static PyObject *__pyx_n_s_fuse_listxattr_async; static PyObject *__pyx_kp_u_fuse_listxattr_fuse_reply__faile; static PyObject *__pyx_n_s_fuse_lookup_async; static PyObject *__pyx_kp_u_fuse_lookup_fuse_reply__failed_w; static PyObject *__pyx_kp_u_fuse_lowlevel_notify_delete_retu; static PyObject *__pyx_kp_u_fuse_lowlevel_notify_inval_entry; static PyObject *__pyx_kp_u_fuse_lowlevel_notify_inval_inode; static PyObject *__pyx_kp_u_fuse_lowlevel_notify_store_retur; static PyObject *__pyx_n_s_fuse_mkdir_async; static PyObject *__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi; static PyObject *__pyx_n_s_fuse_mknod_async; static PyObject *__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi; static PyObject *__pyx_n_s_fuse_open_async; static PyObject *__pyx_n_s_fuse_opendir_async; static PyObject *__pyx_kp_u_fuse_opendir_fuse_reply__failed; static PyObject *__pyx_n_s_fuse_read_async; static PyObject *__pyx_kp_u_fuse_read_fuse_reply__failed_wit; static PyObject *__pyx_n_s_fuse_readdirplus_async; static PyObject *__pyx_kp_u_fuse_readdirplus_fuse_reply__fai; static PyObject *__pyx_n_s_fuse_readlink_async; static PyObject *__pyx_kp_u_fuse_readlink_fuse_reply__failed; static PyObject *__pyx_n_s_fuse_release_async; static PyObject *__pyx_kp_u_fuse_release_fuse_reply__failed; static PyObject *__pyx_n_s_fuse_releasedir_async; static PyObject *__pyx_kp_u_fuse_releasedir_fuse_reply__fail; static PyObject *__pyx_n_s_fuse_removexattr_async; static PyObject *__pyx_kp_u_fuse_removexattr_fuse_reply__fai; static PyObject *__pyx_n_s_fuse_rename_async; static PyObject *__pyx_kp_u_fuse_rename_fuse_reply__failed_w; static PyObject *__pyx_n_s_fuse_rmdir_async; static PyObject *__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi; static PyObject *__pyx_kp_u_fuse_session_mount_failed; static PyObject *__pyx_kp_u_fuse_session_new_failed; static PyObject *__pyx_kp_u_fuse_session_receive_buf_failed; static PyObject *__pyx_n_s_fuse_setattr_async; static PyObject *__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK; static PyObject *__pyx_kp_u_fuse_setattr_fuse_reply__failed; static PyObject *__pyx_n_s_fuse_setxattr_async; static PyObject *__pyx_kp_u_fuse_setxattr_fuse_reply__failed; static PyObject *__pyx_n_u_fuse_stacktrace; static PyObject *__pyx_n_s_fuse_statfs_async; static PyObject *__pyx_kp_u_fuse_statfs_fuse_reply__failed_w; static PyObject *__pyx_n_s_fuse_symlink_async; static PyObject *__pyx_kp_u_fuse_symlink_fuse_reply__failed; static PyObject *__pyx_n_s_fuse_unlink_async; static PyObject *__pyx_kp_u_fuse_unlink_fuse_reply__failed_w; static PyObject *__pyx_n_s_fuse_write_async; static PyObject *__pyx_n_s_fuse_write_buf_async; static PyObject *__pyx_kp_u_fuse_write_buf_fuse_reply__faile; static PyObject *__pyx_kp_u_fuse_write_fuse_reply__failed_wi; static PyObject *__pyx_n_s_g; static PyObject *__pyx_n_u_generation; static PyObject *__pyx_n_s_get; static PyObject *__pyx_n_s_getLogger; static PyObject *__pyx_n_s_get_sup_groups; static PyObject *__pyx_n_s_getattr; static PyObject *__pyx_n_s_getfilesystemencoding; static PyObject *__pyx_n_s_getstate; static PyObject *__pyx_n_s_getxattr; static PyObject *__pyx_n_s_gids; static PyObject *__pyx_n_s_ignore_enoent; static PyObject *__pyx_n_s_import; static PyObject *__pyx_n_s_init; static PyObject *__pyx_n_s_ino; static PyObject *__pyx_n_s_inode; static PyObject *__pyx_n_s_inode_p; static PyObject *__pyx_n_s_invalidate_entry; static PyObject *__pyx_n_s_invalidate_entry_async; static PyObject *__pyx_n_s_invalidate_inode; static PyObject *__pyx_n_s_items; static PyObject *__pyx_n_s_join; static PyObject *__pyx_n_s_keep_cache; static PyObject *__pyx_n_s_len; static PyObject *__pyx_n_s_len_s; static PyObject *__pyx_n_s_line; static PyObject *__pyx_n_s_link; static PyObject *__pyx_n_s_listdir; static PyObject *__pyx_n_s_listxattr; static PyObject *__pyx_n_s_log; static PyObject *__pyx_n_s_logging; static PyObject *__pyx_n_s_lookup; static PyObject *__pyx_n_s_lowlevel; static PyObject *__pyx_n_s_main; static PyObject *__pyx_n_s_main_2; static PyObject *__pyx_n_s_mask; static PyObject *__pyx_n_s_max_tasks; static PyObject *__pyx_n_s_min_tasks; static PyObject *__pyx_n_s_mkdir; static PyObject *__pyx_n_s_mknod; static PyObject *__pyx_n_s_mountpoint; static PyObject *__pyx_kp_u_mountpoint__argument_must_be_of; static PyObject *__pyx_n_s_name; static PyObject *__pyx_n_s_name_2; static PyObject *__pyx_kp_u_name_argument_must_be_of_type_s; static PyObject *__pyx_n_s_name_b; static PyObject *__pyx_n_s_names; static PyObject *__pyx_n_s_namespace; static PyObject *__pyx_kp_u_namespace_parameter_must_be_sys; static PyObject *__pyx_n_s_new; static PyObject *__pyx_n_s_newname; static PyObject *__pyx_n_s_newparent; static PyObject *__pyx_n_s_next_id; static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; static PyObject *__pyx_n_s_nonseekable; static PyObject *__pyx_n_s_notify_closing; static PyObject *__pyx_n_s_notify_loop; static PyObject *__pyx_n_s_notify_store; static PyObject *__pyx_n_s_now; static PyObject *__pyx_n_s_nursery; static PyObject *__pyx_kp_b_o; static PyObject *__pyx_n_s_off; static PyObject *__pyx_n_s_offset; static PyObject *__pyx_n_s_open; static PyObject *__pyx_n_s_open_nursery; static PyObject *__pyx_n_s_opendir; static PyObject *__pyx_n_s_ops; static PyObject *__pyx_n_s_options; static PyObject *__pyx_n_s_os; static PyObject *__pyx_n_s_os_path; static PyObject *__pyx_n_s_path; static PyObject *__pyx_kp_u_path_argument_must_be_of_type_s; static PyObject *__pyx_n_s_path_b; static PyObject *__pyx_n_s_pbuf; static PyObject *__pyx_n_s_pickle; static PyObject *__pyx_n_s_pid; static PyObject *__pyx_kp_u_proc_d_status; static PyObject *__pyx_n_s_put; static PyObject *__pyx_kp_u_py_retval_was_not_awaited_please; static PyObject *__pyx_n_s_pybuf; static PyObject *__pyx_n_b_pyfuse3; static PyObject *__pyx_n_s_pyfuse3; static PyObject *__pyx_n_u_pyfuse3; static PyObject *__pyx_n_s_pyfuse3_2; static PyObject *__pyx_kp_u_pyfuse_02d; static PyObject *__pyx_n_s_pyx_PickleError; static PyObject *__pyx_n_s_pyx_checksum; static PyObject *__pyx_n_s_pyx_result; static PyObject *__pyx_n_s_pyx_state; static PyObject *__pyx_n_s_pyx_type; static PyObject *__pyx_n_s_pyx_unpickle_RequestContext; static PyObject *__pyx_n_s_pyx_unpickle__WorkerData; static PyObject *__pyx_n_s_pyx_vtable; static PyObject *__pyx_n_s_queue; static PyObject *__pyx_n_u_r; static PyObject *__pyx_n_s_range; static PyObject *__pyx_n_s_read; static PyObject *__pyx_n_s_readdir; static PyObject *__pyx_n_s_readdir_reply; static PyObject *__pyx_n_s_readlink; static PyObject *__pyx_n_s_reduce; static PyObject *__pyx_n_s_reduce_cython; static PyObject *__pyx_n_s_reduce_ex; static PyObject *__pyx_n_s_release; static PyObject *__pyx_n_s_releasedir; static PyObject *__pyx_n_s_removexattr; static PyObject *__pyx_n_s_rename; static PyObject *__pyx_n_s_req; static PyObject *__pyx_n_s_res; static PyObject *__pyx_n_s_ret; static PyObject *__pyx_n_s_rmdir; static PyObject *__pyx_kp_u_s_No_tasks_waiting_starting_ano; static PyObject *__pyx_kp_u_s_terminated; static PyObject *__pyx_kp_u_s_too_many_idle_tasks_d_total_d; static PyObject *__pyx_kp_s_self_req_cannot_be_converted_to; static PyObject *__pyx_n_s_send; static PyObject *__pyx_n_s_session_loop; static PyObject *__pyx_n_s_setattr; static PyObject *__pyx_n_s_setstate; static PyObject *__pyx_n_s_setstate_cython; static PyObject *__pyx_n_s_setxattr; static PyObject *__pyx_n_s_size_guess; static PyObject *__pyx_n_s_slen; static PyObject *__pyx_n_s_split; static PyObject *__pyx_kp_s_src_handlers_pxi; static PyObject *__pyx_kp_s_src_internal_pxi; static PyObject *__pyx_kp_s_src_pyfuse3_pyx; static PyObject *__pyx_n_u_st_atime_ns; static PyObject *__pyx_n_u_st_birthtime_ns; static PyObject *__pyx_n_u_st_blksize; static PyObject *__pyx_n_u_st_blocks; static PyObject *__pyx_n_u_st_ctime_ns; static PyObject *__pyx_n_u_st_gid; static PyObject *__pyx_n_u_st_ino; static PyObject *__pyx_n_u_st_mode; static PyObject *__pyx_n_u_st_mtime_ns; static PyObject *__pyx_n_u_st_nlink; static PyObject *__pyx_n_u_st_rdev; static PyObject *__pyx_n_u_st_size; static PyObject *__pyx_n_u_st_uid; static PyObject *__pyx_n_s_stacktrace; static PyObject *__pyx_n_s_start; static PyObject *__pyx_n_s_start_soon; static PyObject *__pyx_n_s_startswith; static PyObject *__pyx_n_s_statfs; static PyObject *__pyx_n_s_stats; static PyObject *__pyx_n_s_strerror; static PyObject *__pyx_kp_s_stringsource; static PyObject *__pyx_n_s_supports_dot_lookup; static PyObject *__pyx_n_u_surrogateescape; static PyObject *__pyx_n_s_symlink; static PyObject *__pyx_n_s_syncfs; static PyObject *__pyx_n_s_sys; static PyObject *__pyx_n_u_system; static PyObject *__pyx_n_s_t; static PyObject *__pyx_n_s_target; static PyObject *__pyx_n_s_terminate; static PyObject *__pyx_kp_u_terminating_notify_thread; static PyObject *__pyx_n_s_test; static PyObject *__pyx_n_s_threading; static PyObject *__pyx_n_s_throw; static PyObject *__pyx_n_s_tmp; static PyObject *__pyx_n_s_to_set; static PyObject *__pyx_n_s_token; static PyObject *__pyx_n_s_trio; static PyObject *__pyx_n_s_trio_token; static PyObject *__pyx_kp_u_unknown_flag_s_o; static PyObject *__pyx_n_s_unlink; static PyObject *__pyx_n_s_unmount; static PyObject *__pyx_n_s_update; static PyObject *__pyx_kp_u_us_ascii; static PyObject *__pyx_n_u_user; static PyObject *__pyx_n_s_value; static PyObject *__pyx_n_s_version; static PyObject *__pyx_n_s_wait_fuse_readable; static PyObject *__pyx_n_s_wait_readable; static PyObject *__pyx_n_s_write; static PyObject *__pyx_n_s_x; static PyObject *__pyx_pf_7pyfuse3_10_Container___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3__Container *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_10_Container_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3__Container *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_7pyfuse3_fuse_lookup_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7pyfuse3_3fuse_getattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_6fuse_setattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_fh); /* proto */ static PyObject *__pyx_pf_7pyfuse3_9fuse_readlink_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_12fuse_mknod_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15fuse_mkdir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7pyfuse3_18fuse_unlink_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7pyfuse3_21fuse_rmdir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7pyfuse3_24fuse_symlink_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name, PyObject *__pyx_v_link); /* proto */ static PyObject *__pyx_pf_7pyfuse3_27fuse_rename_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name, PyObject *__pyx_v_newname); /* proto */ static PyObject *__pyx_pf_7pyfuse3_30fuse_link_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_newname); /* proto */ static PyObject *__pyx_pf_7pyfuse3_33fuse_open_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_36fuse_read_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_39fuse_write_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_pbuf); /* proto */ static PyObject *__pyx_pf_7pyfuse3_42fuse_write_buf_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_buf); /* proto */ static PyObject *__pyx_pf_7pyfuse3_45fuse_flush_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_48fuse_release_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_51fuse_fsync_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_54fuse_opendir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_12ReaddirToken___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_12ReaddirToken_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_7pyfuse3_57fuse_readdirplus_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_60fuse_releasedir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_63fuse_fsyncdir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_66fuse_statfs_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_69fuse_setxattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_7pyfuse3_72fuse_getxattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7pyfuse3_75fuse_listxattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_78fuse_removexattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7pyfuse3_81fuse_access_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c); /* proto */ static PyObject *__pyx_pf_7pyfuse3_84fuse_create_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name); /* proto */ static PyObject *__pyx_pf_7pyfuse3_87_notify_loop(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static int __pyx_pf_7pyfuse3_11_WorkerData___init__(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11_WorkerData_2__reduce_cython__(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11_WorkerData_4__setstate_cython__(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_7pyfuse3_89_wait_fuse_readable(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_92_session_loop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nursery, int __pyx_v_min_tasks, int __pyx_v_max_tasks); /* proto */ static PyObject *__pyx_pf_7pyfuse3_14RequestContext___getstate__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_14RequestContext_3uid___get__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_14RequestContext_3pid___get__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_14RequestContext_3gid___get__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_14RequestContext_5umask___get__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_14RequestContext_2__reduce_cython__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_14RequestContext_4__setstate_cython__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_7pyfuse3_13SetattrFields___cinit__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_2__getstate__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_12update_atime___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_12update_mtime___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_12update_ctime___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_11update_mode___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_10update_uid___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_10update_gid___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_11update_size___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes___cinit__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_6st_ino___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_6st_ino_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_10generation___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_10generation_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_12attr_timeout___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_12attr_timeout_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_13entry_timeout___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_13entry_timeout_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_7st_mode___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_7st_mode_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_8st_nlink___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_8st_nlink_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_6st_uid___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_6st_uid_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_6st_gid___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_6st_gid_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_7st_rdev___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_7st_rdev_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_7st_size___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_7st_size_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_9st_blocks___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_9st_blocks_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_10st_blksize___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_10st_blksize_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_11st_atime_ns___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_11st_atime_ns_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_11st_mtime_ns___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_11st_mtime_ns_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_11st_ctime_ns___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_11st_ctime_ns_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_15st_birthtime_ns___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_15EntryAttributes_15st_birthtime_ns_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_2__getstate__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_4__setstate__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_state); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_7pyfuse3_8FileInfo___cinit__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_fh, PyObject *__pyx_v_direct_io, PyObject *__pyx_v_keep_cache, PyObject *__pyx_v_nonseekable); /* proto */ static PyObject *__pyx_pf_7pyfuse3_8FileInfo_2fh___get__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_8FileInfo_2fh_2__set__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_7pyfuse3_8FileInfo_9direct_io___get__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_8FileInfo_9direct_io_2__set__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_7pyfuse3_8FileInfo_10keep_cache___get__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_8FileInfo_10keep_cache_2__set__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_7pyfuse3_8FileInfo_11nonseekable___get__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_8FileInfo_11nonseekable_2__set__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_7pyfuse3_8FileInfo_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_8FileInfo_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData___cinit__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_7f_bsize___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_7f_bsize_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8f_frsize___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_8f_frsize_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8f_blocks___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_8f_blocks_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_7f_bfree___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_7f_bfree_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8f_bavail___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_8f_bavail_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_7f_files___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_7f_files_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_7f_ffree___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_7f_ffree_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8f_favail___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_8f_favail_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_9f_namemax___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_11StatvfsData_9f_namemax_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_2__getstate__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_4__setstate__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_state); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_7pyfuse3_9FUSEError_5errno___get__(struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self); /* proto */ static int __pyx_pf_7pyfuse3_9FUSEError___cinit__(struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self, PyObject *__pyx_v_errno); /* proto */ static PyObject *__pyx_pf_7pyfuse3_9FUSEError_2__str__(struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_9FUSEError_6errno____get__(struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_9FUSEError_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_9FUSEError_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_7pyfuse3_95listdir(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path); /* proto */ static PyObject *__pyx_pf_7pyfuse3_97syncfs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path); /* proto */ static PyObject *__pyx_pf_7pyfuse3_99setxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_namespace); /* proto */ static PyObject *__pyx_pf_7pyfuse3_101getxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, size_t __pyx_v_size_guess, PyObject *__pyx_v_namespace); /* proto */ static PyObject *__pyx_pf_7pyfuse3_103init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ops, PyObject *__pyx_v_mountpoint, PyObject *__pyx_v_options); /* proto */ static PyObject *__pyx_pf_7pyfuse3_105main(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_min_tasks, int __pyx_v_max_tasks); /* proto */ static PyObject *__pyx_pf_7pyfuse3_108terminate(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_7pyfuse3_110close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_unmount); /* proto */ static PyObject *__pyx_pf_7pyfuse3_112invalidate_inode(CYTHON_UNUSED PyObject *__pyx_self, fuse_ino_t __pyx_v_inode, PyObject *__pyx_v_attr_only); /* proto */ static PyObject *__pyx_pf_7pyfuse3_114invalidate_entry(CYTHON_UNUSED PyObject *__pyx_self, fuse_ino_t __pyx_v_inode_p, PyObject *__pyx_v_name, fuse_ino_t __pyx_v_deleted); /* proto */ static PyObject *__pyx_pf_7pyfuse3_116invalidate_entry_async(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_inode_p, PyObject *__pyx_v_name, PyObject *__pyx_v_deleted, PyObject *__pyx_v_ignore_enoent); /* proto */ static PyObject *__pyx_pf_7pyfuse3_118notify_store(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_inode, PyObject *__pyx_v_offset, PyObject *__pyx_v_data); /* proto */ static PyObject *__pyx_pf_7pyfuse3_120get_sup_groups(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pid); /* proto */ static PyObject *__pyx_pf_7pyfuse3_122readdir_reply(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_v_token, PyObject *__pyx_v_name, struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_attr, off_t __pyx_v_next_id); /* proto */ static PyObject *__pyx_pf_7pyfuse3_124__pyx_unpickle__WorkerData(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_7pyfuse3_126__pyx_unpickle_RequestContext(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_tp_new_7pyfuse3__Container(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3_ReaddirToken(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3__WorkerData(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3_RequestContext(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3_SetattrFields(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3_EntryAttributes(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3_FileInfo(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3_StatvfsData(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3_FUSEError(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct__fuse_lookup_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_9_fuse_rename_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_10_fuse_link_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_11_fuse_open_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_12_fuse_read_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_13_fuse_write_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_15_fuse_flush_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_16_fuse_release_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_27_fuse_access_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_28_fuse_create_async(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_30__session_loop(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_31_main(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_int_0; static PyObject *__pyx_int_1; static PyObject *__pyx_int_35895208; static PyObject *__pyx_int_244161614; static PyObject *__pyx_int_1000000000; static PyObject *__pyx_k__54; static PyObject *__pyx_tuple_; static PyObject *__pyx_tuple__2; static PyObject *__pyx_tuple__3; static PyObject *__pyx_slice__60; static PyObject *__pyx_tuple__17; static PyObject *__pyx_tuple__24; static PyObject *__pyx_tuple__25; static PyObject *__pyx_tuple__38; static PyObject *__pyx_tuple__40; static PyObject *__pyx_tuple__41; static PyObject *__pyx_tuple__42; static PyObject *__pyx_tuple__43; static PyObject *__pyx_tuple__44; static PyObject *__pyx_tuple__45; static PyObject *__pyx_tuple__46; static PyObject *__pyx_tuple__47; static PyObject *__pyx_tuple__48; static PyObject *__pyx_tuple__49; static PyObject *__pyx_tuple__50; static PyObject *__pyx_tuple__51; static PyObject *__pyx_tuple__52; static PyObject *__pyx_tuple__53; static PyObject *__pyx_tuple__55; static PyObject *__pyx_tuple__56; static PyObject *__pyx_tuple__57; static PyObject *__pyx_tuple__59; static PyObject *__pyx_tuple__61; static PyObject *__pyx_tuple__62; static PyObject *__pyx_tuple__63; static PyObject *__pyx_tuple__64; static PyObject *__pyx_tuple__65; static PyObject *__pyx_tuple__66; static PyObject *__pyx_tuple__67; static PyObject *__pyx_tuple__68; static PyObject *__pyx_tuple__69; static PyObject *__pyx_tuple__70; static PyObject *__pyx_tuple__71; static PyObject *__pyx_tuple__72; static PyObject *__pyx_tuple__73; static PyObject *__pyx_tuple__74; static PyObject *__pyx_tuple__75; static PyObject *__pyx_tuple__76; static PyObject *__pyx_tuple__77; static PyObject *__pyx_tuple__78; static PyObject *__pyx_tuple__79; static PyObject *__pyx_tuple__80; static PyObject *__pyx_tuple__81; static PyObject *__pyx_tuple__82; static PyObject *__pyx_tuple__83; static PyObject *__pyx_tuple__84; static PyObject *__pyx_tuple__85; static PyObject *__pyx_tuple__86; static PyObject *__pyx_tuple__87; static PyObject *__pyx_tuple__88; static PyObject *__pyx_tuple__89; static PyObject *__pyx_tuple__90; static PyObject *__pyx_tuple__91; static PyObject *__pyx_tuple__93; static PyObject *__pyx_tuple__94; static PyObject *__pyx_tuple__96; static PyObject *__pyx_tuple__98; static PyObject *__pyx_codeobj__4; static PyObject *__pyx_codeobj__5; static PyObject *__pyx_codeobj__6; static PyObject *__pyx_codeobj__7; static PyObject *__pyx_codeobj__8; static PyObject *__pyx_codeobj__9; static PyObject *__pyx_tuple__100; static PyObject *__pyx_tuple__102; static PyObject *__pyx_tuple__103; static PyObject *__pyx_tuple__105; static PyObject *__pyx_tuple__107; static PyObject *__pyx_tuple__109; static PyObject *__pyx_tuple__111; static PyObject *__pyx_tuple__113; static PyObject *__pyx_tuple__115; static PyObject *__pyx_tuple__117; static PyObject *__pyx_tuple__119; static PyObject *__pyx_tuple__121; static PyObject *__pyx_tuple__123; static PyObject *__pyx_codeobj__10; static PyObject *__pyx_codeobj__11; static PyObject *__pyx_codeobj__12; static PyObject *__pyx_codeobj__13; static PyObject *__pyx_codeobj__14; static PyObject *__pyx_codeobj__15; static PyObject *__pyx_codeobj__16; static PyObject *__pyx_codeobj__18; static PyObject *__pyx_codeobj__19; static PyObject *__pyx_codeobj__20; static PyObject *__pyx_codeobj__21; static PyObject *__pyx_codeobj__22; static PyObject *__pyx_codeobj__23; static PyObject *__pyx_codeobj__26; static PyObject *__pyx_codeobj__27; static PyObject *__pyx_codeobj__28; static PyObject *__pyx_codeobj__29; static PyObject *__pyx_codeobj__30; static PyObject *__pyx_codeobj__31; static PyObject *__pyx_codeobj__32; static PyObject *__pyx_codeobj__34; static PyObject *__pyx_codeobj__35; static PyObject *__pyx_codeobj__36; static PyObject *__pyx_codeobj__37; static PyObject *__pyx_codeobj__39; static PyObject *__pyx_codeobj__58; static PyObject *__pyx_codeobj__92; static PyObject *__pyx_codeobj__95; static PyObject *__pyx_codeobj__97; static PyObject *__pyx_codeobj__99; static PyObject *__pyx_codeobj__101; static PyObject *__pyx_codeobj__104; static PyObject *__pyx_codeobj__106; static PyObject *__pyx_codeobj__108; static PyObject *__pyx_codeobj__110; static PyObject *__pyx_codeobj__112; static PyObject *__pyx_codeobj__114; static PyObject *__pyx_codeobj__116; static PyObject *__pyx_codeobj__118; static PyObject *__pyx_codeobj__120; static PyObject *__pyx_codeobj__122; static PyObject *__pyx_codeobj__124; /* Late includes */ /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_10_Container_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_10_Container___reduce_cython__[] = "_Container.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_10_Container_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_10_Container___reduce_cython__(((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_10_Container___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3__Container *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self.req cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.req cannot be converted to a Python object for pickling") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3._Container.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self.req cannot be converted to a Python object for pickling") */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_10_Container_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_10_Container_2__setstate_cython__[] = "_Container.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_10_Container_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_10_Container_2__setstate_cython__(((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_10_Container_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3__Container *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.req cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self.req cannot be converted to a Python object for pickling") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3._Container.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":33 * cdef uint64_t fh * * cdef void fuse_init (void *userdata, fuse_conn_info *conn): # <<<<<<<<<<<<<< * if not conn.capable & FUSE_CAP_READDIRPLUS: * raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!') */ static void __pyx_f_7pyfuse3_fuse_init(CYTHON_UNUSED void *__pyx_v_userdata, struct fuse_conn_info *__pyx_v_conn) { __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_init", 0); /* "src/handlers.pxi":34 * * cdef void fuse_init (void *userdata, fuse_conn_info *conn): * if not conn.capable & FUSE_CAP_READDIRPLUS: # <<<<<<<<<<<<<< * raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!') * conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) */ __pyx_t_1 = ((!((__pyx_v_conn->capable & FUSE_CAP_READDIRPLUS) != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "src/handlers.pxi":35 * cdef void fuse_init (void *userdata, fuse_conn_info *conn): * if not conn.capable & FUSE_CAP_READDIRPLUS: * raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!') # <<<<<<<<<<<<<< * conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) * */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(1, 35, __pyx_L1_error) /* "src/handlers.pxi":34 * * cdef void fuse_init (void *userdata, fuse_conn_info *conn): * if not conn.capable & FUSE_CAP_READDIRPLUS: # <<<<<<<<<<<<<< * raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!') * conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) */ } /* "src/handlers.pxi":36 * if not conn.capable & FUSE_CAP_READDIRPLUS: * raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!') * conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) # <<<<<<<<<<<<<< * * if (operations.supports_dot_lookup and */ __pyx_v_conn->want = (__pyx_v_conn->want & (~((unsigned int)FUSE_CAP_READDIRPLUS_AUTO))); /* "src/handlers.pxi":38 * conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) * * if (operations.supports_dot_lookup and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_EXPORT_SUPPORT): * conn.want |= FUSE_CAP_EXPORT_SUPPORT */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_supports_dot_lookup); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 38, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 38, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L5_bool_binop_done; } /* "src/handlers.pxi":39 * * if (operations.supports_dot_lookup and * conn.capable & FUSE_CAP_EXPORT_SUPPORT): # <<<<<<<<<<<<<< * conn.want |= FUSE_CAP_EXPORT_SUPPORT * if (operations.enable_writeback_cache and */ __pyx_t_3 = ((__pyx_v_conn->capable & FUSE_CAP_EXPORT_SUPPORT) != 0); __pyx_t_1 = __pyx_t_3; __pyx_L5_bool_binop_done:; /* "src/handlers.pxi":38 * conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) * * if (operations.supports_dot_lookup and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_EXPORT_SUPPORT): * conn.want |= FUSE_CAP_EXPORT_SUPPORT */ if (__pyx_t_1) { /* "src/handlers.pxi":40 * if (operations.supports_dot_lookup and * conn.capable & FUSE_CAP_EXPORT_SUPPORT): * conn.want |= FUSE_CAP_EXPORT_SUPPORT # <<<<<<<<<<<<<< * if (operations.enable_writeback_cache and * conn.capable & FUSE_CAP_WRITEBACK_CACHE): */ __pyx_v_conn->want = (__pyx_v_conn->want | FUSE_CAP_EXPORT_SUPPORT); /* "src/handlers.pxi":38 * conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) * * if (operations.supports_dot_lookup and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_EXPORT_SUPPORT): * conn.want |= FUSE_CAP_EXPORT_SUPPORT */ } /* "src/handlers.pxi":41 * conn.capable & FUSE_CAP_EXPORT_SUPPORT): * conn.want |= FUSE_CAP_EXPORT_SUPPORT * if (operations.enable_writeback_cache and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_WRITEBACK_CACHE): * conn.want |= FUSE_CAP_WRITEBACK_CACHE */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_enable_writeback_cache); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 41, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 41, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L8_bool_binop_done; } /* "src/handlers.pxi":42 * conn.want |= FUSE_CAP_EXPORT_SUPPORT * if (operations.enable_writeback_cache and * conn.capable & FUSE_CAP_WRITEBACK_CACHE): # <<<<<<<<<<<<<< * conn.want |= FUSE_CAP_WRITEBACK_CACHE * if (operations.enable_acl and */ __pyx_t_3 = ((__pyx_v_conn->capable & FUSE_CAP_WRITEBACK_CACHE) != 0); __pyx_t_1 = __pyx_t_3; __pyx_L8_bool_binop_done:; /* "src/handlers.pxi":41 * conn.capable & FUSE_CAP_EXPORT_SUPPORT): * conn.want |= FUSE_CAP_EXPORT_SUPPORT * if (operations.enable_writeback_cache and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_WRITEBACK_CACHE): * conn.want |= FUSE_CAP_WRITEBACK_CACHE */ if (__pyx_t_1) { /* "src/handlers.pxi":43 * if (operations.enable_writeback_cache and * conn.capable & FUSE_CAP_WRITEBACK_CACHE): * conn.want |= FUSE_CAP_WRITEBACK_CACHE # <<<<<<<<<<<<<< * if (operations.enable_acl and * conn.capable & FUSE_CAP_POSIX_ACL): */ __pyx_v_conn->want = (__pyx_v_conn->want | FUSE_CAP_WRITEBACK_CACHE); /* "src/handlers.pxi":41 * conn.capable & FUSE_CAP_EXPORT_SUPPORT): * conn.want |= FUSE_CAP_EXPORT_SUPPORT * if (operations.enable_writeback_cache and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_WRITEBACK_CACHE): * conn.want |= FUSE_CAP_WRITEBACK_CACHE */ } /* "src/handlers.pxi":44 * conn.capable & FUSE_CAP_WRITEBACK_CACHE): * conn.want |= FUSE_CAP_WRITEBACK_CACHE * if (operations.enable_acl and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_POSIX_ACL): * conn.want |= FUSE_CAP_POSIX_ACL */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_enable_acl); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 44, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(1, 44, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L11_bool_binop_done; } /* "src/handlers.pxi":45 * conn.want |= FUSE_CAP_WRITEBACK_CACHE * if (operations.enable_acl and * conn.capable & FUSE_CAP_POSIX_ACL): # <<<<<<<<<<<<<< * conn.want |= FUSE_CAP_POSIX_ACL * */ __pyx_t_3 = ((__pyx_v_conn->capable & FUSE_CAP_POSIX_ACL) != 0); __pyx_t_1 = __pyx_t_3; __pyx_L11_bool_binop_done:; /* "src/handlers.pxi":44 * conn.capable & FUSE_CAP_WRITEBACK_CACHE): * conn.want |= FUSE_CAP_WRITEBACK_CACHE * if (operations.enable_acl and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_POSIX_ACL): * conn.want |= FUSE_CAP_POSIX_ACL */ if (__pyx_t_1) { /* "src/handlers.pxi":46 * if (operations.enable_acl and * conn.capable & FUSE_CAP_POSIX_ACL): * conn.want |= FUSE_CAP_POSIX_ACL # <<<<<<<<<<<<<< * * # Blocking rather than async, in case we decide to let the */ __pyx_v_conn->want = (__pyx_v_conn->want | FUSE_CAP_POSIX_ACL); /* "src/handlers.pxi":44 * conn.capable & FUSE_CAP_WRITEBACK_CACHE): * conn.want |= FUSE_CAP_WRITEBACK_CACHE * if (operations.enable_acl and # <<<<<<<<<<<<<< * conn.capable & FUSE_CAP_POSIX_ACL): * conn.want |= FUSE_CAP_POSIX_ACL */ } /* "src/handlers.pxi":50 * # Blocking rather than async, in case we decide to let the * # init hander modify `conn` in the future. * operations.init() # <<<<<<<<<<<<<< * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_init); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 50, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":33 * cdef uint64_t fh * * cdef void fuse_init (void *userdata, fuse_conn_info *conn): # <<<<<<<<<<<<<< * if not conn.capable & FUSE_CAP_READDIRPLUS: * raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!') */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("pyfuse3.fuse_init", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "src/handlers.pxi":52 * operations.init() * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_lookup(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_lookup", 0); /* "src/handlers.pxi":54 * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, * const_char *name): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.parent = parent */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 54, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":55 * const_char *name): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.parent = parent * save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":56 * cdef _Container c = _Container() * c.req = req * c.parent = parent # <<<<<<<<<<<<<< * save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) * */ __pyx_v_c->parent = __pyx_v_parent; /* "src/handlers.pxi":57 * c.req = req * c.parent = parent * save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) # <<<<<<<<<<<<<< * * async def fuse_lookup_async (_Container c, name): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_lookup_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 57, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 57, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 57, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":52 * operations.init() * * cdef void fuse_lookup (fuse_req_t req, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_lookup", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":59 * save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) * * async def fuse_lookup_async (_Container c, name): # <<<<<<<<<<<<<< * cdef EntryAttributes entry * cdef int ret */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_1fuse_lookup_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_fuse_lookup_async[] = "fuse_lookup_async(_Container c, name)"; static PyMethodDef __pyx_mdef_7pyfuse3_1fuse_lookup_async = {"fuse_lookup_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_1fuse_lookup_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_fuse_lookup_async}; static PyObject *__pyx_pw_7pyfuse3_1fuse_lookup_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_lookup_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_lookup_async", 1, 2, 2, 1); __PYX_ERR(1, 59, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_lookup_async") < 0)) __PYX_ERR(1, 59, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_lookup_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 59, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_lookup_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 59, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_fuse_lookup_async(__pyx_self, __pyx_v_c, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_fuse_lookup_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name) { struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_lookup_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct__fuse_lookup_async(__pyx_ptype_7pyfuse3___pyx_scope_struct__fuse_lookup_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 59, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_2generator, __pyx_codeobj__4, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_lookup_async, __pyx_n_s_fuse_lookup_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 59, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_lookup_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; char const *__pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_lookup_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 59, __pyx_L1_error) /* "src/handlers.pxi":63 * cdef int ret * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * entry = await operations.lookup( */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":64 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.lookup( * c.parent, name, ctx) */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":65 * ctx = get_request_context(c.req) * try: * entry = await operations.lookup( # <<<<<<<<<<<<<< * c.parent, name, ctx) * except FUSEError as e: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_lookup); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 65, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); /* "src/handlers.pxi":66 * try: * entry = await operations.lookup( * c.parent, name, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 66, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 65, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_name); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 65, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 65, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 65, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } /* "src/handlers.pxi":65 * ctx = get_request_context(c.req) * try: * entry = await operations.lookup( # <<<<<<<<<<<<<< * c.parent, name, ctx) * except FUSEError as e: */ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_EntryAttributes)))) __PYX_ERR(1, 65, __pyx_L4_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_entry = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":64 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.lookup( * c.parent, name, ctx) */ } /* "src/handlers.pxi":70 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_entry(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_entry->fuse_param)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":67 * entry = await operations.lookup( * c.parent, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_lookup_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(1, 67, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":68 * c.parent, name, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 68, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 68, __pyx_L16_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":67 * entry = await operations.lookup( * c.parent, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_8 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14); __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":64 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.lookup( * c.parent, name, ctx) */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":72 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/handlers.pxi":73 * * if ret != 0: * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_lookup_fuse_reply__failed_w, __pyx_t_1}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_lookup_fuse_reply__failed_w, __pyx_t_1}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_lookup_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_lookup_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_10, __pyx_kp_u_fuse_lookup_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_10, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 73, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":72 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_lookup(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":59 * save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) * * async def fuse_lookup_async (_Container c, name): # <<<<<<<<<<<<<< * cdef EntryAttributes entry * cdef int ret */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_lookup_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":76 * * * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * uint64_t nlookup): * save_retval(operations.forget([(ino, nlookup)])) */ static void __pyx_f_7pyfuse3_fuse_forget(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, uint64_t __pyx_v_nlookup) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_forget", 0); /* "src/handlers.pxi":78 * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, * uint64_t nlookup): * save_retval(operations.forget([(ino, nlookup)])) # <<<<<<<<<<<<<< * fuse_reply_none(req) * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_forget); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_ino); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_uint64_t(__pyx_v_nlookup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_4 = PyList_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 78, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":79 * uint64_t nlookup): * save_retval(operations.forget([(ino, nlookup)])) * fuse_reply_none(req) # <<<<<<<<<<<<<< * * */ fuse_reply_none(__pyx_v_req); /* "src/handlers.pxi":76 * * * cdef void fuse_forget (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * uint64_t nlookup): * save_retval(operations.forget([(ino, nlookup)])) */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_WriteUnraisable("pyfuse3.fuse_forget", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "src/handlers.pxi":82 * * * cdef void fuse_forget_multi(fuse_req_t req, size_t count, # <<<<<<<<<<<<<< * fuse_forget_data *forgets): * forget_list = list() */ static void __pyx_f_7pyfuse3_fuse_forget_multi(fuse_req_t __pyx_v_req, size_t __pyx_v_count, struct fuse_forget_data *__pyx_v_forgets) { PyObject *__pyx_v_forget_list = NULL; struct fuse_forget_data __pyx_v_el; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; struct fuse_forget_data *__pyx_t_2; struct fuse_forget_data *__pyx_t_3; struct fuse_forget_data *__pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_forget_multi", 0); /* "src/handlers.pxi":84 * cdef void fuse_forget_multi(fuse_req_t req, size_t count, * fuse_forget_data *forgets): * forget_list = list() # <<<<<<<<<<<<<< * for el in forgets[:count]: * forget_list.append((el.ino, el.nlookup)) */ __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 84, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_forget_list = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":85 * fuse_forget_data *forgets): * forget_list = list() * for el in forgets[:count]: # <<<<<<<<<<<<<< * forget_list.append((el.ino, el.nlookup)) * save_retval(operations.forget(forget_list)) */ __pyx_t_3 = (__pyx_v_forgets + __pyx_v_count); for (__pyx_t_4 = __pyx_v_forgets; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { __pyx_t_2 = __pyx_t_4; __pyx_v_el = (__pyx_t_2[0]); /* "src/handlers.pxi":86 * forget_list = list() * for el in forgets[:count]: * forget_list.append((el.ino, el.nlookup)) # <<<<<<<<<<<<<< * save_retval(operations.forget(forget_list)) * fuse_reply_none(req) */ __pyx_t_1 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_el.ino); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 86, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyInt_From_uint64_t(__pyx_v_el.nlookup); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 86, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 86, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_forget_list, __pyx_t_6); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(1, 86, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } /* "src/handlers.pxi":87 * for el in forgets[:count]: * forget_list.append((el.ino, el.nlookup)) * save_retval(operations.forget(forget_list)) # <<<<<<<<<<<<<< * fuse_reply_none(req) * */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_forget); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_6 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_forget_list) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_forget_list); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_6); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/handlers.pxi":88 * forget_list.append((el.ino, el.nlookup)) * save_retval(operations.forget(forget_list)) * fuse_reply_none(req) # <<<<<<<<<<<<<< * * */ fuse_reply_none(__pyx_v_req); /* "src/handlers.pxi":82 * * * cdef void fuse_forget_multi(fuse_req_t req, size_t count, # <<<<<<<<<<<<<< * fuse_forget_data *forgets): * forget_list = list() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_forget_multi", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF(__pyx_v_forget_list); __Pyx_RefNannyFinishContext(); } /* "src/handlers.pxi":91 * * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * fuse_file_info *fi): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_getattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, CYTHON_UNUSED struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_getattr", 0); /* "src/handlers.pxi":93 * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, * fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":94 * fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * save_retval(fuse_getattr_async(c)) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":95 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * save_retval(fuse_getattr_async(c)) * */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":96 * c.req = req * c.ino = ino * save_retval(fuse_getattr_async(c)) # <<<<<<<<<<<<<< * * async def fuse_getattr_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_getattr_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 96, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 96, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":91 * * * cdef void fuse_getattr (fuse_req_t req, fuse_ino_t ino, # <<<<<<<<<<<<<< * fuse_file_info *fi): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyfuse3.fuse_getattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_5generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":98 * save_retval(fuse_getattr_async(c)) * * async def fuse_getattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_4fuse_getattr_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_3fuse_getattr_async[] = "fuse_getattr_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_4fuse_getattr_async = {"fuse_getattr_async", (PyCFunction)__pyx_pw_7pyfuse3_4fuse_getattr_async, METH_O, __pyx_doc_7pyfuse3_3fuse_getattr_async}; static PyObject *__pyx_pw_7pyfuse3_4fuse_getattr_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_getattr_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 98, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_3fuse_getattr_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_3fuse_getattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_getattr_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 98, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_5generator1, __pyx_codeobj__5, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_getattr_async, __pyx_n_s_fuse_getattr_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 98, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_getattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_5generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; char const *__pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_getattr_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 98, __pyx_L1_error) /* "src/handlers.pxi":102 * cdef EntryAttributes entry * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * entry = await operations.getattr(c.ino, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":103 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.getattr(c.ino, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":104 * ctx = get_request_context(c.req) * try: * entry = await operations.getattr(c.ino, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_getattr); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 104, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 104, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 104, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 104, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 104, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 104, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 104, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 104, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_EntryAttributes)))) __PYX_ERR(1, 104, __pyx_L4_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_entry = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":103 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.getattr(c.ino, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":108 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_attr(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_entry->attr, __pyx_cur_scope->__pyx_v_entry->fuse_param.attr_timeout); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":105 * try: * entry = await operations.getattr(c.ino, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_getattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(1, 105, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":106 * entry = await operations.getattr(c.ino, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 106, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 106, __pyx_L16_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":105 * try: * entry = await operations.getattr(c.ino, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_8 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14); __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":103 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.getattr(c.ino, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":110 * ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/handlers.pxi":111 * * if ret != 0: * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_getattr_fuse_reply__failed, __pyx_t_1}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 111, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_getattr_fuse_reply__failed, __pyx_t_1}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 111, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_10, __pyx_kp_u_fuse_getattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_10, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 111, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":110 * ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":98 * save_retval(fuse_getattr_async(c)) * * async def fuse_getattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_getattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":114 * * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, struct_stat *stat, # <<<<<<<<<<<<<< * int to_set, fuse_file_info *fi): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_setattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct stat *__pyx_v_stat, int __pyx_v_to_set, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_fh = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_setattr", 0); /* "src/handlers.pxi":116 * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, struct_stat *stat, * int to_set, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 116, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":117 * int to_set, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * c.stat = stat[0] */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":118 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * c.stat = stat[0] * c.flags = to_set */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":119 * c.req = req * c.ino = ino * c.stat = stat[0] # <<<<<<<<<<<<<< * c.flags = to_set * if fi is NULL: */ __pyx_v_c->stat = (__pyx_v_stat[0]); /* "src/handlers.pxi":120 * c.ino = ino * c.stat = stat[0] * c.flags = to_set # <<<<<<<<<<<<<< * if fi is NULL: * fh = None */ __pyx_v_c->flags = __pyx_v_to_set; /* "src/handlers.pxi":121 * c.stat = stat[0] * c.flags = to_set * if fi is NULL: # <<<<<<<<<<<<<< * fh = None * else: */ __pyx_t_2 = ((__pyx_v_fi == NULL) != 0); if (__pyx_t_2) { /* "src/handlers.pxi":122 * c.flags = to_set * if fi is NULL: * fh = None # <<<<<<<<<<<<<< * else: * fh = fi.fh */ __Pyx_INCREF(Py_None); __pyx_v_fh = Py_None; /* "src/handlers.pxi":121 * c.stat = stat[0] * c.flags = to_set * if fi is NULL: # <<<<<<<<<<<<<< * fh = None * else: */ goto __pyx_L3; } /* "src/handlers.pxi":124 * fh = None * else: * fh = fi.fh # <<<<<<<<<<<<<< * save_retval(fuse_setattr_async(c, fh)) * */ /*else*/ { __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_fi->fh); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 124, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_fh = __pyx_t_1; __pyx_t_1 = 0; } __pyx_L3:; /* "src/handlers.pxi":125 * else: * fh = fi.fh * save_retval(fuse_setattr_async(c, fh)) # <<<<<<<<<<<<<< * * async def fuse_setattr_async (_Container c, fh): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_setattr_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_v_fh}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 125, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_v_fh}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 125, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_INCREF(__pyx_v_fh); __Pyx_GIVEREF(__pyx_v_fh); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_fh); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 125, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":114 * * * cdef void fuse_setattr (fuse_req_t req, fuse_ino_t ino, struct_stat *stat, # <<<<<<<<<<<<<< * int to_set, fuse_file_info *fi): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_setattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_XDECREF(__pyx_v_fh); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_8generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":127 * save_retval(fuse_setattr_async(c, fh)) * * async def fuse_setattr_async (_Container c, fh): # <<<<<<<<<<<<<< * cdef int ret * cdef timespec now */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_7fuse_setattr_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_6fuse_setattr_async[] = "fuse_setattr_async(_Container c, fh)"; static PyMethodDef __pyx_mdef_7pyfuse3_7fuse_setattr_async = {"fuse_setattr_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_7fuse_setattr_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_6fuse_setattr_async}; static PyObject *__pyx_pw_7pyfuse3_7fuse_setattr_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_fh = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_setattr_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_fh,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fh)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_setattr_async", 1, 2, 2, 1); __PYX_ERR(1, 127, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_setattr_async") < 0)) __PYX_ERR(1, 127, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_fh = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_setattr_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 127, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_setattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 127, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_6fuse_setattr_async(__pyx_self, __pyx_v_c, __pyx_v_fh); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_6fuse_setattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_fh) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_setattr_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 127, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_fh = __pyx_v_fh; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_fh); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_fh); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_8generator2, __pyx_codeobj__6, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_setattr_async, __pyx_n_s_fuse_setattr_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 127, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_setattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_8generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; int __pyx_t_1; PyObject *__pyx_t_2 = NULL; struct stat *__pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; time_t __pyx_t_9; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; char const *__pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_setattr_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L14_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 127, __pyx_L1_error) /* "src/handlers.pxi":133 * cdef SetattrFields fields * cdef struct_stat *attr * cdef int to_set = c.flags # <<<<<<<<<<<<<< * * ctx = get_request_context(c.req) */ __pyx_t_1 = __pyx_cur_scope->__pyx_v_c->flags; __pyx_cur_scope->__pyx_v_to_set = __pyx_t_1; /* "src/handlers.pxi":135 * cdef int to_set = c.flags * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * entry = EntryAttributes() * fields = SetattrFields.__new__(SetattrFields) */ __pyx_t_2 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":136 * * ctx = get_request_context(c.req) * entry = EntryAttributes() # <<<<<<<<<<<<<< * fields = SetattrFields.__new__(SetattrFields) * string.memcpy(entry.attr, &c.stat, sizeof(struct_stat)) */ __pyx_t_2 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3_EntryAttributes)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_v_entry = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":137 * ctx = get_request_context(c.req) * entry = EntryAttributes() * fields = SetattrFields.__new__(SetattrFields) # <<<<<<<<<<<<<< * string.memcpy(entry.attr, &c.stat, sizeof(struct_stat)) * */ __pyx_t_2 = ((PyObject *)__pyx_tp_new_7pyfuse3_SetattrFields(((PyTypeObject *)__pyx_ptype_7pyfuse3_SetattrFields), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 137, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_2)); __Pyx_GIVEREF(((PyObject *)__pyx_t_2)); __pyx_cur_scope->__pyx_v_fields = ((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":138 * entry = EntryAttributes() * fields = SetattrFields.__new__(SetattrFields) * string.memcpy(entry.attr, &c.stat, sizeof(struct_stat)) # <<<<<<<<<<<<<< * * attr = entry.attr */ (void)(memcpy(__pyx_cur_scope->__pyx_v_entry->attr, (&__pyx_cur_scope->__pyx_v_c->stat), (sizeof(struct stat)))); /* "src/handlers.pxi":140 * string.memcpy(entry.attr, &c.stat, sizeof(struct_stat)) * * attr = entry.attr # <<<<<<<<<<<<<< * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = libc_extra.gettime_realtime(&now) */ __pyx_t_3 = __pyx_cur_scope->__pyx_v_entry->attr; __pyx_cur_scope->__pyx_v_attr = __pyx_t_3; /* "src/handlers.pxi":141 * * attr = entry.attr * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): # <<<<<<<<<<<<<< * ret = libc_extra.gettime_realtime(&now) * if ret != 0: */ __pyx_t_4 = ((__pyx_cur_scope->__pyx_v_to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW)) != 0); if (__pyx_t_4) { /* "src/handlers.pxi":142 * attr = entry.attr * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = libc_extra.gettime_realtime(&now) # <<<<<<<<<<<<<< * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', */ __pyx_cur_scope->__pyx_v_ret = gettime_realtime((&__pyx_cur_scope->__pyx_v_now)); /* "src/handlers.pxi":143 * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = libc_extra.gettime_realtime(&now) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) */ __pyx_t_4 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_4) { /* "src/handlers.pxi":144 * ret = libc_extra.gettime_realtime(&now) * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', # <<<<<<<<<<<<<< * strerror(errno.errno)) * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":145 * if ret != 0: * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_ATIME: */ __pyx_t_5 = __pyx_f_7pyfuse3_strerror(errno); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 145, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_setattr_clock_gettime_CLOCK, __pyx_t_5}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 144, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_setattr_clock_gettime_CLOCK, __pyx_t_5}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 2+__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 144, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_8 = PyTuple_New(2+__pyx_t_1); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); __Pyx_GIVEREF(__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_1, __pyx_kp_u_fuse_setattr_clock_gettime_CLOCK); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_1, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 144, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":143 * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): * ret = libc_extra.gettime_realtime(&now) * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): clock_gettime(CLOCK_REALTIME) failed with %s', * strerror(errno.errno)) */ } /* "src/handlers.pxi":141 * * attr = entry.attr * if to_set & (FUSE_SET_ATTR_ATIME_NOW | FUSE_SET_ATTR_MTIME_NOW): # <<<<<<<<<<<<<< * ret = libc_extra.gettime_realtime(&now) * if ret != 0: */ } /* "src/handlers.pxi":147 * strerror(errno.errno)) * * if to_set & FUSE_SET_ATTR_ATIME: # <<<<<<<<<<<<<< * fields.update_atime = True * elif to_set & FUSE_SET_ATTR_ATIME_NOW: */ __pyx_t_4 = ((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_ATIME) != 0); if (__pyx_t_4) { /* "src/handlers.pxi":148 * * if to_set & FUSE_SET_ATTR_ATIME: * fields.update_atime = True # <<<<<<<<<<<<<< * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * fields.update_atime = True */ __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_atime); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_atime); __pyx_cur_scope->__pyx_v_fields->update_atime = Py_True; /* "src/handlers.pxi":147 * strerror(errno.errno)) * * if to_set & FUSE_SET_ATTR_ATIME: # <<<<<<<<<<<<<< * fields.update_atime = True * elif to_set & FUSE_SET_ATTR_ATIME_NOW: */ goto __pyx_L6; } /* "src/handlers.pxi":149 * if to_set & FUSE_SET_ATTR_ATIME: * fields.update_atime = True * elif to_set & FUSE_SET_ATTR_ATIME_NOW: # <<<<<<<<<<<<<< * fields.update_atime = True * attr.st_atime = now.tv_sec */ __pyx_t_4 = ((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_ATIME_NOW) != 0); if (__pyx_t_4) { /* "src/handlers.pxi":150 * fields.update_atime = True * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * fields.update_atime = True # <<<<<<<<<<<<<< * attr.st_atime = now.tv_sec * SET_ATIME_NS(attr, now.tv_nsec) */ __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_atime); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_atime); __pyx_cur_scope->__pyx_v_fields->update_atime = Py_True; /* "src/handlers.pxi":151 * elif to_set & FUSE_SET_ATTR_ATIME_NOW: * fields.update_atime = True * attr.st_atime = now.tv_sec # <<<<<<<<<<<<<< * SET_ATIME_NS(attr, now.tv_nsec) * */ __pyx_t_9 = __pyx_cur_scope->__pyx_v_now.tv_sec; __pyx_cur_scope->__pyx_v_attr->st_atime = __pyx_t_9; /* "src/handlers.pxi":152 * fields.update_atime = True * attr.st_atime = now.tv_sec * SET_ATIME_NS(attr, now.tv_nsec) # <<<<<<<<<<<<<< * * if to_set & FUSE_SET_ATTR_MTIME: */ SET_ATIME_NS(__pyx_cur_scope->__pyx_v_attr, __pyx_cur_scope->__pyx_v_now.tv_nsec); /* "src/handlers.pxi":149 * if to_set & FUSE_SET_ATTR_ATIME: * fields.update_atime = True * elif to_set & FUSE_SET_ATTR_ATIME_NOW: # <<<<<<<<<<<<<< * fields.update_atime = True * attr.st_atime = now.tv_sec */ } __pyx_L6:; /* "src/handlers.pxi":154 * SET_ATIME_NS(attr, now.tv_nsec) * * if to_set & FUSE_SET_ATTR_MTIME: # <<<<<<<<<<<<<< * fields.update_mtime = True * elif to_set & FUSE_SET_ATTR_MTIME_NOW: */ __pyx_t_4 = ((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_MTIME) != 0); if (__pyx_t_4) { /* "src/handlers.pxi":155 * * if to_set & FUSE_SET_ATTR_MTIME: * fields.update_mtime = True # <<<<<<<<<<<<<< * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * fields.update_mtime = True */ __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_mtime); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_mtime); __pyx_cur_scope->__pyx_v_fields->update_mtime = Py_True; /* "src/handlers.pxi":154 * SET_ATIME_NS(attr, now.tv_nsec) * * if to_set & FUSE_SET_ATTR_MTIME: # <<<<<<<<<<<<<< * fields.update_mtime = True * elif to_set & FUSE_SET_ATTR_MTIME_NOW: */ goto __pyx_L7; } /* "src/handlers.pxi":156 * if to_set & FUSE_SET_ATTR_MTIME: * fields.update_mtime = True * elif to_set & FUSE_SET_ATTR_MTIME_NOW: # <<<<<<<<<<<<<< * fields.update_mtime = True * attr.st_mtime = now.tv_sec */ __pyx_t_4 = ((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_MTIME_NOW) != 0); if (__pyx_t_4) { /* "src/handlers.pxi":157 * fields.update_mtime = True * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * fields.update_mtime = True # <<<<<<<<<<<<<< * attr.st_mtime = now.tv_sec * SET_MTIME_NS(attr, now.tv_nsec) */ __Pyx_INCREF(Py_True); __Pyx_GIVEREF(Py_True); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_mtime); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_mtime); __pyx_cur_scope->__pyx_v_fields->update_mtime = Py_True; /* "src/handlers.pxi":158 * elif to_set & FUSE_SET_ATTR_MTIME_NOW: * fields.update_mtime = True * attr.st_mtime = now.tv_sec # <<<<<<<<<<<<<< * SET_MTIME_NS(attr, now.tv_nsec) * */ __pyx_t_9 = __pyx_cur_scope->__pyx_v_now.tv_sec; __pyx_cur_scope->__pyx_v_attr->st_mtime = __pyx_t_9; /* "src/handlers.pxi":159 * fields.update_mtime = True * attr.st_mtime = now.tv_sec * SET_MTIME_NS(attr, now.tv_nsec) # <<<<<<<<<<<<<< * * fields.update_ctime = bool(to_set & FUSE_SET_ATTR_CTIME) */ SET_MTIME_NS(__pyx_cur_scope->__pyx_v_attr, __pyx_cur_scope->__pyx_v_now.tv_nsec); /* "src/handlers.pxi":156 * if to_set & FUSE_SET_ATTR_MTIME: * fields.update_mtime = True * elif to_set & FUSE_SET_ATTR_MTIME_NOW: # <<<<<<<<<<<<<< * fields.update_mtime = True * attr.st_mtime = now.tv_sec */ } __pyx_L7:; /* "src/handlers.pxi":161 * SET_MTIME_NS(attr, now.tv_nsec) * * fields.update_ctime = bool(to_set & FUSE_SET_ATTR_CTIME) # <<<<<<<<<<<<<< * fields.update_mode = bool(to_set & FUSE_SET_ATTR_MODE) * fields.update_uid = bool(to_set & FUSE_SET_ATTR_UID) */ __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_CTIME)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 161, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_4))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 161, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_ctime); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_ctime); __pyx_cur_scope->__pyx_v_fields->update_ctime = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":162 * * fields.update_ctime = bool(to_set & FUSE_SET_ATTR_CTIME) * fields.update_mode = bool(to_set & FUSE_SET_ATTR_MODE) # <<<<<<<<<<<<<< * fields.update_uid = bool(to_set & FUSE_SET_ATTR_UID) * fields.update_gid = bool(to_set & FUSE_SET_ATTR_GID) */ __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_MODE)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 162, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_4))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 162, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_mode); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_mode); __pyx_cur_scope->__pyx_v_fields->update_mode = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":163 * fields.update_ctime = bool(to_set & FUSE_SET_ATTR_CTIME) * fields.update_mode = bool(to_set & FUSE_SET_ATTR_MODE) * fields.update_uid = bool(to_set & FUSE_SET_ATTR_UID) # <<<<<<<<<<<<<< * fields.update_gid = bool(to_set & FUSE_SET_ATTR_GID) * fields.update_size = bool(to_set & FUSE_SET_ATTR_SIZE) */ __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_UID)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 163, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_4))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 163, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_uid); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_uid); __pyx_cur_scope->__pyx_v_fields->update_uid = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":164 * fields.update_mode = bool(to_set & FUSE_SET_ATTR_MODE) * fields.update_uid = bool(to_set & FUSE_SET_ATTR_UID) * fields.update_gid = bool(to_set & FUSE_SET_ATTR_GID) # <<<<<<<<<<<<<< * fields.update_size = bool(to_set & FUSE_SET_ATTR_SIZE) * */ __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_GID)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 164, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_4))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_gid); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_gid); __pyx_cur_scope->__pyx_v_fields->update_gid = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":165 * fields.update_uid = bool(to_set & FUSE_SET_ATTR_UID) * fields.update_gid = bool(to_set & FUSE_SET_ATTR_GID) * fields.update_size = bool(to_set & FUSE_SET_ATTR_SIZE) # <<<<<<<<<<<<<< * * try: */ __pyx_t_2 = __Pyx_PyInt_From_int((__pyx_cur_scope->__pyx_v_to_set & FUSE_SET_ATTR_SIZE)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 165, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyBool_FromLong((!(!__pyx_t_4))); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_fields->update_size); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_fields->update_size); __pyx_cur_scope->__pyx_v_fields->update_size = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":167 * fields.update_size = bool(to_set & FUSE_SET_ATTR_SIZE) * * try: # <<<<<<<<<<<<<< * entry = await operations.setattr(c.ino, entry, fields, fh, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { /* "src/handlers.pxi":168 * * try: * entry = await operations.setattr(c.ino, entry, fields, fh, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_setattr); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 168, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 168, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_5 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[6] = {__pyx_t_5, __pyx_t_8, ((PyObject *)__pyx_cur_scope->__pyx_v_entry), ((PyObject *)__pyx_cur_scope->__pyx_v_fields), __pyx_cur_scope->__pyx_v_fh, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 5+__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 168, __pyx_L8_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[6] = {__pyx_t_5, __pyx_t_8, ((PyObject *)__pyx_cur_scope->__pyx_v_entry), ((PyObject *)__pyx_cur_scope->__pyx_v_fields), __pyx_cur_scope->__pyx_v_fh, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 5+__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 168, __pyx_L8_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif { __pyx_t_7 = PyTuple_New(5+__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 168, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_1, __pyx_t_8); __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_entry)); __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_entry)); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_1, ((PyObject *)__pyx_cur_scope->__pyx_v_entry)); __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_fields)); __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_fields)); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_1, ((PyObject *)__pyx_cur_scope->__pyx_v_fields)); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_fh); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_fh); PyTuple_SET_ITEM(__pyx_t_7, 3+__pyx_t_1, __pyx_cur_scope->__pyx_v_fh); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_7, 4+__pyx_t_1, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_8 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_7, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 168, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_10); __pyx_cur_scope->__pyx_t_0 = __pyx_t_10; __Pyx_XGIVEREF(__pyx_t_11); __pyx_cur_scope->__pyx_t_1 = __pyx_t_11; __Pyx_XGIVEREF(__pyx_t_12); __pyx_cur_scope->__pyx_t_2 = __pyx_t_12; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L14_resume_from_await:; __pyx_t_10 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_10); __pyx_t_11 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_11); __pyx_t_12 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 168, __pyx_L8_error) __pyx_t_2 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_2); } else { __pyx_t_2 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_2) < 0) __PYX_ERR(1, 168, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_2); } if (!(likely(__Pyx_TypeTest(__pyx_t_2, __pyx_ptype_7pyfuse3_EntryAttributes)))) __PYX_ERR(1, 168, __pyx_L8_error) __pyx_t_6 = __pyx_t_2; __Pyx_INCREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_GOTREF(((PyObject *)__pyx_cur_scope->__pyx_v_entry)); __Pyx_DECREF_SET(__pyx_cur_scope->__pyx_v_entry, ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_6)); __Pyx_GIVEREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/handlers.pxi":167 * fields.update_size = bool(to_set & FUSE_SET_ATTR_SIZE) * * try: # <<<<<<<<<<<<<< * entry = await operations.setattr(c.ino, entry, fields, fh, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":172 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_attr(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_entry->attr, __pyx_cur_scope->__pyx_v_entry->fuse_param.attr_timeout); } __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L13_try_end; __pyx_L8_error:; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/handlers.pxi":169 * try: * entry = await operations.setattr(c.ino, entry, fields, fh, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_1 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_1) { __Pyx_AddTraceback("pyfuse3.fuse_setattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_2, &__pyx_t_7) < 0) __PYX_ERR(1, 169, __pyx_L10_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_7); __Pyx_INCREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_v_e = __pyx_t_2; /*try:*/ { /* "src/handlers.pxi":170 * entry = await operations.setattr(c.ino, entry, fields, fh, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 170, __pyx_L20_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 170, __pyx_L20_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_1); } /* "src/handlers.pxi":169 * try: * entry = await operations.setattr(c.ino, entry, fields, fh, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L21; } __pyx_L20_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_1 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17); __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14; goto __pyx_L10_except_error; } __pyx_L21:; } __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L9_exception_handled; } goto __pyx_L10_except_error; __pyx_L10_except_error:; /* "src/handlers.pxi":167 * fields.update_size = bool(to_set & FUSE_SET_ATTR_SIZE) * * try: # <<<<<<<<<<<<<< * entry = await operations.setattr(c.ino, entry, fields, fh, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); goto __pyx_L1_error; __pyx_L9_exception_handled:; __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); __pyx_L13_try_end:; } /* "src/handlers.pxi":174 * ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_4 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_4) { /* "src/handlers.pxi":175 * * if ret != 0: * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_log); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_8 = NULL; __pyx_t_13 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_13 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_setattr_fuse_reply__failed, __pyx_t_2}; __pyx_t_7 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 175, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_setattr_fuse_reply__failed, __pyx_t_2}; __pyx_t_7 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 175, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } else #endif { __pyx_t_5 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_setattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_5, 0+__pyx_t_13, __pyx_kp_u_fuse_setattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 1+__pyx_t_13, __pyx_t_2); __pyx_t_2 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_5, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 175, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/handlers.pxi":174 * ret = fuse_reply_attr(c.req, entry.attr, entry.fuse_param.attr_timeout) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":127 * save_retval(fuse_setattr_async(c, fh)) * * async def fuse_setattr_async (_Container c, fh): # <<<<<<<<<<<<<< * cdef int ret * cdef timespec now */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("fuse_setattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":178 * * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_readlink(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_readlink", 0); /* "src/handlers.pxi":179 * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 179, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":180 * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * save_retval(fuse_readlink_async(c)) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":181 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * save_retval(fuse_readlink_async(c)) * */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":182 * c.req = req * c.ino = ino * save_retval(fuse_readlink_async(c)) # <<<<<<<<<<<<<< * * async def fuse_readlink_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_readlink_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 182, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 182, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":178 * * * cdef void fuse_readlink (fuse_req_t req, fuse_ino_t ino): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyfuse3.fuse_readlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_11generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":184 * save_retval(fuse_readlink_async(c)) * * async def fuse_readlink_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_10fuse_readlink_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_9fuse_readlink_async[] = "fuse_readlink_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_10fuse_readlink_async = {"fuse_readlink_async", (PyCFunction)__pyx_pw_7pyfuse3_10fuse_readlink_async, METH_O, __pyx_doc_7pyfuse3_9fuse_readlink_async}; static PyObject *__pyx_pw_7pyfuse3_10fuse_readlink_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_readlink_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 184, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_9fuse_readlink_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_9fuse_readlink_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_readlink_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 184, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_11generator3, __pyx_codeobj__7, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_readlink_async, __pyx_n_s_fuse_readlink_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 184, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_readlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_11generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; char *__pyx_t_10; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_readlink_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 184, __pyx_L1_error) /* "src/handlers.pxi":187 * cdef int ret * cdef char* name * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * target = await operations.readlink(c.ino, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 187, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":188 * cdef char* name * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * target = await operations.readlink(c.ino, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":189 * ctx = get_request_context(c.req) * try: * target = await operations.readlink(c.ino, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_readlink); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 189, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 189, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 189, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 189, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 189, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 189, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 189, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 189, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_target = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":188 * cdef char* name * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * target = await operations.readlink(c.ino, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":193 * ret = fuse_reply_err(c.req, e.errno) * else: * name = PyBytes_AsString(target) # <<<<<<<<<<<<<< * ret = fuse_reply_readlink(c.req, name) * */ /*else:*/ { __pyx_t_10 = PyBytes_AsString(__pyx_cur_scope->__pyx_v_target); if (unlikely(__pyx_t_10 == ((char *)NULL))) __PYX_ERR(1, 193, __pyx_L6_except_error) __pyx_cur_scope->__pyx_v_name = __pyx_t_10; /* "src/handlers.pxi":194 * else: * name = PyBytes_AsString(target) * ret = fuse_reply_readlink(c.req, name) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_readlink(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_name); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":190 * try: * target = await operations.readlink(c.ino, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_readlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(1, 190, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":191 * target = await operations.readlink(c.ino, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * name = PyBytes_AsString(target) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 191, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 191, __pyx_L16_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":190 * try: * target = await operations.readlink(c.ino, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_8 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":188 * cdef char* name * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * target = await operations.readlink(c.ino, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":196 * ret = fuse_reply_readlink(c.req, name) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/handlers.pxi":197 * * if ret != 0: * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_readlink_fuse_reply__failed, __pyx_t_5}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 197, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_readlink_fuse_reply__failed, __pyx_t_5}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 197, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_readlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_readlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_11, __pyx_kp_u_fuse_readlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_11, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":196 * ret = fuse_reply_readlink(c.req, name) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":184 * save_retval(fuse_readlink_async(c)) * * async def fuse_readlink_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_readlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":200 * * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, dev_t rdev): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_mknod(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode, dev_t __pyx_v_rdev) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_mknod", 0); /* "src/handlers.pxi":202 * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, * mode_t mode, dev_t rdev): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.parent = parent */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 202, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":203 * mode_t mode, dev_t rdev): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.parent = parent * c.mode = mode */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":204 * cdef _Container c = _Container() * c.req = req * c.parent = parent # <<<<<<<<<<<<<< * c.mode = mode * c.rdev = rdev */ __pyx_v_c->parent = __pyx_v_parent; /* "src/handlers.pxi":205 * c.req = req * c.parent = parent * c.mode = mode # <<<<<<<<<<<<<< * c.rdev = rdev * save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) */ __pyx_v_c->mode = __pyx_v_mode; /* "src/handlers.pxi":206 * c.parent = parent * c.mode = mode * c.rdev = rdev # <<<<<<<<<<<<<< * save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) * */ __pyx_v_c->rdev = __pyx_v_rdev; /* "src/handlers.pxi":207 * c.mode = mode * c.rdev = rdev * save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) # <<<<<<<<<<<<<< * * async def fuse_mknod_async (_Container c, name): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_mknod_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 207, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 207, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":200 * * * cdef void fuse_mknod (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, dev_t rdev): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_mknod", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_14generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":209 * save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) * * async def fuse_mknod_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13fuse_mknod_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_12fuse_mknod_async[] = "fuse_mknod_async(_Container c, name)"; static PyMethodDef __pyx_mdef_7pyfuse3_13fuse_mknod_async = {"fuse_mknod_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_13fuse_mknod_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_12fuse_mknod_async}; static PyObject *__pyx_pw_7pyfuse3_13fuse_mknod_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_mknod_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_mknod_async", 1, 2, 2, 1); __PYX_ERR(1, 209, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_mknod_async") < 0)) __PYX_ERR(1, 209, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_mknod_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 209, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_mknod_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 209, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_12fuse_mknod_async(__pyx_self, __pyx_v_c, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_12fuse_mknod_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_mknod_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 209, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_14generator4, __pyx_codeobj__8, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_mknod_async, __pyx_n_s_fuse_mknod_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 209, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_mknod_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_14generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_mknod_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 209, __pyx_L1_error) /* "src/handlers.pxi":213 * cdef EntryAttributes entry * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * entry = await operations.mknod( */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 213, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":214 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.mknod( * c.parent, name, c.mode, c.rdev, ctx) */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":215 * ctx = get_request_context(c.req) * try: * entry = await operations.mknod( # <<<<<<<<<<<<<< * c.parent, name, c.mode, c.rdev, ctx) * except FUSEError as e: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_mknod); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 215, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); /* "src/handlers.pxi":216 * try: * entry = await operations.mknod( * c.parent, name, c.mode, c.rdev, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 216, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_mode_t(__pyx_cur_scope->__pyx_v_c->mode); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 216, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_dev_t(__pyx_cur_scope->__pyx_v_c->rdev); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 216, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[6] = {__pyx_t_9, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_t_7, __pyx_t_8, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 5+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 215, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[6] = {__pyx_t_9, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_t_7, __pyx_t_8, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 5+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 215, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif { __pyx_t_11 = PyTuple_New(5+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 215, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_t_8); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 215, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 215, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 215, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } /* "src/handlers.pxi":215 * ctx = get_request_context(c.req) * try: * entry = await operations.mknod( # <<<<<<<<<<<<<< * c.parent, name, c.mode, c.rdev, ctx) * except FUSEError as e: */ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_EntryAttributes)))) __PYX_ERR(1, 215, __pyx_L4_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_entry = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":214 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.mknod( * c.parent, name, c.mode, c.rdev, ctx) */ } /* "src/handlers.pxi":220 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_entry(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_entry->fuse_param)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":217 * entry = await operations.mknod( * c.parent, name, c.mode, c.rdev, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_10) { __Pyx_AddTraceback("pyfuse3.fuse_mknod_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_11) < 0) __PYX_ERR(1, 217, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":218 * c.parent, name, c.mode, c.rdev, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 218, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 218, __pyx_L16_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_10); } /* "src/handlers.pxi":217 * entry = await operations.mknod( * c.parent, name, c.mode, c.rdev, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_10 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":214 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.mknod( * c.parent, name, c.mode, c.rdev, ctx) */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":222 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_20 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_20) { /* "src/handlers.pxi":223 * * if ret != 0: * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_12 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_mknod_fuse_reply__failed_wi, __pyx_t_1}; __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 223, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_mknod_fuse_reply__failed_wi, __pyx_t_1}; __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 223, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_12, __pyx_kp_u_fuse_mknod_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_12, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 223, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; /* "src/handlers.pxi":222 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mknod(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":209 * save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) * * async def fuse_mknod_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("fuse_mknod_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":226 * * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_mkdir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_mkdir", 0); /* "src/handlers.pxi":228 * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, * mode_t mode): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.parent = parent */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":229 * mode_t mode): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.parent = parent * c.mode = mode */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":230 * cdef _Container c = _Container() * c.req = req * c.parent = parent # <<<<<<<<<<<<<< * c.mode = mode * save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) */ __pyx_v_c->parent = __pyx_v_parent; /* "src/handlers.pxi":231 * c.req = req * c.parent = parent * c.mode = mode # <<<<<<<<<<<<<< * save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) * */ __pyx_v_c->mode = __pyx_v_mode; /* "src/handlers.pxi":232 * c.parent = parent * c.mode = mode * save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) # <<<<<<<<<<<<<< * * async def fuse_mkdir_async (_Container c, name): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_mkdir_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":226 * * * cdef void fuse_mkdir (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_mkdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_17generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":234 * save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) * * async def fuse_mkdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_16fuse_mkdir_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_15fuse_mkdir_async[] = "fuse_mkdir_async(_Container c, name)"; static PyMethodDef __pyx_mdef_7pyfuse3_16fuse_mkdir_async = {"fuse_mkdir_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_16fuse_mkdir_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_15fuse_mkdir_async}; static PyObject *__pyx_pw_7pyfuse3_16fuse_mkdir_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_mkdir_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_mkdir_async", 1, 2, 2, 1); __PYX_ERR(1, 234, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_mkdir_async") < 0)) __PYX_ERR(1, 234, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_mkdir_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 234, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_mkdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 234, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_15fuse_mkdir_async(__pyx_self, __pyx_v_c, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15fuse_mkdir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_mkdir_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 234, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_17generator5, __pyx_codeobj__9, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_mkdir_async, __pyx_n_s_fuse_mkdir_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 234, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_mkdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_17generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_mkdir_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 234, __pyx_L1_error) /* "src/handlers.pxi":240 * # Force the entry type to directory. We need to explicitly cast, * # because on BSD the S_* are not of type mode_t. * c.mode = (c.mode & ~ S_IFMT) | S_IFDIR # <<<<<<<<<<<<<< * ctx = get_request_context(c.req) * try: */ __pyx_cur_scope->__pyx_v_c->mode = ((__pyx_cur_scope->__pyx_v_c->mode & (~((mode_t)S_IFMT))) | ((mode_t)S_IFDIR)); /* "src/handlers.pxi":241 * # because on BSD the S_* are not of type mode_t. * c.mode = (c.mode & ~ S_IFMT) | S_IFDIR * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * entry = await operations.mkdir( */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":242 * c.mode = (c.mode & ~ S_IFMT) | S_IFDIR * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.mkdir( * c.parent, name, c.mode, ctx) */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":243 * ctx = get_request_context(c.req) * try: * entry = await operations.mkdir( # <<<<<<<<<<<<<< * c.parent, name, c.mode, ctx) * except FUSEError as e: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_mkdir); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 243, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); /* "src/handlers.pxi":244 * try: * entry = await operations.mkdir( * c.parent, name, c.mode, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 244, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_mode_t(__pyx_cur_scope->__pyx_v_c->mode); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 244, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_t_7, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 243, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_t_7, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 243, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(4+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 243, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_t_7); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_10, 3+__pyx_t_9, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 243, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 243, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 243, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } /* "src/handlers.pxi":243 * ctx = get_request_context(c.req) * try: * entry = await operations.mkdir( # <<<<<<<<<<<<<< * c.parent, name, c.mode, ctx) * except FUSEError as e: */ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_EntryAttributes)))) __PYX_ERR(1, 243, __pyx_L4_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_entry = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":242 * c.mode = (c.mode & ~ S_IFMT) | S_IFDIR * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.mkdir( * c.parent, name, c.mode, ctx) */ } /* "src/handlers.pxi":248 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_entry(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_entry->fuse_param)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/handlers.pxi":245 * entry = await operations.mkdir( * c.parent, name, c.mode, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_9) { __Pyx_AddTraceback("pyfuse3.fuse_mkdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_10) < 0) __PYX_ERR(1, 245, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":246 * c.parent, name, c.mode, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 246, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 246, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_9); } /* "src/handlers.pxi":245 * entry = await operations.mkdir( * c.parent, name, c.mode, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_9 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":242 * c.mode = (c.mode & ~ S_IFMT) | S_IFDIR * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.mkdir( * c.parent, name, c.mode, ctx) */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":250 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/handlers.pxi":251 * * if ret != 0: * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi, __pyx_t_1}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 251, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi, __pyx_t_1}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 251, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_11, __pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_11, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 251, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/handlers.pxi":250 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_mkdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":234 * save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) * * async def fuse_mkdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("fuse_mkdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":254 * * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_unlink(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_unlink", 0); /* "src/handlers.pxi":255 * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.parent = parent */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":256 * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.parent = parent * save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":257 * cdef _Container c = _Container() * c.req = req * c.parent = parent # <<<<<<<<<<<<<< * save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) * */ __pyx_v_c->parent = __pyx_v_parent; /* "src/handlers.pxi":258 * c.req = req * c.parent = parent * save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) # <<<<<<<<<<<<<< * * async def fuse_unlink_async (_Container c, name): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_unlink_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 258, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 258, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 258, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":254 * * * cdef void fuse_unlink (fuse_req_t req, fuse_ino_t parent, const_char *name): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_unlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_20generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":260 * save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) * * async def fuse_unlink_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_19fuse_unlink_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_18fuse_unlink_async[] = "fuse_unlink_async(_Container c, name)"; static PyMethodDef __pyx_mdef_7pyfuse3_19fuse_unlink_async = {"fuse_unlink_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_19fuse_unlink_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_18fuse_unlink_async}; static PyObject *__pyx_pw_7pyfuse3_19fuse_unlink_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_unlink_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_unlink_async", 1, 2, 2, 1); __PYX_ERR(1, 260, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_unlink_async") < 0)) __PYX_ERR(1, 260, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_unlink_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 260, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_unlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 260, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_18fuse_unlink_async(__pyx_self, __pyx_v_c, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_18fuse_unlink_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_unlink_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 260, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_20generator6, __pyx_codeobj__10, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_unlink_async, __pyx_n_s_fuse_unlink_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 260, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_unlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_20generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; char const *__pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_unlink_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 260, __pyx_L1_error) /* "src/handlers.pxi":263 * cdef int ret * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * await operations.unlink(c.parent, name, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":264 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.unlink(c.parent, name, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":265 * ctx = get_request_context(c.req) * try: * await operations.unlink(c.parent, name, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_unlink); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 265, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 265, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 265, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 265, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 265, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_name); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 265, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 265, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 265, __pyx_L4_error) } } /* "src/handlers.pxi":264 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.unlink(c.parent, name, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":269 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":266 * try: * await operations.unlink(c.parent, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_unlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(1, 266, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":267 * await operations.unlink(c.parent, name, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 267, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 267, __pyx_L16_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":266 * try: * await operations.unlink(c.parent, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_8 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14); __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":264 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.unlink(c.parent, name, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":271 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/handlers.pxi":272 * * if ret != 0: * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_unlink_fuse_reply__failed_w, __pyx_t_5}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_unlink_fuse_reply__failed_w, __pyx_t_5}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_unlink_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_unlink_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_10, __pyx_kp_u_fuse_unlink_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_10, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 272, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":271 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_unlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":260 * save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) * * async def fuse_unlink_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_unlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":275 * * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_rmdir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_rmdir", 0); /* "src/handlers.pxi":276 * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.parent = parent */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 276, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":277 * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.parent = parent * save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":278 * cdef _Container c = _Container() * c.req = req * c.parent = parent # <<<<<<<<<<<<<< * save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) * */ __pyx_v_c->parent = __pyx_v_parent; /* "src/handlers.pxi":279 * c.req = req * c.parent = parent * save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) # <<<<<<<<<<<<<< * * async def fuse_rmdir_async (_Container c, name): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_rmdir_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 279, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 279, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 279, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":275 * * * cdef void fuse_rmdir (fuse_req_t req, fuse_ino_t parent, const_char *name): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_rmdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_23generator7(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":281 * save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) * * async def fuse_rmdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_22fuse_rmdir_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_21fuse_rmdir_async[] = "fuse_rmdir_async(_Container c, name)"; static PyMethodDef __pyx_mdef_7pyfuse3_22fuse_rmdir_async = {"fuse_rmdir_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_22fuse_rmdir_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_21fuse_rmdir_async}; static PyObject *__pyx_pw_7pyfuse3_22fuse_rmdir_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_rmdir_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_rmdir_async", 1, 2, 2, 1); __PYX_ERR(1, 281, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_rmdir_async") < 0)) __PYX_ERR(1, 281, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_rmdir_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 281, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_rmdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 281, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_21fuse_rmdir_async(__pyx_self, __pyx_v_c, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_21fuse_rmdir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_rmdir_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 281, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_23generator7, __pyx_codeobj__11, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_rmdir_async, __pyx_n_s_fuse_rmdir_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 281, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_rmdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_23generator7(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; char const *__pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_rmdir_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 281, __pyx_L1_error) /* "src/handlers.pxi":284 * cdef int ret * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * await operations.rmdir(c.parent, name, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":285 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.rmdir(c.parent, name, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":286 * ctx = get_request_context(c.req) * try: * await operations.rmdir(c.parent, name, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_rmdir); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 286, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 286, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 286, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_name); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 286, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 286, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 286, __pyx_L4_error) } } /* "src/handlers.pxi":285 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.rmdir(c.parent, name, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":290 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":287 * try: * await operations.rmdir(c.parent, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_rmdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(1, 287, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":288 * await operations.rmdir(c.parent, name, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 288, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 288, __pyx_L16_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":287 * try: * await operations.rmdir(c.parent, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_8 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14); __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":285 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.rmdir(c.parent, name, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":292 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/handlers.pxi":293 * * if ret != 0: * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi, __pyx_t_5}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi, __pyx_t_5}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_10, __pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_10, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 293, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":292 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rmdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":281 * save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) * * async def fuse_rmdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_rmdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":296 * * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_symlink(fuse_req_t __pyx_v_req, const char *__pyx_v_link, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_symlink", 0); /* "src/handlers.pxi":298 * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, * const_char *name): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.parent = parent */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 298, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":299 * const_char *name): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.parent = parent * save_retval(fuse_symlink_async( */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":300 * cdef _Container c = _Container() * c.req = req * c.parent = parent # <<<<<<<<<<<<<< * save_retval(fuse_symlink_async( * c, PyBytes_FromString(name), PyBytes_FromString(link))) */ __pyx_v_c->parent = __pyx_v_parent; /* "src/handlers.pxi":301 * c.req = req * c.parent = parent * save_retval(fuse_symlink_async( # <<<<<<<<<<<<<< * c, PyBytes_FromString(name), PyBytes_FromString(link))) * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_symlink_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "src/handlers.pxi":302 * c.parent = parent * save_retval(fuse_symlink_async( * c, PyBytes_FromString(name), PyBytes_FromString(link))) # <<<<<<<<<<<<<< * * async def fuse_symlink_async (_Container c, name, link): */ __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyBytes_FromString(__pyx_v_link); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 302, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[4] = {__pyx_t_5, ((PyObject *)__pyx_v_c), __pyx_t_3, __pyx_t_4}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[4] = {__pyx_t_5, ((PyObject *)__pyx_v_c), __pyx_t_3, __pyx_t_4}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":301 * c.req = req * c.parent = parent * save_retval(fuse_symlink_async( # <<<<<<<<<<<<<< * c, PyBytes_FromString(name), PyBytes_FromString(link))) * */ __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":296 * * * cdef void fuse_symlink (fuse_req_t req, const_char *link, fuse_ino_t parent, # <<<<<<<<<<<<<< * const_char *name): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_WriteUnraisable("pyfuse3.fuse_symlink", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_26generator8(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":304 * c, PyBytes_FromString(name), PyBytes_FromString(link))) * * async def fuse_symlink_async (_Container c, name, link): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_25fuse_symlink_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_24fuse_symlink_async[] = "fuse_symlink_async(_Container c, name, link)"; static PyMethodDef __pyx_mdef_7pyfuse3_25fuse_symlink_async = {"fuse_symlink_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_25fuse_symlink_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_24fuse_symlink_async}; static PyObject *__pyx_pw_7pyfuse3_25fuse_symlink_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; PyObject *__pyx_v_link = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_symlink_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,&__pyx_n_s_link,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_symlink_async", 1, 3, 3, 1); __PYX_ERR(1, 304, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_link)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_symlink_async", 1, 3, 3, 2); __PYX_ERR(1, 304, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_symlink_async") < 0)) __PYX_ERR(1, 304, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; __pyx_v_link = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_symlink_async", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 304, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_symlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 304, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_24fuse_symlink_async(__pyx_self, __pyx_v_c, __pyx_v_name, __pyx_v_link); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_24fuse_symlink_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name, PyObject *__pyx_v_link) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_symlink_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 304, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); __pyx_cur_scope->__pyx_v_link = __pyx_v_link; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_link); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_link); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_26generator8, __pyx_codeobj__12, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_symlink_async, __pyx_n_s_fuse_symlink_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 304, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_symlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_26generator8(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; char const *__pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_symlink_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 304, __pyx_L1_error) /* "src/handlers.pxi":308 * cdef EntryAttributes entry * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * entry = await operations.symlink( */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 308, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":309 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.symlink( * c.parent, name, link, ctx) */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":310 * ctx = get_request_context(c.req) * try: * entry = await operations.symlink( # <<<<<<<<<<<<<< * c.parent, name, link, ctx) * except FUSEError as e: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_symlink); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 310, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); /* "src/handlers.pxi":311 * try: * entry = await operations.symlink( * c.parent, name, link, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 311, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_link, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 310, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[5] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_link, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 4+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 310, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(4+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 310, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_name); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_link); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_link); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_cur_scope->__pyx_v_link); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 3+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 310, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 310, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 310, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } /* "src/handlers.pxi":310 * ctx = get_request_context(c.req) * try: * entry = await operations.symlink( # <<<<<<<<<<<<<< * c.parent, name, link, ctx) * except FUSEError as e: */ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_EntryAttributes)))) __PYX_ERR(1, 310, __pyx_L4_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_entry = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":309 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.symlink( * c.parent, name, link, ctx) */ } /* "src/handlers.pxi":315 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_entry(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_entry->fuse_param)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":312 * entry = await operations.symlink( * c.parent, name, link, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_symlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(1, 312, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":313 * c.parent, name, link, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 313, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 313, __pyx_L16_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":312 * entry = await operations.symlink( * c.parent, name, link, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_8 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14); __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":309 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.symlink( * c.parent, name, link, ctx) */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":317 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/handlers.pxi":318 * * if ret != 0: * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_symlink_fuse_reply__failed, __pyx_t_1}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 318, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_symlink_fuse_reply__failed, __pyx_t_1}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 318, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_symlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_symlink_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_10, __pyx_kp_u_fuse_symlink_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_10, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 318, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":317 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_symlink(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":304 * c, PyBytes_FromString(name), PyBytes_FromString(link))) * * async def fuse_symlink_async (_Container c, name, link): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_symlink_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":321 * * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * fuse_ino_t newparent, const_char *newname, unsigned flags): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_rename(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, fuse_ino_t __pyx_v_newparent, const char *__pyx_v_newname, unsigned int __pyx_v_flags) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_rename", 0); /* "src/handlers.pxi":323 * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, * fuse_ino_t newparent, const_char *newname, unsigned flags): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.parent = parent */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 323, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":324 * fuse_ino_t newparent, const_char *newname, unsigned flags): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.parent = parent * c.ino = newparent */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":325 * cdef _Container c = _Container() * c.req = req * c.parent = parent # <<<<<<<<<<<<<< * c.ino = newparent * c.flags = flags */ __pyx_v_c->parent = __pyx_v_parent; /* "src/handlers.pxi":326 * c.req = req * c.parent = parent * c.ino = newparent # <<<<<<<<<<<<<< * c.flags = flags * save_retval(fuse_rename_async( */ __pyx_v_c->ino = __pyx_v_newparent; /* "src/handlers.pxi":327 * c.parent = parent * c.ino = newparent * c.flags = flags # <<<<<<<<<<<<<< * save_retval(fuse_rename_async( * c, PyBytes_FromString(name), PyBytes_FromString(newname))) */ __pyx_v_c->flags = ((int)__pyx_v_flags); /* "src/handlers.pxi":328 * c.ino = newparent * c.flags = flags * save_retval(fuse_rename_async( # <<<<<<<<<<<<<< * c, PyBytes_FromString(name), PyBytes_FromString(newname))) * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_rename_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "src/handlers.pxi":329 * c.flags = flags * save_retval(fuse_rename_async( * c, PyBytes_FromString(name), PyBytes_FromString(newname))) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyBytes_FromString(__pyx_v_newname); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 329, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[4] = {__pyx_t_5, ((PyObject *)__pyx_v_c), __pyx_t_3, __pyx_t_4}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 328, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[4] = {__pyx_t_5, ((PyObject *)__pyx_v_c), __pyx_t_3, __pyx_t_4}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 3+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 328, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_7 = PyTuple_New(3+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 2+__pyx_t_6, __pyx_t_4); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 328, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":328 * c.ino = newparent * c.flags = flags * save_retval(fuse_rename_async( # <<<<<<<<<<<<<< * c, PyBytes_FromString(name), PyBytes_FromString(newname))) * */ __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":321 * * * cdef void fuse_rename (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * fuse_ino_t newparent, const_char *newname, unsigned flags): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_WriteUnraisable("pyfuse3.fuse_rename", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_29generator9(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":332 * * * async def fuse_rename_async (_Container c, name, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef unsigned flags = c.flags */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_28fuse_rename_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_27fuse_rename_async[] = "fuse_rename_async(_Container c, name, newname)"; static PyMethodDef __pyx_mdef_7pyfuse3_28fuse_rename_async = {"fuse_rename_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_28fuse_rename_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_27fuse_rename_async}; static PyObject *__pyx_pw_7pyfuse3_28fuse_rename_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; PyObject *__pyx_v_newname = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_rename_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,&__pyx_n_s_newname,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_rename_async", 1, 3, 3, 1); __PYX_ERR(1, 332, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_newname)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_rename_async", 1, 3, 3, 2); __PYX_ERR(1, 332, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_rename_async") < 0)) __PYX_ERR(1, 332, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; __pyx_v_newname = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_rename_async", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 332, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_rename_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 332, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_27fuse_rename_async(__pyx_self, __pyx_v_c, __pyx_v_name, __pyx_v_newname); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_27fuse_rename_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name, PyObject *__pyx_v_newname) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_rename_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_9_fuse_rename_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_9_fuse_rename_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 332, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); __pyx_cur_scope->__pyx_v_newname = __pyx_v_newname; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_newname); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_newname); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_29generator9, __pyx_codeobj__13, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_rename_async, __pyx_n_s_fuse_rename_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 332, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_rename_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_29generator9(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; fuse_ino_t __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; char const *__pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; int __pyx_t_21; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_rename_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 332, __pyx_L1_error) /* "src/handlers.pxi":334 * async def fuse_rename_async (_Container c, name, newname): * cdef int ret * cdef unsigned flags = c.flags # <<<<<<<<<<<<<< * cdef fuse_ino_t newparent = c.ino * */ __pyx_cur_scope->__pyx_v_flags = ((unsigned int)__pyx_cur_scope->__pyx_v_c->flags); /* "src/handlers.pxi":335 * cdef int ret * cdef unsigned flags = c.flags * cdef fuse_ino_t newparent = c.ino # <<<<<<<<<<<<<< * * ctx = get_request_context(c.req) */ __pyx_t_1 = __pyx_cur_scope->__pyx_v_c->ino; __pyx_cur_scope->__pyx_v_newparent = __pyx_t_1; /* "src/handlers.pxi":337 * cdef fuse_ino_t newparent = c.ino * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * await operations.rename(c.parent, name, newparent, newname, flags, ctx) */ __pyx_t_2 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":338 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.rename(c.parent, name, newparent, newname, flags, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { /* "src/handlers.pxi":339 * ctx = get_request_context(c.req) * try: * await operations.rename(c.parent, name, newparent, newname, flags, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_rename); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 339, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 339, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_newparent); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 339, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyInt_From_unsigned_int(__pyx_cur_scope->__pyx_v_flags); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 339, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[7] = {__pyx_t_10, __pyx_t_7, __pyx_cur_scope->__pyx_v_name, __pyx_t_8, __pyx_cur_scope->__pyx_v_newname, __pyx_t_9, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 6+__pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 339, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[7] = {__pyx_t_10, __pyx_t_7, __pyx_cur_scope->__pyx_v_name, __pyx_t_8, __pyx_cur_scope->__pyx_v_newname, __pyx_t_9, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_11, 6+__pyx_t_11); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 339, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else #endif { __pyx_t_12 = PyTuple_New(6+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 339, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL; } __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_t_7); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_11, __pyx_t_8); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_newname); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_newname); PyTuple_SET_ITEM(__pyx_t_12, 3+__pyx_t_11, __pyx_cur_scope->__pyx_v_newname); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_12, 4+__pyx_t_11, __pyx_t_9); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_12, 5+__pyx_t_11, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_12, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 339, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_0 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_1 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_t_2 = __pyx_t_5; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_3 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_4); __pyx_t_5 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 339, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 339, __pyx_L4_error) } } /* "src/handlers.pxi":338 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.rename(c.parent, name, newparent, newname, flags, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":343 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":340 * try: * await operations.rename(c.parent, name, newparent, newname, flags, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_11) { __Pyx_AddTraceback("pyfuse3.fuse_rename_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_12) < 0) __PYX_ERR(1, 340, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_cur_scope->__pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/handlers.pxi":341 * await operations.rename(c.parent, name, newparent, newname, flags, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 341, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 341, __pyx_L16_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_11); } /* "src/handlers.pxi":340 * try: * await operations.rename(c.parent, name, newparent, newname, flags, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_20); __pyx_t_11 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_14 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ExceptionReset(__pyx_t_18, __pyx_t_19, __pyx_t_20); } __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_17); __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_14; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":338 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.rename(c.parent, name, newparent, newname, flags, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); __pyx_L9_try_end:; } /* "src/handlers.pxi":345 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_21 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_21) { /* "src/handlers.pxi":346 * * if ret != 0: * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_log); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_9 = NULL; __pyx_t_13 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_13 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_kp_u_fuse_rename_fuse_reply__failed_w, __pyx_t_6}; __pyx_t_12 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_kp_u_fuse_rename_fuse_reply__failed_w, __pyx_t_6}; __pyx_t_12 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_8 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_rename_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_rename_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_13, __pyx_kp_u_fuse_rename_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_13, __pyx_t_6); __pyx_t_6 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/handlers.pxi":345 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_rename(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":332 * * * async def fuse_rename_async (_Container c, name, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef unsigned flags = c.flags */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("fuse_rename_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":349 * * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, # <<<<<<<<<<<<<< * const_char *newname): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_link(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, fuse_ino_t __pyx_v_newparent, const char *__pyx_v_newname) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_link", 0); /* "src/handlers.pxi":351 * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, * const_char *newname): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 351, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":352 * const_char *newname): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * c.parent = newparent */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":353 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * c.parent = newparent * save_retval(fuse_link_async(c, PyBytes_FromString(newname))) */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":354 * c.req = req * c.ino = ino * c.parent = newparent # <<<<<<<<<<<<<< * save_retval(fuse_link_async(c, PyBytes_FromString(newname))) * */ __pyx_v_c->parent = __pyx_v_newparent; /* "src/handlers.pxi":355 * c.ino = ino * c.parent = newparent * save_retval(fuse_link_async(c, PyBytes_FromString(newname))) # <<<<<<<<<<<<<< * * async def fuse_link_async (_Container c, newname): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_link_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_newname); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 355, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 355, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 355, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":349 * * * cdef void fuse_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, # <<<<<<<<<<<<<< * const_char *newname): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_link", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_32generator10(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":357 * save_retval(fuse_link_async(c, PyBytes_FromString(newname))) * * async def fuse_link_async (_Container c, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_31fuse_link_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_30fuse_link_async[] = "fuse_link_async(_Container c, newname)"; static PyMethodDef __pyx_mdef_7pyfuse3_31fuse_link_async = {"fuse_link_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_31fuse_link_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_30fuse_link_async}; static PyObject *__pyx_pw_7pyfuse3_31fuse_link_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_newname = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_link_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_newname,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_newname)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_link_async", 1, 2, 2, 1); __PYX_ERR(1, 357, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_link_async") < 0)) __PYX_ERR(1, 357, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_newname = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_link_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 357, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_link_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 357, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_30fuse_link_async(__pyx_self, __pyx_v_c, __pyx_v_newname); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_30fuse_link_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_newname) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_link_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_10_fuse_link_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_10_fuse_link_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 357, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_newname = __pyx_v_newname; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_newname); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_newname); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_32generator10, __pyx_codeobj__14, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_link_async, __pyx_n_s_fuse_link_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 357, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_link_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_32generator10(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_link_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 357, __pyx_L1_error) /* "src/handlers.pxi":361 * cdef EntryAttributes entry * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * entry = await operations.link( */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":362 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.link( * c.ino, c.parent, newname, ctx) */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":363 * ctx = get_request_context(c.req) * try: * entry = await operations.link( # <<<<<<<<<<<<<< * c.ino, c.parent, newname, ctx) * except FUSEError as e: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_link); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 363, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); /* "src/handlers.pxi":364 * try: * entry = await operations.link( * c.ino, c.parent, newname, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 364, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 364, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_newname, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 363, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[5] = {__pyx_t_8, __pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_newname, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 4+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 363, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(4+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 363, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_newname); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_newname); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_cur_scope->__pyx_v_newname); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_10, 3+__pyx_t_9, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 363, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 363, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 363, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } /* "src/handlers.pxi":363 * ctx = get_request_context(c.req) * try: * entry = await operations.link( # <<<<<<<<<<<<<< * c.ino, c.parent, newname, ctx) * except FUSEError as e: */ if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_EntryAttributes)))) __PYX_ERR(1, 363, __pyx_L4_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_entry = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":362 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.link( * c.ino, c.parent, newname, ctx) */ } /* "src/handlers.pxi":368 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_entry(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_entry->fuse_param)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/handlers.pxi":365 * entry = await operations.link( * c.ino, c.parent, newname, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_9) { __Pyx_AddTraceback("pyfuse3.fuse_link_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_10) < 0) __PYX_ERR(1, 365, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":366 * c.ino, c.parent, newname, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_entry(c.req, &entry.fuse_param) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 366, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 366, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_9); } /* "src/handlers.pxi":365 * entry = await operations.link( * c.ino, c.parent, newname, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_9 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":362 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * entry = await operations.link( * c.ino, c.parent, newname, ctx) */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":370 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/handlers.pxi":371 * * if ret != 0: * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_link_fuse_reply__failed_wit, __pyx_t_1}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 371, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_link_fuse_reply__failed_wit, __pyx_t_1}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 371, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_11, __pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_11, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 371, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/handlers.pxi":370 * ret = fuse_reply_entry(c.req, &entry.fuse_param) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":357 * save_retval(fuse_link_async(c, PyBytes_FromString(newname))) * * async def fuse_link_async (_Container c, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("fuse_link_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":374 * * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_open(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_open", 0); /* "src/handlers.pxi":375 * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 375, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":376 * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * c.fi = fi[0] */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":377 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * c.fi = fi[0] * save_retval(fuse_open_async(c)) */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":378 * c.req = req * c.ino = ino * c.fi = fi[0] # <<<<<<<<<<<<<< * save_retval(fuse_open_async(c)) * */ __pyx_v_c->fi = (__pyx_v_fi[0]); /* "src/handlers.pxi":379 * c.ino = ino * c.fi = fi[0] * save_retval(fuse_open_async(c)) # <<<<<<<<<<<<<< * * async def fuse_open_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_open_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 379, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":374 * * * cdef void fuse_open (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyfuse3.fuse_open", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_35generator11(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":381 * save_retval(fuse_open_async(c)) * * async def fuse_open_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef FileInfo fi */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_34fuse_open_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_33fuse_open_async[] = "fuse_open_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_34fuse_open_async = {"fuse_open_async", (PyCFunction)__pyx_pw_7pyfuse3_34fuse_open_async, METH_O, __pyx_doc_7pyfuse3_33fuse_open_async}; static PyObject *__pyx_pw_7pyfuse3_34fuse_open_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_open_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 381, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_33fuse_open_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_33fuse_open_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_open_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_11_fuse_open_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_11_fuse_open_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 381, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_35generator11, __pyx_codeobj__15, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_open_async, __pyx_n_s_fuse_open_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 381, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_open_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_35generator11(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_open_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 381, __pyx_L1_error) /* "src/handlers.pxi":385 * cdef FileInfo fi * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * * try: */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 385, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":387 * ctx = get_request_context(c.req) * * try: # <<<<<<<<<<<<<< * fi = await operations.open(c.ino, c.fi.flags, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":388 * * try: * fi = await operations.open(c.ino, c.fi.flags, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_open); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 388, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 388, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_c->fi.flags); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 388, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 388, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 388, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 388, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 388, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 388, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 388, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_FileInfo)))) __PYX_ERR(1, 388, __pyx_L4_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_fi = ((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":387 * ctx = get_request_context(c.req) * * try: # <<<<<<<<<<<<<< * fi = await operations.open(c.ino, c.fi.flags, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":392 * ret = fuse_reply_err(c.req, e.errno) * else: * fi._copy_to_fuse(&c.fi) # <<<<<<<<<<<<<< * ret = fuse_reply_open(c.req, &c.fi) * */ /*else:*/ { __pyx_t_5 = ((struct __pyx_vtabstruct_7pyfuse3_FileInfo *)__pyx_cur_scope->__pyx_v_fi->__pyx_vtab)->_copy_to_fuse(__pyx_cur_scope->__pyx_v_fi, (&__pyx_cur_scope->__pyx_v_c->fi)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 392, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":393 * else: * fi._copy_to_fuse(&c.fi) * ret = fuse_reply_open(c.req, &c.fi) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_open(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_c->fi)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/handlers.pxi":389 * try: * fi = await operations.open(c.ino, c.fi.flags, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_9) { __Pyx_AddTraceback("pyfuse3.fuse_open_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_10) < 0) __PYX_ERR(1, 389, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":390 * fi = await operations.open(c.ino, c.fi.flags, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * fi._copy_to_fuse(&c.fi) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 390, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 390, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_9); } /* "src/handlers.pxi":389 * try: * fi = await operations.open(c.ino, c.fi.flags, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_9 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":387 * ctx = get_request_context(c.req) * * try: # <<<<<<<<<<<<<< * fi = await operations.open(c.ino, c.fi.flags, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":395 * ret = fuse_reply_open(c.req, &c.fi) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/handlers.pxi":396 * * if ret != 0: * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_7 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_link_fuse_reply__failed_wit, __pyx_t_1}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 396, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_link_fuse_reply__failed_wit, __pyx_t_1}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 396, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_link_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_11, __pyx_kp_u_fuse_link_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_11, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 396, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/handlers.pxi":395 * ret = fuse_reply_open(c.req, &c.fi) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_link(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":381 * save_retval(fuse_open_async(c)) * * async def fuse_open_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef FileInfo fi */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("fuse_open_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":399 * * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_read(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_read", 0); /* "src/handlers.pxi":401 * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, * fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.size = size */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 401, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":402 * fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.size = size * c.off = off */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":403 * cdef _Container c = _Container() * c.req = req * c.size = size # <<<<<<<<<<<<<< * c.off = off * c.fh = fi.fh */ __pyx_v_c->size = __pyx_v_size; /* "src/handlers.pxi":404 * c.req = req * c.size = size * c.off = off # <<<<<<<<<<<<<< * c.fh = fi.fh * save_retval(fuse_read_async(c)) */ __pyx_v_c->off = __pyx_v_off; /* "src/handlers.pxi":405 * c.size = size * c.off = off * c.fh = fi.fh # <<<<<<<<<<<<<< * save_retval(fuse_read_async(c)) * */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":406 * c.off = off * c.fh = fi.fh * save_retval(fuse_read_async(c)) # <<<<<<<<<<<<<< * * async def fuse_read_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_read_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 406, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":399 * * * cdef void fuse_read (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pyfuse3.fuse_read", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_38generator12(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":408 * save_retval(fuse_read_async(c)) * * async def fuse_read_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef Py_buffer pybuf */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_37fuse_read_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_36fuse_read_async[] = "fuse_read_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_37fuse_read_async = {"fuse_read_async", (PyCFunction)__pyx_pw_7pyfuse3_37fuse_read_async, METH_O, __pyx_doc_7pyfuse3_36fuse_read_async}; static PyObject *__pyx_pw_7pyfuse3_37fuse_read_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_read_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 408, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_36fuse_read_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_36fuse_read_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_read_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_12_fuse_read_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_12_fuse_read_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 408, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_38generator12, __pyx_codeobj__16, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_read_async, __pyx_n_s_fuse_read_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 408, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_read_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_38generator12(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_read_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 408, __pyx_L1_error) /* "src/handlers.pxi":412 * cdef Py_buffer pybuf * * try: # <<<<<<<<<<<<<< * buf = await operations.read(c.fh, c.off, c.size) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":413 * * try: * buf = await operations.read(c.fh, c.off, c.size) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_read); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_off_t(__pyx_cur_scope->__pyx_v_c->off); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_FromSize_t(__pyx_cur_scope->__pyx_v_c->size); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_t_6, __pyx_t_7, __pyx_t_8}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_t_6, __pyx_t_7, __pyx_t_8}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 3+__pyx_t_10); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif { __pyx_t_11 = PyTuple_New(3+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_8); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_11, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 413, __pyx_L4_error) __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4); } else { __pyx_t_4 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(1, 413, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); } __Pyx_GIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_v_buf = __pyx_t_4; __pyx_t_4 = 0; /* "src/handlers.pxi":412 * cdef Py_buffer pybuf * * try: # <<<<<<<<<<<<<< * buf = await operations.read(c.fh, c.off, c.size) * except FUSEError as e: */ } /* "src/handlers.pxi":417 * ret = fuse_reply_err(c.req, e.errno) * else: * PyObject_GetBuffer(buf, &pybuf, PyBUF_CONTIG_RO) # <<<<<<<<<<<<<< * ret = fuse_reply_buf(c.req, pybuf.buf, pybuf.len) * PyBuffer_Release(&pybuf) */ /*else:*/ { __pyx_t_10 = PyObject_GetBuffer(__pyx_cur_scope->__pyx_v_buf, (&__pyx_cur_scope->__pyx_v_pybuf), PyBUF_CONTIG_RO); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 417, __pyx_L6_except_error) /* "src/handlers.pxi":418 * else: * PyObject_GetBuffer(buf, &pybuf, PyBUF_CONTIG_RO) * ret = fuse_reply_buf(c.req, pybuf.buf, pybuf.len) # <<<<<<<<<<<<<< * PyBuffer_Release(&pybuf) * */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_buf(__pyx_cur_scope->__pyx_v_c->req, ((const char *)__pyx_cur_scope->__pyx_v_pybuf.buf), ((size_t)__pyx_cur_scope->__pyx_v_pybuf.len)); /* "src/handlers.pxi":419 * PyObject_GetBuffer(buf, &pybuf, PyBUF_CONTIG_RO) * ret = fuse_reply_buf(c.req, pybuf.buf, pybuf.len) * PyBuffer_Release(&pybuf) # <<<<<<<<<<<<<< * * if ret != 0: */ PyBuffer_Release((&__pyx_cur_scope->__pyx_v_pybuf)); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":414 * try: * buf = await operations.read(c.fh, c.off, c.size) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_10) { __Pyx_AddTraceback("pyfuse3.fuse_read_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_11) < 0) __PYX_ERR(1, 414, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":415 * buf = await operations.read(c.fh, c.off, c.size) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * PyObject_GetBuffer(buf, &pybuf, PyBUF_CONTIG_RO) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 415, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 415, __pyx_L16_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_10); } /* "src/handlers.pxi":414 * try: * buf = await operations.read(c.fh, c.off, c.size) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_10 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":412 * cdef Py_buffer pybuf * * try: # <<<<<<<<<<<<<< * buf = await operations.read(c.fh, c.off, c.size) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L9_try_end:; } /* "src/handlers.pxi":421 * PyBuffer_Release(&pybuf) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_20 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_20) { /* "src/handlers.pxi":422 * * if ret != 0: * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_read_fuse_reply__failed_wit, __pyx_t_5}; __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_read_fuse_reply__failed_wit, __pyx_t_5}; __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_read_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_kp_u_fuse_read_fuse_reply__failed_wit); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_12, __pyx_kp_u_fuse_read_fuse_reply__failed_wit); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_12, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 422, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; /* "src/handlers.pxi":421 * PyBuffer_Release(&pybuf) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_read(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":408 * save_retval(fuse_read_async(c)) * * async def fuse_read_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef Py_buffer pybuf */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("fuse_read_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":425 * * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, # <<<<<<<<<<<<<< * size_t size, off_t off, fuse_file_info *fi): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_write(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, const char *__pyx_v_buf, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_pbuf = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_write", 0); /* "src/handlers.pxi":427 * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, * size_t size, off_t off, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.size = size */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 427, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":428 * size_t size, off_t off, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.size = size * c.off = off */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":429 * cdef _Container c = _Container() * c.req = req * c.size = size # <<<<<<<<<<<<<< * c.off = off * c.fh = fi.fh */ __pyx_v_c->size = __pyx_v_size; /* "src/handlers.pxi":430 * c.req = req * c.size = size * c.off = off # <<<<<<<<<<<<<< * c.fh = fi.fh * */ __pyx_v_c->off = __pyx_v_off; /* "src/handlers.pxi":431 * c.size = size * c.off = off * c.fh = fi.fh # <<<<<<<<<<<<<< * * if size > PY_SSIZE_T_MAX: */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":433 * c.fh = fi.fh * * if size > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< * raise OverflowError('Value too long to convert to Python') * pbuf = PyBytes_FromStringAndSize(buf, size) */ __pyx_t_3 = ((__pyx_v_size > PY_SSIZE_T_MAX) != 0); if (unlikely(__pyx_t_3)) { /* "src/handlers.pxi":434 * * if size > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') # <<<<<<<<<<<<<< * pbuf = PyBytes_FromStringAndSize(buf, size) * save_retval(fuse_write_async(c, pbuf)) */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_OverflowError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 434, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 434, __pyx_L1_error) /* "src/handlers.pxi":433 * c.fh = fi.fh * * if size > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< * raise OverflowError('Value too long to convert to Python') * pbuf = PyBytes_FromStringAndSize(buf, size) */ } /* "src/handlers.pxi":435 * if size > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') * pbuf = PyBytes_FromStringAndSize(buf, size) # <<<<<<<<<<<<<< * save_retval(fuse_write_async(c, pbuf)) * */ __pyx_t_1 = PyBytes_FromStringAndSize(__pyx_v_buf, ((Py_ssize_t)__pyx_v_size)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 435, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_pbuf = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":436 * raise OverflowError('Value too long to convert to Python') * pbuf = PyBytes_FromStringAndSize(buf, size) * save_retval(fuse_write_async(c, pbuf)) # <<<<<<<<<<<<<< * * async def fuse_write_async (_Container c, pbuf): */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_fuse_write_async); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; __pyx_t_6 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_6 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, ((PyObject *)__pyx_v_c), __pyx_v_pbuf}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 436, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_5, ((PyObject *)__pyx_v_c), __pyx_v_pbuf}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 436, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, ((PyObject *)__pyx_v_c)); __Pyx_INCREF(__pyx_v_pbuf); __Pyx_GIVEREF(__pyx_v_pbuf); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_pbuf); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 436, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":425 * * * cdef void fuse_write (fuse_req_t req, fuse_ino_t ino, const_char *buf, # <<<<<<<<<<<<<< * size_t size, off_t off, fuse_file_info *fi): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __Pyx_WriteUnraisable("pyfuse3.fuse_write", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_XDECREF(__pyx_v_pbuf); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_41generator13(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":438 * save_retval(fuse_write_async(c, pbuf)) * * async def fuse_write_async (_Container c, pbuf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_40fuse_write_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_39fuse_write_async[] = "fuse_write_async(_Container c, pbuf)"; static PyMethodDef __pyx_mdef_7pyfuse3_40fuse_write_async = {"fuse_write_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_40fuse_write_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_39fuse_write_async}; static PyObject *__pyx_pw_7pyfuse3_40fuse_write_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_pbuf = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_write_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_pbuf,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pbuf)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_write_async", 1, 2, 2, 1); __PYX_ERR(1, 438, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_write_async") < 0)) __PYX_ERR(1, 438, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_pbuf = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_write_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 438, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_write_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 438, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_39fuse_write_async(__pyx_self, __pyx_v_c, __pyx_v_pbuf); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_39fuse_write_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_pbuf) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_write_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_13_fuse_write_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_13_fuse_write_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 438, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_pbuf = __pyx_v_pbuf; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_pbuf); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pbuf); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_41generator13, __pyx_codeobj__18, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_write_async, __pyx_n_s_fuse_write_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 438, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_write_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_41generator13(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; size_t __pyx_t_11; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_write_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 438, __pyx_L1_error) /* "src/handlers.pxi":442 * cdef size_t len_ * * try: # <<<<<<<<<<<<<< * len_ = await operations.write(c.fh, c.off, pbuf) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":443 * * try: * len_ = await operations.write(c.fh, c.off, pbuf) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_write); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_off_t(__pyx_cur_scope->__pyx_v_c->off); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_pbuf}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_pbuf}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_pbuf); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_pbuf); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_cur_scope->__pyx_v_pbuf); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 443, __pyx_L4_error) __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4); } else { __pyx_t_4 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); } __pyx_t_11 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_11 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 443, __pyx_L4_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_cur_scope->__pyx_v_len_ = __pyx_t_11; /* "src/handlers.pxi":442 * cdef size_t len_ * * try: # <<<<<<<<<<<<<< * len_ = await operations.write(c.fh, c.off, pbuf) * except FUSEError as e: */ } /* "src/handlers.pxi":447 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_write(c.req, len_) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_write(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_len_); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/handlers.pxi":444 * try: * len_ = await operations.write(c.fh, c.off, pbuf) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_9) { __Pyx_AddTraceback("pyfuse3.fuse_write_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_10) < 0) __PYX_ERR(1, 444, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":445 * len_ = await operations.write(c.fh, c.off, pbuf) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_write(c.req, len_) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 445, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 445, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_9); } /* "src/handlers.pxi":444 * try: * len_ = await operations.write(c.fh, c.off, pbuf) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_9 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":442 * cdef size_t len_ * * try: # <<<<<<<<<<<<<< * len_ = await operations.write(c.fh, c.off, pbuf) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L9_try_end:; } /* "src/handlers.pxi":449 * ret = fuse_reply_write(c.req, len_) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_20 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_20) { /* "src/handlers.pxi":450 * * if ret != 0: * log.error('fuse_write(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_12 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_write_fuse_reply__failed_wi, __pyx_t_5}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 450, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_write_fuse_reply__failed_wi, __pyx_t_5}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 450, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_12, __pyx_kp_u_fuse_write_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_12, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 450, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/handlers.pxi":449 * ret = fuse_reply_write(c.req, len_) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":438 * save_retval(fuse_write_async(c, pbuf)) * * async def fuse_write_async (_Container c, pbuf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("fuse_write_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":453 * * * cdef void fuse_write_buf(fuse_req_t req, fuse_ino_t ino, fuse_bufvec *bufv, # <<<<<<<<<<<<<< * off_t off, fuse_file_info *fi): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_write_buf(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_bufvec *__pyx_v_bufv, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_buf = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_write_buf", 0); /* "src/handlers.pxi":455 * cdef void fuse_write_buf(fuse_req_t req, fuse_ino_t ino, fuse_bufvec *bufv, * off_t off, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.off = off */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 455, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":456 * off_t off, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.off = off * c.fh = fi.fh */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":457 * cdef _Container c = _Container() * c.req = req * c.off = off # <<<<<<<<<<<<<< * c.fh = fi.fh * buf = PyBytes_from_bufvec(bufv) */ __pyx_v_c->off = __pyx_v_off; /* "src/handlers.pxi":458 * c.req = req * c.off = off * c.fh = fi.fh # <<<<<<<<<<<<<< * buf = PyBytes_from_bufvec(bufv) * save_retval(fuse_write_buf_async(c, buf)) */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":459 * c.off = off * c.fh = fi.fh * buf = PyBytes_from_bufvec(bufv) # <<<<<<<<<<<<<< * save_retval(fuse_write_buf_async(c, buf)) * */ __pyx_t_1 = __pyx_f_7pyfuse3_PyBytes_from_bufvec(__pyx_v_bufv); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 459, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_buf = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":460 * c.fh = fi.fh * buf = PyBytes_from_bufvec(bufv) * save_retval(fuse_write_buf_async(c, buf)) # <<<<<<<<<<<<<< * * async def fuse_write_buf_async (_Container c, buf): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_write_buf_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 460, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_v_buf}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 460, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_v_buf}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 460, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 460, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_INCREF(__pyx_v_buf); __Pyx_GIVEREF(__pyx_v_buf); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_buf); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 460, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":453 * * * cdef void fuse_write_buf(fuse_req_t req, fuse_ino_t ino, fuse_bufvec *bufv, # <<<<<<<<<<<<<< * off_t off, fuse_file_info *fi): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_write_buf", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_XDECREF(__pyx_v_buf); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_44generator14(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":462 * save_retval(fuse_write_buf_async(c, buf)) * * async def fuse_write_buf_async (_Container c, buf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_43fuse_write_buf_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_42fuse_write_buf_async[] = "fuse_write_buf_async(_Container c, buf)"; static PyMethodDef __pyx_mdef_7pyfuse3_43fuse_write_buf_async = {"fuse_write_buf_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_43fuse_write_buf_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_42fuse_write_buf_async}; static PyObject *__pyx_pw_7pyfuse3_43fuse_write_buf_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_buf = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_write_buf_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_buf,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buf)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_write_buf_async", 1, 2, 2, 1); __PYX_ERR(1, 462, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_write_buf_async") < 0)) __PYX_ERR(1, 462, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_buf = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_write_buf_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 462, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_write_buf_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 462, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_42fuse_write_buf_async(__pyx_self, __pyx_v_c, __pyx_v_buf); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_42fuse_write_buf_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_buf) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_write_buf_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 462, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_buf = __pyx_v_buf; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_buf); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_buf); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_44generator14, __pyx_codeobj__19, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_write_buf_async, __pyx_n_s_fuse_write_buf_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 462, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_write_buf_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_44generator14(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; size_t __pyx_t_11; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_write_buf_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 462, __pyx_L1_error) /* "src/handlers.pxi":466 * cdef size_t len_ * * try: # <<<<<<<<<<<<<< * len_ = await operations.write(c.fh, c.off, buf) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":467 * * try: * len_ = await operations.write(c.fh, c.off, buf) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_write); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_off_t(__pyx_cur_scope->__pyx_v_c->off); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_buf}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_8, __pyx_t_6, __pyx_t_7, __pyx_cur_scope->__pyx_v_buf}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 3+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(3+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_buf); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_buf); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_9, __pyx_cur_scope->__pyx_v_buf); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 467, __pyx_L4_error) __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4); } else { __pyx_t_4 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); } __pyx_t_11 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_11 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 467, __pyx_L4_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_cur_scope->__pyx_v_len_ = __pyx_t_11; /* "src/handlers.pxi":466 * cdef size_t len_ * * try: # <<<<<<<<<<<<<< * len_ = await operations.write(c.fh, c.off, buf) * except FUSEError as e: */ } /* "src/handlers.pxi":471 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_write(c.req, len_) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_write(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_len_); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/handlers.pxi":468 * try: * len_ = await operations.write(c.fh, c.off, buf) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_9) { __Pyx_AddTraceback("pyfuse3.fuse_write_buf_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_10) < 0) __PYX_ERR(1, 468, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":469 * len_ = await operations.write(c.fh, c.off, buf) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_write(c.req, len_) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 469, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 469, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_9); } /* "src/handlers.pxi":468 * try: * len_ = await operations.write(c.fh, c.off, buf) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_9 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":466 * cdef size_t len_ * * try: # <<<<<<<<<<<<<< * len_ = await operations.write(c.fh, c.off, buf) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L9_try_end:; } /* "src/handlers.pxi":473 * ret = fuse_reply_write(c.req, len_) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write_buf(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_20 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_20) { /* "src/handlers.pxi":474 * * if ret != 0: * log.error('fuse_write_buf(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_12 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_12 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_write_buf_fuse_reply__faile, __pyx_t_5}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_write_buf_fuse_reply__faile, __pyx_t_5}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_write_buf_fuse_reply__faile); __Pyx_GIVEREF(__pyx_kp_u_fuse_write_buf_fuse_reply__faile); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_12, __pyx_kp_u_fuse_write_buf_fuse_reply__faile); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_12, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 474, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/handlers.pxi":473 * ret = fuse_reply_write(c.req, len_) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_write_buf(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":462 * save_retval(fuse_write_buf_async(c, buf)) * * async def fuse_write_buf_async (_Container c, buf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("fuse_write_buf_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":477 * * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_flush(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_flush", 0); /* "src/handlers.pxi":478 * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.fh = fi.fh */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 478, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":479 * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.fh = fi.fh * save_retval(fuse_flush_async(c)) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":480 * cdef _Container c = _Container() * c.req = req * c.fh = fi.fh # <<<<<<<<<<<<<< * save_retval(fuse_flush_async(c)) * */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":481 * c.req = req * c.fh = fi.fh * save_retval(fuse_flush_async(c)) # <<<<<<<<<<<<<< * * async def fuse_flush_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_flush_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 481, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":477 * * * cdef void fuse_flush (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pyfuse3.fuse_flush", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_47generator15(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":483 * save_retval(fuse_flush_async(c)) * * async def fuse_flush_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_46fuse_flush_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_45fuse_flush_async[] = "fuse_flush_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_46fuse_flush_async = {"fuse_flush_async", (PyCFunction)__pyx_pw_7pyfuse3_46fuse_flush_async, METH_O, __pyx_doc_7pyfuse3_45fuse_flush_async}; static PyObject *__pyx_pw_7pyfuse3_46fuse_flush_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_flush_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 483, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_45fuse_flush_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_45fuse_flush_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_flush_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_15_fuse_flush_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_15_fuse_flush_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 483, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_47generator15, __pyx_codeobj__20, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_flush_async, __pyx_n_s_fuse_flush_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 483, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_flush_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_47generator15(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_t_9; char const *__pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_flush_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 483, __pyx_L1_error) /* "src/handlers.pxi":486 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.flush(c.fh) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":487 * * try: * await operations.flush(c.fh) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_flush); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 487, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 487, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 487, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 487, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 487, __pyx_L4_error) } } /* "src/handlers.pxi":486 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.flush(c.fh) * except FUSEError as e: */ } /* "src/handlers.pxi":491 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/handlers.pxi":488 * try: * await operations.flush(c.fh) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_flush_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(1, 488, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":489 * await operations.flush(c.fh) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 489, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 489, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":488 * try: * await operations.flush(c.fh) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __pyx_t_8 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); } __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":486 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.flush(c.fh) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L9_try_end:; } /* "src/handlers.pxi":493 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/handlers.pxi":494 * * if ret != 0: * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_flush_fuse_reply__failed_wi, __pyx_t_5}; __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_flush_fuse_reply__failed_wi, __pyx_t_5}; __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_18 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_flush_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_flush_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_9, __pyx_kp_u_fuse_flush_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_9, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_18, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 494, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/handlers.pxi":493 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_flush(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":483 * save_retval(fuse_flush_async(c)) * * async def fuse_flush_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_18); __Pyx_AddTraceback("fuse_flush_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":497 * * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_release(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_release", 0); /* "src/handlers.pxi":498 * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.fh = fi.fh */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 498, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":499 * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.fh = fi.fh * save_retval(fuse_release_async(c)) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":500 * cdef _Container c = _Container() * c.req = req * c.fh = fi.fh # <<<<<<<<<<<<<< * save_retval(fuse_release_async(c)) * */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":501 * c.req = req * c.fh = fi.fh * save_retval(fuse_release_async(c)) # <<<<<<<<<<<<<< * * async def fuse_release_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_release_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 501, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 501, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":497 * * * cdef void fuse_release (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pyfuse3.fuse_release", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_50generator16(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":503 * save_retval(fuse_release_async(c)) * * async def fuse_release_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_49fuse_release_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_48fuse_release_async[] = "fuse_release_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_49fuse_release_async = {"fuse_release_async", (PyCFunction)__pyx_pw_7pyfuse3_49fuse_release_async, METH_O, __pyx_doc_7pyfuse3_48fuse_release_async}; static PyObject *__pyx_pw_7pyfuse3_49fuse_release_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_release_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 503, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_48fuse_release_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_48fuse_release_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_release_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_16_fuse_release_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_16_fuse_release_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 503, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_50generator16, __pyx_codeobj__21, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_release_async, __pyx_n_s_fuse_release_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_release_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_50generator16(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_t_9; char const *__pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_release_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 503, __pyx_L1_error) /* "src/handlers.pxi":506 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.release(c.fh) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":507 * * try: * await operations.release(c.fh) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_release); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 507, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 507, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 507, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 507, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 507, __pyx_L4_error) } } /* "src/handlers.pxi":506 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.release(c.fh) * except FUSEError as e: */ } /* "src/handlers.pxi":511 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/handlers.pxi":508 * try: * await operations.release(c.fh) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_release_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(1, 508, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":509 * await operations.release(c.fh) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 509, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 509, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":508 * try: * await operations.release(c.fh) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __pyx_t_8 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); } __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":506 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.release(c.fh) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L9_try_end:; } /* "src/handlers.pxi":513 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/handlers.pxi":514 * * if ret != 0: * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_release_fuse_reply__failed, __pyx_t_5}; __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_release_fuse_reply__failed, __pyx_t_5}; __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_18 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_release_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_release_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_9, __pyx_kp_u_fuse_release_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_9, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_18, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/handlers.pxi":513 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_release(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":503 * save_retval(fuse_release_async(c)) * * async def fuse_release_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_18); __Pyx_AddTraceback("fuse_release_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":517 * * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_fsync(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, int __pyx_v_datasync, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_fsync", 0); /* "src/handlers.pxi":519 * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, * fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.flags = datasync */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 519, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":520 * fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.flags = datasync * c.fh = fi.fh */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":521 * cdef _Container c = _Container() * c.req = req * c.flags = datasync # <<<<<<<<<<<<<< * c.fh = fi.fh * save_retval(fuse_fsync_async(c)) */ __pyx_v_c->flags = __pyx_v_datasync; /* "src/handlers.pxi":522 * c.req = req * c.flags = datasync * c.fh = fi.fh # <<<<<<<<<<<<<< * save_retval(fuse_fsync_async(c)) * */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":523 * c.flags = datasync * c.fh = fi.fh * save_retval(fuse_fsync_async(c)) # <<<<<<<<<<<<<< * * async def fuse_fsync_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_fsync_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 523, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":517 * * * cdef void fuse_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pyfuse3.fuse_fsync", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_53generator17(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":525 * save_retval(fuse_fsync_async(c)) * * async def fuse_fsync_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_52fuse_fsync_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_51fuse_fsync_async[] = "fuse_fsync_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_52fuse_fsync_async = {"fuse_fsync_async", (PyCFunction)__pyx_pw_7pyfuse3_52fuse_fsync_async, METH_O, __pyx_doc_7pyfuse3_51fuse_fsync_async}; static PyObject *__pyx_pw_7pyfuse3_52fuse_fsync_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_fsync_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 525, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_51fuse_fsync_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_51fuse_fsync_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_fsync_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 525, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_53generator17, __pyx_codeobj__22, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_fsync_async, __pyx_n_s_fuse_fsync_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 525, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_fsync_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_53generator17(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_fsync_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 525, __pyx_L1_error) /* "src/handlers.pxi":528 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.fsync(c.fh, c.flags != 0) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":529 * * try: * await operations.fsync(c.fh, c.flags != 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_fsync); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 529, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 529, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyBool_FromLong((__pyx_cur_scope->__pyx_v_c->flags != 0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 529, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 529, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 529, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 529, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 529, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 529, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 529, __pyx_L4_error) } } /* "src/handlers.pxi":528 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.fsync(c.fh, c.flags != 0) * except FUSEError as e: */ } /* "src/handlers.pxi":533 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/handlers.pxi":530 * try: * await operations.fsync(c.fh, c.flags != 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_9) { __Pyx_AddTraceback("pyfuse3.fuse_fsync_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_10) < 0) __PYX_ERR(1, 530, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":531 * await operations.fsync(c.fh, c.flags != 0) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 531, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 531, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_9); } /* "src/handlers.pxi":530 * try: * await operations.fsync(c.fh, c.flags != 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_9 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":528 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.fsync(c.fh, c.flags != 0) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L9_try_end:; } /* "src/handlers.pxi":535 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/handlers.pxi":536 * * if ret != 0: * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_fsync_fuse_reply__failed_wi, __pyx_t_5}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 536, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_fsync_fuse_reply__failed_wi, __pyx_t_5}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 536, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_11, __pyx_kp_u_fuse_fsync_fuse_reply__failed_wi); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_11, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 536, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/handlers.pxi":535 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsync(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":525 * save_retval(fuse_fsync_async(c)) * * async def fuse_fsync_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("fuse_fsync_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":539 * * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_opendir(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_opendir", 0); /* "src/handlers.pxi":540 * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 540, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":541 * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * c.fi = fi[0] */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":542 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * c.fi = fi[0] * save_retval(fuse_opendir_async(c)) */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":543 * c.req = req * c.ino = ino * c.fi = fi[0] # <<<<<<<<<<<<<< * save_retval(fuse_opendir_async(c)) * */ __pyx_v_c->fi = (__pyx_v_fi[0]); /* "src/handlers.pxi":544 * c.ino = ino * c.fi = fi[0] * save_retval(fuse_opendir_async(c)) # <<<<<<<<<<<<<< * * async def fuse_opendir_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_opendir_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 544, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 544, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":539 * * * cdef void fuse_opendir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyfuse3.fuse_opendir", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_56generator18(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":546 * save_retval(fuse_opendir_async(c)) * * async def fuse_opendir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_55fuse_opendir_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_54fuse_opendir_async[] = "fuse_opendir_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_55fuse_opendir_async = {"fuse_opendir_async", (PyCFunction)__pyx_pw_7pyfuse3_55fuse_opendir_async, METH_O, __pyx_doc_7pyfuse3_54fuse_opendir_async}; static PyObject *__pyx_pw_7pyfuse3_55fuse_opendir_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_opendir_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 546, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_54fuse_opendir_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_54fuse_opendir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_opendir_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 546, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_56generator18, __pyx_codeobj__23, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_opendir_async, __pyx_n_s_fuse_opendir_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 546, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_opendir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_56generator18(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; uint64_t __pyx_t_10; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_opendir_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 546, __pyx_L1_error) /* "src/handlers.pxi":549 * cdef int ret * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * c.fi.fh = await operations.opendir(c.ino, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 549, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":550 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * c.fi.fh = await operations.opendir(c.ino, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":551 * ctx = get_request_context(c.req) * try: * c.fi.fh = await operations.opendir(c.ino, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_opendir); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 551, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 551, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 551, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 551, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 551, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 551, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 551, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 551, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } __pyx_t_10 = __Pyx_PyInt_As_uint64_t(__pyx_t_1); if (unlikely((__pyx_t_10 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(1, 551, __pyx_L4_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_cur_scope->__pyx_v_c->fi.fh = __pyx_t_10; /* "src/handlers.pxi":550 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * c.fi.fh = await operations.opendir(c.ino, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":555 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_open(c.req, &c.fi) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_open(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_c->fi)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":552 * try: * c.fi.fh = await operations.opendir(c.ino, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_opendir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(1, 552, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":553 * c.fi.fh = await operations.opendir(c.ino, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_open(c.req, &c.fi) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 553, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 553, __pyx_L16_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":552 * try: * c.fi.fh = await operations.opendir(c.ino, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_8 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":550 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * c.fi.fh = await operations.opendir(c.ino, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":557 * ret = fuse_reply_open(c.req, &c.fi) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/handlers.pxi":558 * * if ret != 0: * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_opendir_fuse_reply__failed, __pyx_t_5}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 558, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_opendir_fuse_reply__failed, __pyx_t_5}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 558, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_opendir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_opendir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_11, __pyx_kp_u_fuse_opendir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_11, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 558, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":557 * ret = fuse_reply_open(c.req, &c.fi) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_opendir(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":546 * save_retval(fuse_opendir_async(c)) * * async def fuse_opendir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_opendir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_12ReaddirToken_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_12ReaddirToken___reduce_cython__[] = "ReaddirToken.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_12ReaddirToken_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_12ReaddirToken___reduce_cython__(((struct __pyx_obj_7pyfuse3_ReaddirToken *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_12ReaddirToken___reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self.req cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.req cannot be converted to a Python object for pickling") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.ReaddirToken.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self.req cannot be converted to a Python object for pickling") */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_12ReaddirToken_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_12ReaddirToken_2__setstate_cython__[] = "ReaddirToken.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_12ReaddirToken_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_12ReaddirToken_2__setstate_cython__(((struct __pyx_obj_7pyfuse3_ReaddirToken *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_12ReaddirToken_2__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.req cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("self.req cannot be converted to a Python object for pickling") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.ReaddirToken.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":568 * cdef size_t size * * cdef void fuse_readdirplus (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi): * global py_retval */ static void __pyx_f_7pyfuse3_fuse_readdirplus(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, size_t __pyx_v_size, off_t __pyx_v_off, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_readdirplus", 0); /* "src/handlers.pxi":571 * fuse_file_info *fi): * global py_retval * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.size = size */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 571, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":572 * global py_retval * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.size = size * c.off = off */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":573 * cdef _Container c = _Container() * c.req = req * c.size = size # <<<<<<<<<<<<<< * c.off = off * c.fh = fi.fh */ __pyx_v_c->size = __pyx_v_size; /* "src/handlers.pxi":574 * c.req = req * c.size = size * c.off = off # <<<<<<<<<<<<<< * c.fh = fi.fh * save_retval(fuse_readdirplus_async(c)) */ __pyx_v_c->off = __pyx_v_off; /* "src/handlers.pxi":575 * c.size = size * c.off = off * c.fh = fi.fh # <<<<<<<<<<<<<< * save_retval(fuse_readdirplus_async(c)) * */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":576 * c.off = off * c.fh = fi.fh * save_retval(fuse_readdirplus_async(c)) # <<<<<<<<<<<<<< * * async def fuse_readdirplus_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_readdirplus_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 576, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":568 * cdef size_t size * * cdef void fuse_readdirplus (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off, # <<<<<<<<<<<<<< * fuse_file_info *fi): * global py_retval */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pyfuse3.fuse_readdirplus", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_59generator19(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":578 * save_retval(fuse_readdirplus_async(c)) * * async def fuse_readdirplus_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ReaddirToken token = ReaddirToken() */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_58fuse_readdirplus_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_57fuse_readdirplus_async[] = "fuse_readdirplus_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_58fuse_readdirplus_async = {"fuse_readdirplus_async", (PyCFunction)__pyx_pw_7pyfuse3_58fuse_readdirplus_async, METH_O, __pyx_doc_7pyfuse3_57fuse_readdirplus_async}; static PyObject *__pyx_pw_7pyfuse3_58fuse_readdirplus_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_readdirplus_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 578, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_57fuse_readdirplus_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_57fuse_readdirplus_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_readdirplus_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 578, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_59generator19, __pyx_codeobj__26, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_readdirplus_async, __pyx_n_s_fuse_readdirplus_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 578, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_readdirplus_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_59generator19(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; size_t __pyx_t_2; fuse_req_t __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; char const *__pyx_t_15; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; char const *__pyx_t_22; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_readdirplus_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L13_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 578, __pyx_L1_error) /* "src/handlers.pxi":580 * async def fuse_readdirplus_async (_Container c): * cdef int ret * cdef ReaddirToken token = ReaddirToken() # <<<<<<<<<<<<<< * token.buf_start = NULL * token.size = c.size */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3_ReaddirToken)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 580, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_token = ((struct __pyx_obj_7pyfuse3_ReaddirToken *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":581 * cdef int ret * cdef ReaddirToken token = ReaddirToken() * token.buf_start = NULL # <<<<<<<<<<<<<< * token.size = c.size * token.req = c.req */ __pyx_cur_scope->__pyx_v_token->buf_start = NULL; /* "src/handlers.pxi":582 * cdef ReaddirToken token = ReaddirToken() * token.buf_start = NULL * token.size = c.size # <<<<<<<<<<<<<< * token.req = c.req * */ __pyx_t_2 = __pyx_cur_scope->__pyx_v_c->size; __pyx_cur_scope->__pyx_v_token->size = __pyx_t_2; /* "src/handlers.pxi":583 * token.buf_start = NULL * token.size = c.size * token.req = c.req # <<<<<<<<<<<<<< * * try: */ __pyx_t_3 = __pyx_cur_scope->__pyx_v_c->req; __pyx_cur_scope->__pyx_v_token->req = __pyx_t_3; /* "src/handlers.pxi":585 * token.req = c.req * * try: # <<<<<<<<<<<<<< * await operations.readdir(c.fh, c.off, token) * except FUSEError as e: */ /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_6); /*try:*/ { /* "src/handlers.pxi":586 * * try: * await operations.readdir(c.fh, c.off, token) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_readdir); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 586, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 586, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = __Pyx_PyInt_From_off_t(__pyx_cur_scope->__pyx_v_c->off); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 586, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_10 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_10 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_10)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_10); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_t_8, __pyx_t_9, ((PyObject *)__pyx_cur_scope->__pyx_v_token)}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 586, __pyx_L7_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_7)) { PyObject *__pyx_temp[4] = {__pyx_t_10, __pyx_t_8, __pyx_t_9, ((PyObject *)__pyx_cur_scope->__pyx_v_token)}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_7, __pyx_temp+1-__pyx_t_11, 3+__pyx_t_11); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 586, __pyx_L7_error) __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } else #endif { __pyx_t_12 = PyTuple_New(3+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 586, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_10) { __Pyx_GIVEREF(__pyx_t_10); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_10); __pyx_t_10 = NULL; } __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_11, __pyx_t_8); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_11, __pyx_t_9); __Pyx_INCREF(((PyObject *)__pyx_cur_scope->__pyx_v_token)); __Pyx_GIVEREF(((PyObject *)__pyx_cur_scope->__pyx_v_token)); PyTuple_SET_ITEM(__pyx_t_12, 2+__pyx_t_11, ((PyObject *)__pyx_cur_scope->__pyx_v_token)); __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_7, __pyx_t_12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 586, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_0 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_t_1 = __pyx_t_5; __Pyx_XGIVEREF(__pyx_t_6); __pyx_cur_scope->__pyx_t_2 = __pyx_t_6; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L13_resume_from_await:; __pyx_t_4 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_4); __pyx_t_5 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_5); __pyx_t_6 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 586, __pyx_L7_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 586, __pyx_L7_error) } } /* "src/handlers.pxi":585 * token.req = c.req * * try: # <<<<<<<<<<<<<< * await operations.readdir(c.fh, c.off, token) * except FUSEError as e: */ } /* "src/handlers.pxi":590 * ret = fuse_reply_err(c.req, e.errno) * else: * if token.buf_start == NULL: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(c.req, NULL, 0) * else: */ /*else:*/ { __pyx_t_13 = ((__pyx_cur_scope->__pyx_v_token->buf_start == NULL) != 0); if (__pyx_t_13) { /* "src/handlers.pxi":591 * else: * if token.buf_start == NULL: * ret = fuse_reply_buf(c.req, NULL, 0) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_buf(c.req, token.buf_start, c.size - token.size) */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_buf(__pyx_cur_scope->__pyx_v_c->req, NULL, 0); /* "src/handlers.pxi":590 * ret = fuse_reply_err(c.req, e.errno) * else: * if token.buf_start == NULL: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(c.req, NULL, 0) * else: */ goto __pyx_L14; } /* "src/handlers.pxi":593 * ret = fuse_reply_buf(c.req, NULL, 0) * else: * ret = fuse_reply_buf(c.req, token.buf_start, c.size - token.size) # <<<<<<<<<<<<<< * finally: * stdlib.free(token.buf_start) */ /*else*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_buf(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_token->buf_start, (__pyx_cur_scope->__pyx_v_c->size - __pyx_cur_scope->__pyx_v_token->size)); } __pyx_L14:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L12_try_end; __pyx_L7_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":587 * try: * await operations.readdir(c.fh, c.off, token) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_11) { __Pyx_AddTraceback("pyfuse3.fuse_readdirplus_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_7, &__pyx_t_12) < 0) __PYX_ERR(1, 587, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_12); __Pyx_INCREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_7); __pyx_cur_scope->__pyx_v_e = __pyx_t_7; /*try:*/ { /* "src/handlers.pxi":588 * await operations.readdir(c.fh, c.off, token) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * if token.buf_start == NULL: */ __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 588, __pyx_L20_error) __Pyx_GOTREF(__pyx_t_9); __pyx_t_11 = __Pyx_PyInt_As_int(__pyx_t_9); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 588, __pyx_L20_error) __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_11); } /* "src/handlers.pxi":587 * try: * await operations.readdir(c.fh, c.off, token) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L21; } __pyx_L20_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_19, &__pyx_t_20, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18) < 0)) __Pyx_ErrFetch(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_11 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_19, __pyx_t_20, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ErrRestore(__pyx_t_16, __pyx_t_17, __pyx_t_18); __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_11; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15; goto __pyx_L9_except_error; } __pyx_L21:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L8_exception_handled; } goto __pyx_L9_except_error; __pyx_L9_except_error:; /* "src/handlers.pxi":585 * token.req = c.req * * try: # <<<<<<<<<<<<<< * await operations.readdir(c.fh, c.off, token) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); goto __pyx_L5_error; __pyx_L8_exception_handled:; __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_5, __pyx_t_6); __pyx_L12_try_end:; } } /* "src/handlers.pxi":595 * ret = fuse_reply_buf(c.req, token.buf_start, c.size - token.size) * finally: * stdlib.free(token.buf_start) # <<<<<<<<<<<<<< * * if ret != 0: */ /*finally:*/ { /*normal exit:*/{ free(__pyx_cur_scope->__pyx_v_token->buf_start); goto __pyx_L6; } __pyx_L5_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_20, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4) < 0)) __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_5, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_21); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_14 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_22 = __pyx_filename; { free(__pyx_cur_scope->__pyx_v_token->buf_start); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_21); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_20, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ErrRestore(__pyx_t_6, __pyx_t_5, __pyx_t_4); __pyx_t_6 = 0; __pyx_t_5 = 0; __pyx_t_4 = 0; __pyx_t_21 = 0; __pyx_t_20 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_14; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_22; goto __pyx_L1_error; } __pyx_L6:; } /* "src/handlers.pxi":597 * stdlib.free(token.buf_start) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readdirplus(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_13 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_13) { /* "src/handlers.pxi":598 * * if ret != 0: * log.error('fuse_readdirplus(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_log); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_kp_u_fuse_readdirplus_fuse_reply__fai, __pyx_t_7}; __pyx_t_12 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 598, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_9, __pyx_kp_u_fuse_readdirplus_fuse_reply__fai, __pyx_t_7}; __pyx_t_12 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 598, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_8 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_readdirplus_fuse_reply__fai); __Pyx_GIVEREF(__pyx_kp_u_fuse_readdirplus_fuse_reply__fai); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_11, __pyx_kp_u_fuse_readdirplus_fuse_reply__fai); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_11, __pyx_t_7); __pyx_t_7 = 0; __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_8, NULL); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 598, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_12); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; /* "src/handlers.pxi":597 * stdlib.free(token.buf_start) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_readdirplus(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":578 * save_retval(fuse_readdirplus_async(c)) * * async def fuse_readdirplus_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ReaddirToken token = ReaddirToken() */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("fuse_readdirplus_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":601 * * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_releasedir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_releasedir", 0); /* "src/handlers.pxi":602 * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.fh = fi.fh */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 602, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":603 * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.fh = fi.fh * save_retval(fuse_releasedir_async(c)) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":604 * cdef _Container c = _Container() * c.req = req * c.fh = fi.fh # <<<<<<<<<<<<<< * save_retval(fuse_releasedir_async(c)) * */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":605 * c.req = req * c.fh = fi.fh * save_retval(fuse_releasedir_async(c)) # <<<<<<<<<<<<<< * * async def fuse_releasedir_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_releasedir_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 605, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":601 * * * cdef void fuse_releasedir (fuse_req_t req, fuse_ino_t ino, fuse_file_info *fi): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pyfuse3.fuse_releasedir", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_62generator20(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":607 * save_retval(fuse_releasedir_async(c)) * * async def fuse_releasedir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_61fuse_releasedir_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_60fuse_releasedir_async[] = "fuse_releasedir_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_61fuse_releasedir_async = {"fuse_releasedir_async", (PyCFunction)__pyx_pw_7pyfuse3_61fuse_releasedir_async, METH_O, __pyx_doc_7pyfuse3_60fuse_releasedir_async}; static PyObject *__pyx_pw_7pyfuse3_61fuse_releasedir_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_releasedir_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 607, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_60fuse_releasedir_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_60fuse_releasedir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_releasedir_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 607, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_62generator20, __pyx_codeobj__27, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_releasedir_async, __pyx_n_s_fuse_releasedir_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 607, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_releasedir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_62generator20(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_t_9; char const *__pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_releasedir_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 607, __pyx_L1_error) /* "src/handlers.pxi":610 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.releasedir(c.fh) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":611 * * try: * await operations.releasedir(c.fh) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_releasedir); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 611, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 611, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_7, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 611, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 611, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 611, __pyx_L4_error) } } /* "src/handlers.pxi":610 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.releasedir(c.fh) * except FUSEError as e: */ } /* "src/handlers.pxi":615 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/handlers.pxi":612 * try: * await operations.releasedir(c.fh) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_releasedir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_6) < 0) __PYX_ERR(1, 612, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":613 * await operations.releasedir(c.fh) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 613, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 613, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":612 * try: * await operations.releasedir(c.fh) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __pyx_t_8 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); } __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":610 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.releasedir(c.fh) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L9_try_end:; } /* "src/handlers.pxi":617 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/handlers.pxi":618 * * if ret != 0: * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_releasedir_fuse_reply__fail, __pyx_t_5}; __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_releasedir_fuse_reply__fail, __pyx_t_5}; __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_18 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_releasedir_fuse_reply__fail); __Pyx_GIVEREF(__pyx_kp_u_fuse_releasedir_fuse_reply__fail); PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_9, __pyx_kp_u_fuse_releasedir_fuse_reply__fail); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_9, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_18, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 618, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/handlers.pxi":617 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_releasedir(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":607 * save_retval(fuse_releasedir_async(c)) * * async def fuse_releasedir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_18); __Pyx_AddTraceback("fuse_releasedir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":622 * * * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_fsyncdir(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino, int __pyx_v_datasync, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; uint64_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_fsyncdir", 0); /* "src/handlers.pxi":624 * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, * fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.flags = datasync */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 624, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":625 * fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.flags = datasync * c.fh = fi.fh */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":626 * cdef _Container c = _Container() * c.req = req * c.flags = datasync # <<<<<<<<<<<<<< * c.fh = fi.fh * save_retval(fuse_fsyncdir_async(c)) */ __pyx_v_c->flags = __pyx_v_datasync; /* "src/handlers.pxi":627 * c.req = req * c.flags = datasync * c.fh = fi.fh # <<<<<<<<<<<<<< * save_retval(fuse_fsyncdir_async(c)) * */ __pyx_t_2 = __pyx_v_fi->fh; __pyx_v_c->fh = __pyx_t_2; /* "src/handlers.pxi":628 * c.flags = datasync * c.fh = fi.fh * save_retval(fuse_fsyncdir_async(c)) # <<<<<<<<<<<<<< * * async def fuse_fsyncdir_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_fsyncdir_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_3, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 628, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":622 * * * cdef void fuse_fsyncdir (fuse_req_t req, fuse_ino_t ino, int datasync, # <<<<<<<<<<<<<< * fuse_file_info *fi): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_WriteUnraisable("pyfuse3.fuse_fsyncdir", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_65generator21(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":630 * save_retval(fuse_fsyncdir_async(c)) * * async def fuse_fsyncdir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_64fuse_fsyncdir_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_63fuse_fsyncdir_async[] = "fuse_fsyncdir_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_64fuse_fsyncdir_async = {"fuse_fsyncdir_async", (PyCFunction)__pyx_pw_7pyfuse3_64fuse_fsyncdir_async, METH_O, __pyx_doc_7pyfuse3_63fuse_fsyncdir_async}; static PyObject *__pyx_pw_7pyfuse3_64fuse_fsyncdir_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_fsyncdir_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 630, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_63fuse_fsyncdir_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_63fuse_fsyncdir_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_fsyncdir_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 630, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_65generator21, __pyx_codeobj__28, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_fsyncdir_async, __pyx_n_s_fuse_fsyncdir_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 630, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_fsyncdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_65generator21(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_t_19; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_fsyncdir_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 630, __pyx_L1_error) /* "src/handlers.pxi":633 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.fsyncdir(c.fh, c.flags != 0) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":634 * * try: * await operations.fsyncdir(c.fh, c.flags != 0) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_fsyncdir); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 634, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_uint64_t(__pyx_cur_scope->__pyx_v_c->fh); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 634, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyBool_FromLong((__pyx_cur_scope->__pyx_v_c->flags != 0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 634, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 634, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_t_6, __pyx_t_7}; __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 634, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } else #endif { __pyx_t_10 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 634, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_9, __pyx_t_6); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_9, __pyx_t_7); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_10, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 634, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 634, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 634, __pyx_L4_error) } } /* "src/handlers.pxi":633 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.fsyncdir(c.fh, c.flags != 0) * except FUSEError as e: */ } /* "src/handlers.pxi":638 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; /* "src/handlers.pxi":635 * try: * await operations.fsyncdir(c.fh, c.flags != 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_9) { __Pyx_AddTraceback("pyfuse3.fuse_fsyncdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_5, &__pyx_t_10) < 0) __PYX_ERR(1, 635, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":636 * await operations.fsyncdir(c.fh, c.flags != 0) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 636, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = __Pyx_PyInt_As_int(__pyx_t_7); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 636, __pyx_L16_error) __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_9); } /* "src/handlers.pxi":635 * try: * await operations.fsyncdir(c.fh, c.flags != 0) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_9 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_9; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":633 * cdef int ret * * try: # <<<<<<<<<<<<<< * await operations.fsyncdir(c.fh, c.flags != 0) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); __pyx_L9_try_end:; } /* "src/handlers.pxi":640 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_19 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_19) { /* "src/handlers.pxi":641 * * if ret != 0: * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_fsyncdir_fuse_reply__failed, __pyx_t_5}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 641, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_kp_u_fuse_fsyncdir_fuse_reply__failed, __pyx_t_5}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 641, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_11, __pyx_kp_u_fuse_fsyncdir_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_11, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_6, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 641, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/handlers.pxi":640 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_fsyncdir(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":630 * save_retval(fuse_fsyncdir_async(c)) * * async def fuse_fsyncdir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("fuse_fsyncdir_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":645 * * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_statfs(fuse_req_t __pyx_v_req, CYTHON_UNUSED fuse_ino_t __pyx_v_ino) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_statfs", 0); /* "src/handlers.pxi":646 * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * save_retval(fuse_statfs_async(c)) */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 646, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":647 * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * save_retval(fuse_statfs_async(c)) * */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":648 * cdef _Container c = _Container() * c.req = req * save_retval(fuse_statfs_async(c)) # <<<<<<<<<<<<<< * * async def fuse_statfs_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_statfs_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":645 * * * cdef void fuse_statfs (fuse_req_t req, fuse_ino_t ino): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyfuse3.fuse_statfs", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_68generator22(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":650 * save_retval(fuse_statfs_async(c)) * * async def fuse_statfs_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef StatvfsData stats */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_67fuse_statfs_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_66fuse_statfs_async[] = "fuse_statfs_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_67fuse_statfs_async = {"fuse_statfs_async", (PyCFunction)__pyx_pw_7pyfuse3_67fuse_statfs_async, METH_O, __pyx_doc_7pyfuse3_66fuse_statfs_async}; static PyObject *__pyx_pw_7pyfuse3_67fuse_statfs_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_statfs_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 650, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_66fuse_statfs_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_66fuse_statfs_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_statfs_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 650, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_68generator22, __pyx_codeobj__29, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_statfs_async, __pyx_n_s_fuse_statfs_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 650, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_statfs_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_68generator22(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; char const *__pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_t_17; PyObject *__pyx_t_18 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_statfs_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 650, __pyx_L1_error) /* "src/handlers.pxi":654 * cdef StatvfsData stats * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * stats = await operations.statfs(ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 654, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":655 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * stats = await operations.statfs(ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":656 * ctx = get_request_context(c.req) * try: * stats = await operations.statfs(ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_statfs); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 656, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_1 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_cur_scope->__pyx_v_ctx); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 656, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 656, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 656, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_StatvfsData)))) __PYX_ERR(1, 656, __pyx_L4_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_stats = ((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":655 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * stats = await operations.statfs(ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":660 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_statfs(c.req, &stats.stat) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_statfs(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_stats->stat)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/handlers.pxi":657 * try: * stats = await operations.statfs(ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_7 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_7) { __Pyx_AddTraceback("pyfuse3.fuse_statfs_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_6) < 0) __PYX_ERR(1, 657, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_6); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":658 * stats = await operations.statfs(ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_statfs(c.req, &stats.stat) */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 658, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_7 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 658, __pyx_L16_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_7); } /* "src/handlers.pxi":657 * try: * stats = await operations.statfs(ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __pyx_t_7 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); } __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_lineno = __pyx_t_7; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":655 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * stats = await operations.statfs(ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":662 * ret = fuse_reply_statfs(c.req, &stats.stat) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_17 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_17) { /* "src/handlers.pxi":663 * * if ret != 0: * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_8 = NULL; __pyx_t_9 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_9 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_statfs_fuse_reply__failed_w, __pyx_t_1}; __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_statfs_fuse_reply__failed_w, __pyx_t_1}; __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_9, 2+__pyx_t_9); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_18 = PyTuple_New(2+__pyx_t_9); if (unlikely(!__pyx_t_18)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_18); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_statfs_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_statfs_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_18, 0+__pyx_t_9, __pyx_kp_u_fuse_statfs_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_18, 1+__pyx_t_9, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_18, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 663, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/handlers.pxi":662 * ret = fuse_reply_statfs(c.req, &stats.stat) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_statfs(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":650 * save_retval(fuse_statfs_async(c)) * * async def fuse_statfs_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef StatvfsData stats */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_18); __Pyx_AddTraceback("fuse_statfs_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":666 * * * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_setxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_cname, const char *__pyx_v_cvalue, size_t __pyx_v_size, int __pyx_v_flags) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_value = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_setxattr", 0); /* "src/handlers.pxi":668 * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, * const_char *cvalue, size_t size, int flags): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 668, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":669 * const_char *cvalue, size_t size, int flags): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * c.size = size */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":670 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * c.size = size * c.flags = flags */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":671 * c.req = req * c.ino = ino * c.size = size # <<<<<<<<<<<<<< * c.flags = flags * */ __pyx_v_c->size = __pyx_v_size; /* "src/handlers.pxi":672 * c.ino = ino * c.size = size * c.flags = flags # <<<<<<<<<<<<<< * * name = PyBytes_FromString(cname) */ __pyx_v_c->flags = __pyx_v_flags; /* "src/handlers.pxi":674 * c.flags = flags * * name = PyBytes_FromString(cname) # <<<<<<<<<<<<<< * if c.size > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') */ __pyx_t_1 = PyBytes_FromString(__pyx_v_cname); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 674, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_name = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":675 * * name = PyBytes_FromString(cname) * if c.size > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< * raise OverflowError('Value too long to convert to Python') * value = PyBytes_FromStringAndSize(cvalue, c.size) */ __pyx_t_2 = ((__pyx_v_c->size > PY_SSIZE_T_MAX) != 0); if (unlikely(__pyx_t_2)) { /* "src/handlers.pxi":676 * name = PyBytes_FromString(cname) * if c.size > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') # <<<<<<<<<<<<<< * value = PyBytes_FromStringAndSize(cvalue, c.size) * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_OverflowError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 676, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(1, 676, __pyx_L1_error) /* "src/handlers.pxi":675 * * name = PyBytes_FromString(cname) * if c.size > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< * raise OverflowError('Value too long to convert to Python') * value = PyBytes_FromStringAndSize(cvalue, c.size) */ } /* "src/handlers.pxi":677 * if c.size > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') * value = PyBytes_FromStringAndSize(cvalue, c.size) # <<<<<<<<<<<<<< * * save_retval(fuse_setxattr_async(c, name, value)) */ __pyx_t_1 = PyBytes_FromStringAndSize(__pyx_v_cvalue, ((Py_ssize_t)__pyx_v_c->size)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 677, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_value = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":679 * value = PyBytes_FromStringAndSize(cvalue, c.size) * * save_retval(fuse_setxattr_async(c, name, value)) # <<<<<<<<<<<<<< * * async def fuse_setxattr_async (_Container c, name, value): */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fuse_setxattr_async); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_v_name, __pyx_v_value}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 679, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[4] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_v_name, __pyx_v_value}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_5, 3+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 679, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); } else #endif { __pyx_t_6 = PyTuple_New(3+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_name); __Pyx_INCREF(__pyx_v_value); __Pyx_GIVEREF(__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_6, 2+__pyx_t_5, __pyx_v_value); __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 679, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":666 * * * cdef void fuse_setxattr (fuse_req_t req, fuse_ino_t ino, const_char *cname, # <<<<<<<<<<<<<< * const_char *cvalue, size_t size, int flags): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_value); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_71generator23(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":681 * save_retval(fuse_setxattr_async(c, name, value)) * * async def fuse_setxattr_async (_Container c, name, value): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_70fuse_setxattr_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_69fuse_setxattr_async[] = "fuse_setxattr_async(_Container c, name, value)"; static PyMethodDef __pyx_mdef_7pyfuse3_70fuse_setxattr_async = {"fuse_setxattr_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_70fuse_setxattr_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_69fuse_setxattr_async}; static PyObject *__pyx_pw_7pyfuse3_70fuse_setxattr_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; PyObject *__pyx_v_value = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_setxattr_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,&__pyx_n_s_value,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_setxattr_async", 1, 3, 3, 1); __PYX_ERR(1, 681, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_setxattr_async", 1, 3, 3, 2); __PYX_ERR(1, 681, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_setxattr_async") < 0)) __PYX_ERR(1, 681, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; __pyx_v_value = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_setxattr_async", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 681, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_setxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 681, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_69fuse_setxattr_async(__pyx_self, __pyx_v_c, __pyx_v_name, __pyx_v_value); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_69fuse_setxattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name, PyObject *__pyx_v_value) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_setxattr_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 681, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); __pyx_cur_scope->__pyx_v_value = __pyx_v_value; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_value); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_value); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_71generator23, __pyx_codeobj__30, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_setxattr_async, __pyx_n_s_fuse_setxattr_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_setxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_71generator23(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_t_16; char const *__pyx_t_17; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; char const *__pyx_t_24; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_setxattr_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L21_resume_from_await; case 2: goto __pyx_L34_resume_from_await; case 3: goto __pyx_L35_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 681, __pyx_L1_error) /* "src/handlers.pxi":685 * * # Special case for deadlock debugging * if c.ino == FUSE_ROOT_ID and name == 'fuse_stacktrace': # <<<<<<<<<<<<<< * operations.stacktrace() * fuse_reply_err(c.req, 0) */ __pyx_t_2 = ((__pyx_cur_scope->__pyx_v_c->ino == FUSE_ROOT_ID) != 0); if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L5_bool_binop_done; } __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_cur_scope->__pyx_v_name, __pyx_n_u_fuse_stacktrace, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 685, __pyx_L1_error) __pyx_t_1 = __pyx_t_2; __pyx_L5_bool_binop_done:; if (__pyx_t_1) { /* "src/handlers.pxi":686 * # Special case for deadlock debugging * if c.ino == FUSE_ROOT_ID and name == 'fuse_stacktrace': * operations.stacktrace() # <<<<<<<<<<<<<< * fuse_reply_err(c.req, 0) * return */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_stacktrace); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 686, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 686, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/handlers.pxi":687 * if c.ino == FUSE_ROOT_ID and name == 'fuse_stacktrace': * operations.stacktrace() * fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * return * */ (void)(fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0)); /* "src/handlers.pxi":688 * operations.stacktrace() * fuse_reply_err(c.req, 0) * return # <<<<<<<<<<<<<< * * # Make sure we know all the flags */ __Pyx_XDECREF(__pyx_r); __pyx_r = NULL; goto __pyx_L0; /* "src/handlers.pxi":685 * * # Special case for deadlock debugging * if c.ino == FUSE_ROOT_ID and name == 'fuse_stacktrace': # <<<<<<<<<<<<<< * operations.stacktrace() * fuse_reply_err(c.req, 0) */ } /* "src/handlers.pxi":691 * * # Make sure we know all the flags * if c.flags & ~(libc_extra.XATTR_CREATE | libc_extra.XATTR_REPLACE): # <<<<<<<<<<<<<< * raise ValueError('unknown flag(s): %o' % c.flags) * */ __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_c->flags & (~(XATTR_CREATE | XATTR_REPLACE))) != 0); if (unlikely(__pyx_t_1)) { /* "src/handlers.pxi":692 * # Make sure we know all the flags * if c.flags & ~(libc_extra.XATTR_CREATE | libc_extra.XATTR_REPLACE): * raise ValueError('unknown flag(s): %o' % c.flags) # <<<<<<<<<<<<<< * * ctx = get_request_context(c.req) */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_c->flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyUnicode_Format(__pyx_kp_u_unknown_flag_s_o, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 692, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(1, 692, __pyx_L1_error) /* "src/handlers.pxi":691 * * # Make sure we know all the flags * if c.flags & ~(libc_extra.XATTR_CREATE | libc_extra.XATTR_REPLACE): # <<<<<<<<<<<<<< * raise ValueError('unknown flag(s): %o' % c.flags) * */ } /* "src/handlers.pxi":694 * raise ValueError('unknown flag(s): %o' % c.flags) * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist */ __pyx_t_3 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 694, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_3; __pyx_t_3 = 0; /* "src/handlers.pxi":695 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist * try: */ { __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); /*try:*/ { /* "src/handlers.pxi":696 * ctx = get_request_context(c.req) * try: * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist # <<<<<<<<<<<<<< * try: * await operations.getxattr(c.ino, name) */ __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_c->flags & XATTR_CREATE) != 0); if (__pyx_t_1) { /* "src/handlers.pxi":697 * try: * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist * try: # <<<<<<<<<<<<<< * await operations.getxattr(c.ino, name) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/handlers.pxi":698 * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist * try: * await operations.getxattr(c.ino, name) # <<<<<<<<<<<<<< * except FUSEError as e: * if e.errno != ENOATTR: */ __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 698, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 698, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); __pyx_t_13 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_t_5, __pyx_cur_scope->__pyx_v_name}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L15_error) __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_4)) { PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_t_5, __pyx_cur_scope->__pyx_v_name}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_4, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L15_error) __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_14 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 698, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_14); if (__pyx_t_12) { __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_12); __pyx_t_12 = NULL; } __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_14, 0+__pyx_t_13, __pyx_t_5); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_14, 1+__pyx_t_13, __pyx_cur_scope->__pyx_v_name); __pyx_t_5 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_14, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L15_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; } __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_6); __pyx_cur_scope->__pyx_t_0 = __pyx_t_6; __Pyx_XGIVEREF(__pyx_t_7); __pyx_cur_scope->__pyx_t_1 = __pyx_t_7; __Pyx_XGIVEREF(__pyx_t_8); __pyx_cur_scope->__pyx_t_2 = __pyx_t_8; __Pyx_XGIVEREF(__pyx_t_9); __pyx_cur_scope->__pyx_t_3 = __pyx_t_9; __Pyx_XGIVEREF(__pyx_t_10); __pyx_cur_scope->__pyx_t_4 = __pyx_t_10; __Pyx_XGIVEREF(__pyx_t_11); __pyx_cur_scope->__pyx_t_5 = __pyx_t_11; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L21_resume_from_await:; __pyx_t_6 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_6); __pyx_t_7 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_7); __pyx_t_8 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_8); __pyx_t_9 = __pyx_cur_scope->__pyx_t_3; __pyx_cur_scope->__pyx_t_3 = 0; __Pyx_XGOTREF(__pyx_t_9); __pyx_t_10 = __pyx_cur_scope->__pyx_t_4; __pyx_cur_scope->__pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_t_10); __pyx_t_11 = __pyx_cur_scope->__pyx_t_5; __pyx_cur_scope->__pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 698, __pyx_L15_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 698, __pyx_L15_error) } } /* "src/handlers.pxi":697 * try: * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist * try: # <<<<<<<<<<<<<< * await operations.getxattr(c.ino, name) * except FUSEError as e: */ } /* "src/handlers.pxi":703 * raise * else: * raise FUSEError(errno.EEXIST) # <<<<<<<<<<<<<< * * elif c.flags & libc_extra.XATTR_REPLACE: # Attribute must exist */ /*else:*/ { __pyx_t_3 = __Pyx_PyInt_From_int(EEXIST); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 703, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError), __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 703, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 703, __pyx_L17_except_error) } __pyx_L15_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":699 * try: * await operations.getxattr(c.ino, name) * except FUSEError as e: # <<<<<<<<<<<<<< * if e.errno != ENOATTR: * raise */ __pyx_t_13 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_13) { __Pyx_AddTraceback("pyfuse3.fuse_setxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_3, &__pyx_t_14) < 0) __PYX_ERR(1, 699, __pyx_L17_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_14); __Pyx_INCREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_v_e = __pyx_t_3; /*try:*/ { /* "src/handlers.pxi":700 * await operations.getxattr(c.ino, name) * except FUSEError as e: * if e.errno != ENOATTR: # <<<<<<<<<<<<<< * raise * else: */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 700, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_12 = __Pyx_PyInt_From_int(ENOATTR); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 700, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_15 = PyObject_RichCompare(__pyx_t_5, __pyx_t_12, Py_NE); __Pyx_XGOTREF(__pyx_t_15); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 700, __pyx_L27_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_15); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 700, __pyx_L27_error) __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; if (unlikely(__pyx_t_1)) { /* "src/handlers.pxi":701 * except FUSEError as e: * if e.errno != ENOATTR: * raise # <<<<<<<<<<<<<< * else: * raise FUSEError(errno.EEXIST) */ __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_3, __pyx_t_14); __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_14 = 0; __PYX_ERR(1, 701, __pyx_L27_error) /* "src/handlers.pxi":700 * await operations.getxattr(c.ino, name) * except FUSEError as e: * if e.errno != ENOATTR: # <<<<<<<<<<<<<< * raise * else: */ } } /* "src/handlers.pxi":699 * try: * await operations.getxattr(c.ino, name) * except FUSEError as e: # <<<<<<<<<<<<<< * if e.errno != ENOATTR: * raise */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L28; } __pyx_L27_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_21, &__pyx_t_22, &__pyx_t_23); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20) < 0)) __Pyx_ErrFetch(&__pyx_t_18, &__pyx_t_19, &__pyx_t_20); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_21); __Pyx_XGOTREF(__pyx_t_22); __Pyx_XGOTREF(__pyx_t_23); __pyx_t_13 = __pyx_lineno; __pyx_t_16 = __pyx_clineno; __pyx_t_17 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_21); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_XGIVEREF(__pyx_t_23); __Pyx_ExceptionReset(__pyx_t_21, __pyx_t_22, __pyx_t_23); } __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_XGIVEREF(__pyx_t_20); __Pyx_ErrRestore(__pyx_t_18, __pyx_t_19, __pyx_t_20); __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_16; __pyx_filename = __pyx_t_17; goto __pyx_L17_except_error; } __pyx_L28:; } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; goto __pyx_L16_exception_handled; } goto __pyx_L17_except_error; __pyx_L17_except_error:; /* "src/handlers.pxi":697 * try: * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist * try: # <<<<<<<<<<<<<< * await operations.getxattr(c.ino, name) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L8_error; __pyx_L16_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); } /* "src/handlers.pxi":696 * ctx = get_request_context(c.req) * try: * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist # <<<<<<<<<<<<<< * try: * await operations.getxattr(c.ino, name) */ goto __pyx_L14; } /* "src/handlers.pxi":705 * raise FUSEError(errno.EEXIST) * * elif c.flags & libc_extra.XATTR_REPLACE: # Attribute must exist # <<<<<<<<<<<<<< * await operations.getxattr(c.ino, name) * */ __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_c->flags & XATTR_REPLACE) != 0); if (__pyx_t_1) { /* "src/handlers.pxi":706 * * elif c.flags & libc_extra.XATTR_REPLACE: # Attribute must exist * await operations.getxattr(c.ino, name) # <<<<<<<<<<<<<< * * await operations.setxattr(c.ino, name, value, ctx) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 706, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 706, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_15 = NULL; __pyx_t_16 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_15 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_15)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_15); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_16 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_15, __pyx_t_4, __pyx_cur_scope->__pyx_v_name}; __pyx_t_14 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_16, 2+__pyx_t_16); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 706, __pyx_L8_error) __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[3] = {__pyx_t_15, __pyx_t_4, __pyx_cur_scope->__pyx_v_name}; __pyx_t_14 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_16, 2+__pyx_t_16); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 706, __pyx_L8_error) __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } else #endif { __pyx_t_12 = PyTuple_New(2+__pyx_t_16); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 706, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_12); if (__pyx_t_15) { __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_15); __pyx_t_15 = NULL; } __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_12, 0+__pyx_t_16, __pyx_t_4); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_12, 1+__pyx_t_16, __pyx_cur_scope->__pyx_v_name); __pyx_t_4 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_12, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 706, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_6); __pyx_cur_scope->__pyx_t_0 = __pyx_t_6; __Pyx_XGIVEREF(__pyx_t_7); __pyx_cur_scope->__pyx_t_1 = __pyx_t_7; __Pyx_XGIVEREF(__pyx_t_8); __pyx_cur_scope->__pyx_t_2 = __pyx_t_8; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 2; return __pyx_r; __pyx_L34_resume_from_await:; __pyx_t_6 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_6); __pyx_t_7 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_7); __pyx_t_8 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 706, __pyx_L8_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 706, __pyx_L8_error) } } /* "src/handlers.pxi":705 * raise FUSEError(errno.EEXIST) * * elif c.flags & libc_extra.XATTR_REPLACE: # Attribute must exist # <<<<<<<<<<<<<< * await operations.getxattr(c.ino, name) * */ } __pyx_L14:; /* "src/handlers.pxi":708 * await operations.getxattr(c.ino, name) * * await operations.setxattr(c.ino, name, value, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_setxattr); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 708, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_12 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 708, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_4 = NULL; __pyx_t_16 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_16 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_4, __pyx_t_12, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_value, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_14 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_16, 4+__pyx_t_16); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 708, __pyx_L8_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_4, __pyx_t_12, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_value, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_14 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_16, 4+__pyx_t_16); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 708, __pyx_L8_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; } else #endif { __pyx_t_15 = PyTuple_New(4+__pyx_t_16); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 708, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_15); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_15, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_15, 0+__pyx_t_16, __pyx_t_12); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_15, 1+__pyx_t_16, __pyx_cur_scope->__pyx_v_name); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_value); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_value); PyTuple_SET_ITEM(__pyx_t_15, 2+__pyx_t_16, __pyx_cur_scope->__pyx_v_value); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_15, 3+__pyx_t_16, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_12 = 0; __pyx_t_14 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_15, NULL); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 708, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_14); __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_6); __pyx_cur_scope->__pyx_t_0 = __pyx_t_6; __Pyx_XGIVEREF(__pyx_t_7); __pyx_cur_scope->__pyx_t_1 = __pyx_t_7; __Pyx_XGIVEREF(__pyx_t_8); __pyx_cur_scope->__pyx_t_2 = __pyx_t_8; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 3; return __pyx_r; __pyx_L35_resume_from_await:; __pyx_t_6 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_6); __pyx_t_7 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_7); __pyx_t_8 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 708, __pyx_L8_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 708, __pyx_L8_error) } } /* "src/handlers.pxi":695 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist * try: */ } /* "src/handlers.pxi":712 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L13_try_end; __pyx_L8_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":709 * * await operations.setxattr(c.ino, name, value, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_16 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_16) { __Pyx_AddTraceback("pyfuse3.fuse_setxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_14, &__pyx_t_3, &__pyx_t_15) < 0) __PYX_ERR(1, 709, __pyx_L10_except_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_GOTREF(__pyx_t_3); __Pyx_GOTREF(__pyx_t_15); __Pyx_INCREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_e, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); /*try:*/ { /* "src/handlers.pxi":710 * await operations.setxattr(c.ino, name, value, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 710, __pyx_L41_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_16 = __Pyx_PyInt_As_int(__pyx_t_12); if (unlikely((__pyx_t_16 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 710, __pyx_L41_error) __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_16); } /* "src/handlers.pxi":709 * * await operations.setxattr(c.ino, name, value, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L42; } __pyx_L41_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_23 = 0; __pyx_t_22 = 0; __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_23, &__pyx_t_22, &__pyx_t_21); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_10, &__pyx_t_9); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_23); __Pyx_XGOTREF(__pyx_t_22); __Pyx_XGOTREF(__pyx_t_21); __pyx_t_16 = __pyx_lineno; __pyx_t_13 = __pyx_clineno; __pyx_t_24 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_22, __pyx_t_21); } __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ErrRestore(__pyx_t_11, __pyx_t_10, __pyx_t_9); __pyx_t_11 = 0; __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_23 = 0; __pyx_t_22 = 0; __pyx_t_21 = 0; __pyx_lineno = __pyx_t_16; __pyx_clineno = __pyx_t_13; __pyx_filename = __pyx_t_24; goto __pyx_L10_except_error; } __pyx_L42:; } __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; goto __pyx_L9_exception_handled; } goto __pyx_L10_except_error; __pyx_L10_except_error:; /* "src/handlers.pxi":695 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * if c.flags & libc_extra.XATTR_CREATE: # Attribute must not exist * try: */ __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); goto __pyx_L1_error; __pyx_L9_exception_handled:; __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); __pyx_L13_try_end:; } /* "src/handlers.pxi":714 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_1 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_1) { /* "src/handlers.pxi":715 * * if ret != 0: * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_log); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_error); if (unlikely(!__pyx_t_14)) __PYX_ERR(1, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_12 = NULL; __pyx_t_13 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_14))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_14); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_14, function); __pyx_t_13 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_14)) { PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_kp_u_fuse_setxattr_fuse_reply__failed, __pyx_t_3}; __pyx_t_15 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 715, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) { PyObject *__pyx_temp[3] = {__pyx_t_12, __pyx_kp_u_fuse_setxattr_fuse_reply__failed, __pyx_t_3}; __pyx_t_15 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_13, 2+__pyx_t_13); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 715, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_4 = PyTuple_New(2+__pyx_t_13); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (__pyx_t_12) { __Pyx_GIVEREF(__pyx_t_12); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_12); __pyx_t_12 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_setxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_setxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_4, 0+__pyx_t_13, __pyx_kp_u_fuse_setxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 1+__pyx_t_13, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_15 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_4, NULL); if (unlikely(!__pyx_t_15)) __PYX_ERR(1, 715, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_15); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; /* "src/handlers.pxi":714 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_setxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":681 * save_retval(fuse_setxattr_async(c, name, value)) * * async def fuse_setxattr_async (_Container c, name, value): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_15); __Pyx_AddTraceback("fuse_setxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":718 * * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *name, # <<<<<<<<<<<<<< * size_t size): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_getxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_name, size_t __pyx_v_size) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_getxattr", 0); /* "src/handlers.pxi":720 * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *name, * size_t size): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 720, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":721 * size_t size): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * c.size = size */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":722 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * c.size = size * save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":723 * c.req = req * c.ino = ino * c.size = size # <<<<<<<<<<<<<< * save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) * */ __pyx_v_c->size = __pyx_v_size; /* "src/handlers.pxi":724 * c.ino = ino * c.size = size * save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) # <<<<<<<<<<<<<< * * async def fuse_getxattr_async (_Container c, name): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_getxattr_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 724, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 724, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 724, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":718 * * * cdef void fuse_getxattr (fuse_req_t req, fuse_ino_t ino, const_char *name, # <<<<<<<<<<<<<< * size_t size): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_74generator24(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":726 * save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) * * async def fuse_getxattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_73fuse_getxattr_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_72fuse_getxattr_async[] = "fuse_getxattr_async(_Container c, name)"; static PyMethodDef __pyx_mdef_7pyfuse3_73fuse_getxattr_async = {"fuse_getxattr_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_73fuse_getxattr_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_72fuse_getxattr_async}; static PyObject *__pyx_pw_7pyfuse3_73fuse_getxattr_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_getxattr_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_getxattr_async", 1, 2, 2, 1); __PYX_ERR(1, 726, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_getxattr_async") < 0)) __PYX_ERR(1, 726, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_getxattr_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 726, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_getxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 726, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_72fuse_getxattr_async(__pyx_self, __pyx_v_c, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_72fuse_getxattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_getxattr_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 726, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_74generator24, __pyx_codeobj__31, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_getxattr_async, __pyx_n_s_fuse_getxattr_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 726, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_getxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_74generator24(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_getxattr_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 726, __pyx_L1_error) /* "src/handlers.pxi":732 * cdef char *cbuf * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * buf = await operations.getxattr(c.ino, name, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 732, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":733 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * buf = await operations.getxattr(c.ino, name, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":734 * ctx = get_request_context(c.req) * try: * buf = await operations.getxattr(c.ino, name, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_getxattr); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 734, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 734, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 734, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 734, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 734, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_name); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 734, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 734, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 734, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_buf = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":733 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * buf = await operations.getxattr(c.ino, name, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":738 * ret = fuse_reply_err(c.req, e.errno) * else: * PyBytes_AsStringAndSize(buf, &cbuf, &len_s) # <<<<<<<<<<<<<< * len_ = len_s # guaranteed positive * */ /*else:*/ { __pyx_t_8 = PyBytes_AsStringAndSize(__pyx_cur_scope->__pyx_v_buf, (&__pyx_cur_scope->__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_cur_scope->__pyx_v_len_s))); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 738, __pyx_L6_except_error) /* "src/handlers.pxi":739 * else: * PyBytes_AsStringAndSize(buf, &cbuf, &len_s) * len_ = len_s # guaranteed positive # <<<<<<<<<<<<<< * * if c.size == 0: */ __pyx_cur_scope->__pyx_v_len_ = ((size_t)__pyx_cur_scope->__pyx_v_len_s); /* "src/handlers.pxi":741 * len_ = len_s # guaranteed positive * * if c.size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: */ __pyx_t_10 = ((__pyx_cur_scope->__pyx_v_c->size == 0) != 0); if (__pyx_t_10) { /* "src/handlers.pxi":742 * * if c.size == 0: * ret = fuse_reply_xattr(c.req, len_) # <<<<<<<<<<<<<< * elif len_ <= c.size: * ret = fuse_reply_buf(c.req, cbuf, len_) */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_xattr(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_len_); /* "src/handlers.pxi":741 * len_ = len_s # guaranteed positive * * if c.size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: */ goto __pyx_L11; } /* "src/handlers.pxi":743 * if c.size == 0: * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(c.req, cbuf, len_) * else: */ __pyx_t_10 = ((__pyx_cur_scope->__pyx_v_len_ <= __pyx_cur_scope->__pyx_v_c->size) != 0); if (__pyx_t_10) { /* "src/handlers.pxi":744 * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: * ret = fuse_reply_buf(c.req, cbuf, len_) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, errno.ERANGE) */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_buf(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_cbuf, __pyx_cur_scope->__pyx_v_len_); /* "src/handlers.pxi":743 * if c.size == 0: * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(c.req, cbuf, len_) * else: */ goto __pyx_L11; } /* "src/handlers.pxi":746 * ret = fuse_reply_buf(c.req, cbuf, len_) * else: * ret = fuse_reply_err(c.req, errno.ERANGE) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, ERANGE); } __pyx_L11:; } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":735 * try: * buf = await operations.getxattr(c.ino, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_getxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(1, 735, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":736 * buf = await operations.getxattr(c.ino, name, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * PyBytes_AsStringAndSize(buf, &cbuf, &len_s) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 736, __pyx_L17_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 736, __pyx_L17_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":735 * try: * buf = await operations.getxattr(c.ino, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L18; } __pyx_L17_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_8 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L18:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":733 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * buf = await operations.getxattr(c.ino, name, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":748 * ret = fuse_reply_err(c.req, errno.ERANGE) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_10 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_10) { /* "src/handlers.pxi":749 * * if ret != 0: * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_getxattr_fuse_reply__failed, __pyx_t_5}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 749, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_getxattr_fuse_reply__failed, __pyx_t_5}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 749, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_kp_u_fuse_getxattr_fuse_reply__failed); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_11, __pyx_kp_u_fuse_getxattr_fuse_reply__failed); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_11, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 749, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":748 * ret = fuse_reply_err(c.req, errno.ERANGE) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_getxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":726 * save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) * * async def fuse_getxattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_getxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":752 * * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_listxattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, size_t __pyx_v_size) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_listxattr", 0); /* "src/handlers.pxi":753 * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 753, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":754 * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * c.size = size */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":755 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * c.size = size * save_retval(fuse_listxattr_async(c)) */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":756 * c.req = req * c.ino = ino * c.size = size # <<<<<<<<<<<<<< * save_retval(fuse_listxattr_async(c)) * */ __pyx_v_c->size = __pyx_v_size; /* "src/handlers.pxi":757 * c.ino = ino * c.size = size * save_retval(fuse_listxattr_async(c)) # <<<<<<<<<<<<<< * * async def fuse_listxattr_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_listxattr_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":752 * * * cdef void fuse_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyfuse3.fuse_listxattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_77generator25(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":759 * save_retval(fuse_listxattr_async(c)) * * async def fuse_listxattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_76fuse_listxattr_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_75fuse_listxattr_async[] = "fuse_listxattr_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_76fuse_listxattr_async = {"fuse_listxattr_async", (PyCFunction)__pyx_pw_7pyfuse3_76fuse_listxattr_async, METH_O, __pyx_doc_7pyfuse3_75fuse_listxattr_async}; static PyObject *__pyx_pw_7pyfuse3_76fuse_listxattr_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_listxattr_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 759, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_75fuse_listxattr_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_75fuse_listxattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_listxattr_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 759, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_77generator25, __pyx_codeobj__32, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_listxattr_async, __pyx_n_s_fuse_listxattr_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 759, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_listxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_77generator25(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; int __pyx_t_11; char const *__pyx_t_12; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_listxattr_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 759, __pyx_L1_error) /* "src/handlers.pxi":766 * * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * res = await operations.listxattr(c.ino, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 766, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":767 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * res = await operations.listxattr(c.ino, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":768 * ctx = get_request_context(c.req) * try: * res = await operations.listxattr(c.ino, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_listxattr); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 768, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 768, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 768, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 768, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 768, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 768, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 768, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 768, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_res = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":767 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * res = await operations.listxattr(c.ino, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":772 * ret = fuse_reply_err(c.req, e.errno) * else: * buf = b'\0'.join(res) + b'\0' # <<<<<<<<<<<<<< * * PyBytes_AsStringAndSize(buf, &cbuf, &len_s) */ /*else:*/ { __pyx_t_1 = __Pyx_PyBytes_Join(__pyx_kp_b__33, __pyx_cur_scope->__pyx_v_res); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 772, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = PyNumber_Add(__pyx_t_1, __pyx_kp_b__33); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 772, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_buf = __pyx_t_5; __pyx_t_5 = 0; /* "src/handlers.pxi":774 * buf = b'\0'.join(res) + b'\0' * * PyBytes_AsStringAndSize(buf, &cbuf, &len_s) # <<<<<<<<<<<<<< * len_ = len_s # guaranteed positive * */ __pyx_t_8 = PyBytes_AsStringAndSize(__pyx_cur_scope->__pyx_v_buf, (&__pyx_cur_scope->__pyx_v_cbuf), ((Py_ssize_t *)(&__pyx_cur_scope->__pyx_v_len_s))); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 774, __pyx_L6_except_error) /* "src/handlers.pxi":775 * * PyBytes_AsStringAndSize(buf, &cbuf, &len_s) * len_ = len_s # guaranteed positive # <<<<<<<<<<<<<< * * if len_ == 1: # No attributes */ __pyx_cur_scope->__pyx_v_len_ = ((size_t)__pyx_cur_scope->__pyx_v_len_s); /* "src/handlers.pxi":777 * len_ = len_s # guaranteed positive * * if len_ == 1: # No attributes # <<<<<<<<<<<<<< * len_ = 0 * */ __pyx_t_10 = ((__pyx_cur_scope->__pyx_v_len_ == 1) != 0); if (__pyx_t_10) { /* "src/handlers.pxi":778 * * if len_ == 1: # No attributes * len_ = 0 # <<<<<<<<<<<<<< * * if c.size == 0: */ __pyx_cur_scope->__pyx_v_len_ = 0; /* "src/handlers.pxi":777 * len_ = len_s # guaranteed positive * * if len_ == 1: # No attributes # <<<<<<<<<<<<<< * len_ = 0 * */ } /* "src/handlers.pxi":780 * len_ = 0 * * if c.size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: */ __pyx_t_10 = ((__pyx_cur_scope->__pyx_v_c->size == 0) != 0); if (__pyx_t_10) { /* "src/handlers.pxi":781 * * if c.size == 0: * ret = fuse_reply_xattr(c.req, len_) # <<<<<<<<<<<<<< * elif len_ <= c.size: * ret = fuse_reply_buf(c.req, cbuf, len_) */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_xattr(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_len_); /* "src/handlers.pxi":780 * len_ = 0 * * if c.size == 0: # <<<<<<<<<<<<<< * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: */ goto __pyx_L12; } /* "src/handlers.pxi":782 * if c.size == 0: * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(c.req, cbuf, len_) * else: */ __pyx_t_10 = ((__pyx_cur_scope->__pyx_v_len_ <= __pyx_cur_scope->__pyx_v_c->size) != 0); if (__pyx_t_10) { /* "src/handlers.pxi":783 * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: * ret = fuse_reply_buf(c.req, cbuf, len_) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, errno.ERANGE) */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_buf(__pyx_cur_scope->__pyx_v_c->req, __pyx_cur_scope->__pyx_v_cbuf, __pyx_cur_scope->__pyx_v_len_); /* "src/handlers.pxi":782 * if c.size == 0: * ret = fuse_reply_xattr(c.req, len_) * elif len_ <= c.size: # <<<<<<<<<<<<<< * ret = fuse_reply_buf(c.req, cbuf, len_) * else: */ goto __pyx_L12; } /* "src/handlers.pxi":785 * ret = fuse_reply_buf(c.req, cbuf, len_) * else: * ret = fuse_reply_err(c.req, errno.ERANGE) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, ERANGE); } __pyx_L12:; } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":769 * try: * res = await operations.listxattr(c.ino, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_listxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_1, &__pyx_t_9) < 0) __PYX_ERR(1, 769, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_e = __pyx_t_1; /*try:*/ { /* "src/handlers.pxi":770 * res = await operations.listxattr(c.ino, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * buf = b'\0'.join(res) + b'\0' */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 770, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 770, __pyx_L18_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":769 * try: * res = await operations.listxattr(c.ino, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L19; } __pyx_L18_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_16, &__pyx_t_17, &__pyx_t_18); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15) < 0)) __Pyx_ErrFetch(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __pyx_t_8 = __pyx_lineno; __pyx_t_11 = __pyx_clineno; __pyx_t_12 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_ExceptionReset(__pyx_t_16, __pyx_t_17, __pyx_t_18); } __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ErrRestore(__pyx_t_13, __pyx_t_14, __pyx_t_15); __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_11; __pyx_filename = __pyx_t_12; goto __pyx_L6_except_error; } __pyx_L19:; } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":767 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * res = await operations.listxattr(c.ino, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":787 * ret = fuse_reply_err(c.req, errno.ERANGE) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_10 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_10) { /* "src/handlers.pxi":788 * * if ret != 0: * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_error); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_6 = NULL; __pyx_t_11 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_11 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_listxattr_fuse_reply__faile, __pyx_t_1}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 788, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_listxattr_fuse_reply__faile, __pyx_t_1}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_11, 2+__pyx_t_11); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 788, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_11); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_listxattr_fuse_reply__faile); __Pyx_GIVEREF(__pyx_kp_u_fuse_listxattr_fuse_reply__faile); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_11, __pyx_kp_u_fuse_listxattr_fuse_reply__faile); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_11, __pyx_t_1); __pyx_t_1 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 788, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":787 * ret = fuse_reply_err(c.req, errno.ERANGE) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_listxattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":759 * save_retval(fuse_listxattr_async(c)) * * async def fuse_listxattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_listxattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":791 * * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *name): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_removexattr(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, const char *__pyx_v_name) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_removexattr", 0); /* "src/handlers.pxi":792 * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *name): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 792, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":793 * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *name): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":794 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) * */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":795 * c.req = req * c.ino = ino * save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) # <<<<<<<<<<<<<< * * async def fuse_removexattr_async (_Container c, name): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_removexattr_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 795, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 795, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 795, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":791 * * * cdef void fuse_removexattr (fuse_req_t req, fuse_ino_t ino, const_char *name): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_removexattr", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_80generator26(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":797 * save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) * * async def fuse_removexattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_79fuse_removexattr_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_78fuse_removexattr_async[] = "fuse_removexattr_async(_Container c, name)"; static PyMethodDef __pyx_mdef_7pyfuse3_79fuse_removexattr_async = {"fuse_removexattr_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_79fuse_removexattr_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_78fuse_removexattr_async}; static PyObject *__pyx_pw_7pyfuse3_79fuse_removexattr_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_removexattr_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_removexattr_async", 1, 2, 2, 1); __PYX_ERR(1, 797, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_removexattr_async") < 0)) __PYX_ERR(1, 797, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_removexattr_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 797, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_removexattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 797, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_78fuse_removexattr_async(__pyx_self, __pyx_v_c, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_78fuse_removexattr_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_removexattr_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 797, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_80generator26, __pyx_codeobj__34, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_removexattr_async, __pyx_n_s_fuse_removexattr_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 797, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_removexattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_80generator26(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; char const *__pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_removexattr_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 797, __pyx_L1_error) /* "src/handlers.pxi":800 * cdef int ret * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * await operations.removexattr(c.ino, name, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 800, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":801 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.removexattr(c.ino, name, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":802 * ctx = get_request_context(c.req) * try: * await operations.removexattr(c.ino, name, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_removexattr); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 802, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 802, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; __pyx_t_8 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_8 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 802, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[4] = {__pyx_t_7, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 3+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 802, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_9 = PyTuple_New(3+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 802, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_9); if (__pyx_t_7) { __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_cur_scope->__pyx_v_name); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_9, 2+__pyx_t_8, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 802, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 802, __pyx_L4_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(1, 802, __pyx_L4_error) } } /* "src/handlers.pxi":801 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.removexattr(c.ino, name, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":806 * ret = fuse_reply_err(c.req, e.errno) * else: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else:*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":803 * try: * await operations.removexattr(c.ino, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.fuse_removexattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9) < 0) __PYX_ERR(1, 803, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_9); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":804 * await operations.removexattr(c.ino, name, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, 0) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 804, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 804, __pyx_L16_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_8); } /* "src/handlers.pxi":803 * try: * await operations.removexattr(c.ino, name, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_15, &__pyx_t_16, &__pyx_t_17); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14) < 0)) __Pyx_ErrFetch(&__pyx_t_12, &__pyx_t_13, &__pyx_t_14); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __pyx_t_8 = __pyx_lineno; __pyx_t_10 = __pyx_clineno; __pyx_t_11 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_17); __Pyx_ExceptionReset(__pyx_t_15, __pyx_t_16, __pyx_t_17); } __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_ErrRestore(__pyx_t_12, __pyx_t_13, __pyx_t_14); __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_10; __pyx_filename = __pyx_t_11; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":801 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * await operations.removexattr(c.ino, name, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":808 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_18 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_18) { /* "src/handlers.pxi":809 * * if ret != 0: * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_removexattr_fuse_reply__fai, __pyx_t_5}; __pyx_t_9 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 809, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_6, __pyx_kp_u_fuse_removexattr_fuse_reply__fai, __pyx_t_5}; __pyx_t_9 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_10, 2+__pyx_t_10); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 809, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_10); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_removexattr_fuse_reply__fai); __Pyx_GIVEREF(__pyx_kp_u_fuse_removexattr_fuse_reply__fai); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_10, __pyx_kp_u_fuse_removexattr_fuse_reply__fai); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_10, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 809, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":808 * ret = fuse_reply_err(c.req, 0) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_removexattr(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":797 * save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) * * async def fuse_removexattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("fuse_removexattr_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":812 * * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ static void __pyx_f_7pyfuse3_fuse_access(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_ino, int __pyx_v_mask) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_access", 0); /* "src/handlers.pxi":813 * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.ino = ino */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 813, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":814 * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.ino = ino * c.flags = mask */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":815 * cdef _Container c = _Container() * c.req = req * c.ino = ino # <<<<<<<<<<<<<< * c.flags = mask * save_retval(fuse_access_async(c)) */ __pyx_v_c->ino = __pyx_v_ino; /* "src/handlers.pxi":816 * c.req = req * c.ino = ino * c.flags = mask # <<<<<<<<<<<<<< * save_retval(fuse_access_async(c)) * */ __pyx_v_c->flags = __pyx_v_mask; /* "src/handlers.pxi":817 * c.ino = ino * c.flags = mask * save_retval(fuse_access_async(c)) # <<<<<<<<<<<<<< * * async def fuse_access_async (_Container c): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_access_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, ((PyObject *)__pyx_v_c)) : __Pyx_PyObject_CallOneArg(__pyx_t_2, ((PyObject *)__pyx_v_c)); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 817, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":812 * * * cdef void fuse_access (fuse_req_t req, fuse_ino_t ino, int mask): # <<<<<<<<<<<<<< * cdef _Container c = _Container() * c.req = req */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_WriteUnraisable("pyfuse3.fuse_access", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_83generator27(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":819 * save_retval(fuse_access_async(c)) * * async def fuse_access_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef int mask = c.flags */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_82fuse_access_async(PyObject *__pyx_self, PyObject *__pyx_v_c); /*proto*/ static char __pyx_doc_7pyfuse3_81fuse_access_async[] = "fuse_access_async(_Container c)"; static PyMethodDef __pyx_mdef_7pyfuse3_82fuse_access_async = {"fuse_access_async", (PyCFunction)__pyx_pw_7pyfuse3_82fuse_access_async, METH_O, __pyx_doc_7pyfuse3_81fuse_access_async}; static PyObject *__pyx_pw_7pyfuse3_82fuse_access_async(PyObject *__pyx_self, PyObject *__pyx_v_c) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_access_async (wrapper)", 0); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 819, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_81fuse_access_async(__pyx_self, ((struct __pyx_obj_7pyfuse3__Container *)__pyx_v_c)); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_81fuse_access_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_access_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_27_fuse_access_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_27_fuse_access_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 819, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_83generator27, __pyx_codeobj__35, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_access_async, __pyx_n_s_fuse_access_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 819, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_access_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_83generator27(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_access_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 819, __pyx_L1_error) /* "src/handlers.pxi":821 * async def fuse_access_async (_Container c): * cdef int ret * cdef int mask = c.flags # <<<<<<<<<<<<<< * * ctx = get_request_context(c.req) */ __pyx_t_1 = __pyx_cur_scope->__pyx_v_c->flags; __pyx_cur_scope->__pyx_v_mask = __pyx_t_1; /* "src/handlers.pxi":823 * cdef int mask = c.flags * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * allowed = await operations.access(c.ino, mask, ctx) */ __pyx_t_2 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 823, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":824 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * allowed = await operations.access(c.ino, mask, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_5); /*try:*/ { /* "src/handlers.pxi":825 * ctx = get_request_context(c.req) * try: * allowed = await operations.access(c.ino, mask, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_access); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 825, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->ino); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 825, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_mask); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 825, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; __pyx_t_1 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); __pyx_t_1 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_t_7, __pyx_t_8, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 3+__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 825, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { PyObject *__pyx_temp[4] = {__pyx_t_9, __pyx_t_7, __pyx_t_8, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_1, 3+__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 825, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif { __pyx_t_10 = PyTuple_New(3+__pyx_t_1); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 825, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_10); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_10, 0+__pyx_t_1, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_10, 1+__pyx_t_1, __pyx_t_8); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_10, 2+__pyx_t_1, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_10, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 825, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_0 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_1 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_t_2 = __pyx_t_5; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_3 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_4); __pyx_t_5 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 825, __pyx_L4_error) __pyx_t_2 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_2); } else { __pyx_t_2 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_2) < 0) __PYX_ERR(1, 825, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_2); } __Pyx_GIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_v_allowed = __pyx_t_2; __pyx_t_2 = 0; /* "src/handlers.pxi":824 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * allowed = await operations.access(c.ino, mask, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":829 * ret = fuse_reply_err(c.req, e.errno) * else: * if allowed: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, 0) * else: */ /*else:*/ { __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_cur_scope->__pyx_v_allowed); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(1, 829, __pyx_L6_except_error) if (__pyx_t_11) { /* "src/handlers.pxi":830 * else: * if allowed: * ret = fuse_reply_err(c.req, 0) # <<<<<<<<<<<<<< * else: * ret = fuse_reply_err(c.req, EACCES) */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, 0); /* "src/handlers.pxi":829 * ret = fuse_reply_err(c.req, e.errno) * else: * if allowed: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, 0) * else: */ goto __pyx_L11; } /* "src/handlers.pxi":832 * ret = fuse_reply_err(c.req, 0) * else: * ret = fuse_reply_err(c.req, EACCES) # <<<<<<<<<<<<<< * * if ret != 0: */ /*else*/ { __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, EACCES); } __pyx_L11:; } __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":826 * try: * allowed = await operations.access(c.ino, mask, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_1 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_1) { __Pyx_AddTraceback("pyfuse3.fuse_access_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_2, &__pyx_t_6, &__pyx_t_10) < 0) __PYX_ERR(1, 826, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_10); __Pyx_INCREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_6); __pyx_cur_scope->__pyx_v_e = __pyx_t_6; /*try:*/ { /* "src/handlers.pxi":827 * allowed = await operations.access(c.ino, mask, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * if allowed: */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 827, __pyx_L17_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 827, __pyx_L17_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_1); } /* "src/handlers.pxi":826 * try: * allowed = await operations.access(c.ino, mask, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L18; } __pyx_L17_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_1 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_1; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L6_except_error; } __pyx_L18:; } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":824 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * allowed = await operations.access(c.ino, mask, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_5); __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); __pyx_L9_try_end:; } /* "src/handlers.pxi":834 * ret = fuse_reply_err(c.req, EACCES) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) * */ __pyx_t_11 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_11) { /* "src/handlers.pxi":835 * * if ret != 0: * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_log); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 835, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_error); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 835, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 835, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_12 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_access_fuse_reply__failed_w, __pyx_t_6}; __pyx_t_10 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 835, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_access_fuse_reply__failed_w, __pyx_t_6}; __pyx_t_10 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 835, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 835, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_access_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_access_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_12, __pyx_kp_u_fuse_access_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_12, __pyx_t_6); __pyx_t_6 = 0; __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 835, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "src/handlers.pxi":834 * ret = fuse_reply_err(c.req, EACCES) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_access(): fuse_reply_* failed with %s', strerror(-ret)) * */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":819 * save_retval(fuse_access_async(c)) * * async def fuse_access_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef int mask = c.flags */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("fuse_access_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/handlers.pxi":839 * * * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, fuse_file_info *fi): * cdef _Container c = _Container() */ static void __pyx_f_7pyfuse3_fuse_create(fuse_req_t __pyx_v_req, fuse_ino_t __pyx_v_parent, const char *__pyx_v_name, mode_t __pyx_v_mode, struct fuse_file_info *__pyx_v_fi) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_create", 0); /* "src/handlers.pxi":841 * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *name, * mode_t mode, fuse_file_info *fi): * cdef _Container c = _Container() # <<<<<<<<<<<<<< * c.req = req * c.parent = parent */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__Container)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 841, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":842 * mode_t mode, fuse_file_info *fi): * cdef _Container c = _Container() * c.req = req # <<<<<<<<<<<<<< * c.parent = parent * c.mode = mode */ __pyx_v_c->req = __pyx_v_req; /* "src/handlers.pxi":843 * cdef _Container c = _Container() * c.req = req * c.parent = parent # <<<<<<<<<<<<<< * c.mode = mode * c.fi = fi[0] */ __pyx_v_c->parent = __pyx_v_parent; /* "src/handlers.pxi":844 * c.req = req * c.parent = parent * c.mode = mode # <<<<<<<<<<<<<< * c.fi = fi[0] * save_retval(fuse_create_async(c, PyBytes_FromString(name))) */ __pyx_v_c->mode = __pyx_v_mode; /* "src/handlers.pxi":845 * c.parent = parent * c.mode = mode * c.fi = fi[0] # <<<<<<<<<<<<<< * save_retval(fuse_create_async(c, PyBytes_FromString(name))) * */ __pyx_v_c->fi = (__pyx_v_fi[0]); /* "src/handlers.pxi":846 * c.mode = mode * c.fi = fi[0] * save_retval(fuse_create_async(c, PyBytes_FromString(name))) # <<<<<<<<<<<<<< * * async def fuse_create_async (_Container c, name): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_fuse_create_async); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyBytes_FromString(__pyx_v_name); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 846, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, ((PyObject *)__pyx_v_c), __pyx_t_3}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 846, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_INCREF(((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(((PyObject *)__pyx_v_c)); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, ((PyObject *)__pyx_v_c)); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 846, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_f_7pyfuse3_save_retval(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":839 * * * cdef void fuse_create (fuse_req_t req, fuse_ino_t parent, const_char *name, # <<<<<<<<<<<<<< * mode_t mode, fuse_file_info *fi): * cdef _Container c = _Container() */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.fuse_create", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_c); __Pyx_RefNannyFinishContext(); } static PyObject *__pyx_gb_7pyfuse3_86generator28(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/handlers.pxi":848 * save_retval(fuse_create_async(c, PyBytes_FromString(name))) * * async def fuse_create_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_85fuse_create_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_84fuse_create_async[] = "fuse_create_async(_Container c, name)"; static PyMethodDef __pyx_mdef_7pyfuse3_85fuse_create_async = {"fuse_create_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_85fuse_create_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_84fuse_create_async}; static PyObject *__pyx_pw_7pyfuse3_85fuse_create_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3__Container *__pyx_v_c = 0; PyObject *__pyx_v_name = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_create_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_c,&__pyx_n_s_name,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_c)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("fuse_create_async", 1, 2, 2, 1); __PYX_ERR(1, 848, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "fuse_create_async") < 0)) __PYX_ERR(1, 848, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); } __pyx_v_c = ((struct __pyx_obj_7pyfuse3__Container *)values[0]); __pyx_v_name = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("fuse_create_async", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 848, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.fuse_create_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_c), __pyx_ptype_7pyfuse3__Container, 1, "c", 0))) __PYX_ERR(1, 848, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_84fuse_create_async(__pyx_self, __pyx_v_c, __pyx_v_name); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_84fuse_create_async(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3__Container *__pyx_v_c, PyObject *__pyx_v_name) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("fuse_create_async", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_28_fuse_create_async(__pyx_ptype_7pyfuse3___pyx_scope_struct_28_fuse_create_async, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(1, 848, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_c = __pyx_v_c; __Pyx_INCREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __Pyx_GIVEREF((PyObject *)__pyx_cur_scope->__pyx_v_c); __pyx_cur_scope->__pyx_v_name = __pyx_v_name; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_86generator28, __pyx_codeobj__36, (PyObject *) __pyx_cur_scope, __pyx_n_s_fuse_create_async, __pyx_n_s_fuse_create_async, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(1, 848, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.fuse_create_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_86generator28(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_t_10; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; char const *__pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fuse_create_async", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L10_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 848, __pyx_L1_error) /* "src/handlers.pxi":853 * cdef FileInfo fi * * ctx = get_request_context(c.req) # <<<<<<<<<<<<<< * try: * tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) */ __pyx_t_1 = __pyx_f_7pyfuse3_get_request_context(__pyx_cur_scope->__pyx_v_c->req); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 853, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_ctx = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":854 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) * except FUSEError as e: */ { __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_4); /*try:*/ { /* "src/handlers.pxi":855 * ctx = get_request_context(c.req) * try: * tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) # <<<<<<<<<<<<<< * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) */ __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3_operations, __pyx_n_s_create); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyInt_From_fuse_ino_t(__pyx_cur_scope->__pyx_v_c->parent); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyInt_From_mode_t(__pyx_cur_scope->__pyx_v_c->mode); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_c->fi.flags); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = NULL; __pyx_t_10 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); __pyx_t_10 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[6] = {__pyx_t_9, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_t_7, __pyx_t_8, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 5+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { PyObject *__pyx_temp[6] = {__pyx_t_9, __pyx_t_6, __pyx_cur_scope->__pyx_v_name, __pyx_t_7, __pyx_t_8, __pyx_cur_scope->__pyx_v_ctx}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_10, 5+__pyx_t_10); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } else #endif { __pyx_t_11 = PyTuple_New(5+__pyx_t_10); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_11); if (__pyx_t_9) { __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_9); __pyx_t_9 = NULL; } __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_11, 0+__pyx_t_10, __pyx_t_6); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_11, 1+__pyx_t_10, __pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_11, 2+__pyx_t_10, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_11, 3+__pyx_t_10, __pyx_t_8); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_ctx); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_ctx); PyTuple_SET_ITEM(__pyx_t_11, 4+__pyx_t_10, __pyx_cur_scope->__pyx_v_ctx); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_11, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_1 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_2 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L10_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(1, 855, __pyx_L4_error) __pyx_t_1 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_1); } else { __pyx_t_1 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_1) < 0) __PYX_ERR(1, 855, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); } __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_tmp = __pyx_t_1; __pyx_t_1 = 0; /* "src/handlers.pxi":854 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) * except FUSEError as e: */ } /* "src/handlers.pxi":859 * ret = fuse_reply_err(c.req, e.errno) * else: * fi = tmp[0] # <<<<<<<<<<<<<< * entry = tmp[1] * fi._copy_to_fuse(&c.fi) */ /*else:*/ { __pyx_t_1 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_tmp, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 859, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); if (!(likely(__Pyx_TypeTest(__pyx_t_1, __pyx_ptype_7pyfuse3_FileInfo)))) __PYX_ERR(1, 859, __pyx_L6_except_error) __pyx_t_5 = __pyx_t_1; __Pyx_INCREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_fi = ((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_t_5); __pyx_t_5 = 0; /* "src/handlers.pxi":860 * else: * fi = tmp[0] * entry = tmp[1] # <<<<<<<<<<<<<< * fi._copy_to_fuse(&c.fi) * ret = fuse_reply_create(c.req, &entry.fuse_param, &c.fi) */ __pyx_t_5 = __Pyx_GetItemInt(__pyx_cur_scope->__pyx_v_tmp, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 860, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_5); if (!(likely(__Pyx_TypeTest(__pyx_t_5, __pyx_ptype_7pyfuse3_EntryAttributes)))) __PYX_ERR(1, 860, __pyx_L6_except_error) __pyx_t_1 = __pyx_t_5; __Pyx_INCREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_v_entry = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":861 * fi = tmp[0] * entry = tmp[1] * fi._copy_to_fuse(&c.fi) # <<<<<<<<<<<<<< * ret = fuse_reply_create(c.req, &entry.fuse_param, &c.fi) * */ __pyx_t_1 = ((struct __pyx_vtabstruct_7pyfuse3_FileInfo *)__pyx_cur_scope->__pyx_v_fi->__pyx_vtab)->_copy_to_fuse(__pyx_cur_scope->__pyx_v_fi, (&__pyx_cur_scope->__pyx_v_c->fi)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 861, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/handlers.pxi":862 * entry = tmp[1] * fi._copy_to_fuse(&c.fi) * ret = fuse_reply_create(c.req, &entry.fuse_param, &c.fi) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_cur_scope->__pyx_v_ret = fuse_reply_create(__pyx_cur_scope->__pyx_v_c->req, (&__pyx_cur_scope->__pyx_v_entry->fuse_param), (&__pyx_cur_scope->__pyx_v_c->fi)); } __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L9_try_end; __pyx_L4_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; /* "src/handlers.pxi":856 * try: * tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ __pyx_t_10 = __Pyx_PyErr_ExceptionMatches(((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)); if (__pyx_t_10) { __Pyx_AddTraceback("pyfuse3.fuse_create_async", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_5, &__pyx_t_11) < 0) __PYX_ERR(1, 856, __pyx_L6_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_11); __Pyx_INCREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_v_e = __pyx_t_5; /*try:*/ { /* "src/handlers.pxi":857 * tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) * except FUSEError as e: * ret = fuse_reply_err(c.req, e.errno) # <<<<<<<<<<<<<< * else: * fi = tmp[0] */ __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_e, __pyx_n_s_errno); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 857, __pyx_L16_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_10 = __Pyx_PyInt_As_int(__pyx_t_8); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 857, __pyx_L16_error) __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_cur_scope->__pyx_v_ret = fuse_reply_err(__pyx_cur_scope->__pyx_v_c->req, __pyx_t_10); } /* "src/handlers.pxi":856 * try: * tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) * except FUSEError as e: # <<<<<<<<<<<<<< * ret = fuse_reply_err(c.req, e.errno) * else: */ /*finally:*/ { /*normal exit:*/{ __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; goto __pyx_L17; } __pyx_L16_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_17, &__pyx_t_18, &__pyx_t_19); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16) < 0)) __Pyx_ErrFetch(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_17); __Pyx_XGOTREF(__pyx_t_18); __Pyx_XGOTREF(__pyx_t_19); __pyx_t_10 = __pyx_lineno; __pyx_t_12 = __pyx_clineno; __pyx_t_13 = __pyx_filename; { __Pyx_GOTREF(__pyx_cur_scope->__pyx_v_e); __Pyx_DECREF(__pyx_cur_scope->__pyx_v_e); __pyx_cur_scope->__pyx_v_e = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_17); __Pyx_XGIVEREF(__pyx_t_18); __Pyx_XGIVEREF(__pyx_t_19); __Pyx_ExceptionReset(__pyx_t_17, __pyx_t_18, __pyx_t_19); } __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ErrRestore(__pyx_t_14, __pyx_t_15, __pyx_t_16); __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_17 = 0; __pyx_t_18 = 0; __pyx_t_19 = 0; __pyx_lineno = __pyx_t_10; __pyx_clineno = __pyx_t_12; __pyx_filename = __pyx_t_13; goto __pyx_L6_except_error; } __pyx_L17:; } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L5_exception_handled; } goto __pyx_L6_except_error; __pyx_L6_except_error:; /* "src/handlers.pxi":854 * * ctx = get_request_context(c.req) * try: # <<<<<<<<<<<<<< * tmp = await operations.create(c.parent, name, c.mode, c.fi.flags, ctx) * except FUSEError as e: */ __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); goto __pyx_L1_error; __pyx_L5_exception_handled:; __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); __pyx_L9_try_end:; } /* "src/handlers.pxi":864 * ret = fuse_reply_create(c.req, &entry.fuse_param, &c.fi) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) */ __pyx_t_20 = ((__pyx_cur_scope->__pyx_v_ret != 0) != 0); if (__pyx_t_20) { /* "src/handlers.pxi":865 * * if ret != 0: * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) # <<<<<<<<<<<<<< */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 865, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 865, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 865, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_8 = NULL; __pyx_t_12 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_12 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_create_fuse_reply__failed_w, __pyx_t_5}; __pyx_t_11 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 865, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_8, __pyx_kp_u_fuse_create_fuse_reply__failed_w, __pyx_t_5}; __pyx_t_11 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_12, 2+__pyx_t_12); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 865, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_7 = PyTuple_New(2+__pyx_t_12); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 865, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); if (__pyx_t_8) { __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8); __pyx_t_8 = NULL; } __Pyx_INCREF(__pyx_kp_u_fuse_create_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_kp_u_fuse_create_fuse_reply__failed_w); PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_12, __pyx_kp_u_fuse_create_fuse_reply__failed_w); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_12, __pyx_t_5); __pyx_t_5 = 0; __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_7, NULL); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 865, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; /* "src/handlers.pxi":864 * ret = fuse_reply_create(c.req, &entry.fuse_param, &c.fi) * * if ret != 0: # <<<<<<<<<<<<<< * log.error('fuse_create(): fuse_reply_* failed with %s', strerror(-ret)) */ } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/handlers.pxi":848 * save_retval(fuse_create_async(c, PyBytes_FromString(name))) * * async def fuse_create_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_XDECREF(__pyx_t_11); __Pyx_AddTraceback("fuse_create_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":13 * ''' * * cdef void save_retval(object val): # <<<<<<<<<<<<<< * global py_retval * if py_retval is not None and val is not None: */ static void __pyx_f_7pyfuse3_save_retval(PyObject *__pyx_v_val) { __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("save_retval", 0); /* "src/internal.pxi":15 * cdef void save_retval(object val): * global py_retval * if py_retval is not None and val is not None: # <<<<<<<<<<<<<< * log.error('py_retval was not awaited - please report a bug at ' * 'https://github.com/libfuse/pyfuse3/issues!') */ __pyx_t_2 = (__pyx_v_7pyfuse3_py_retval != Py_None); __pyx_t_3 = (__pyx_t_2 != 0); if (__pyx_t_3) { } else { __pyx_t_1 = __pyx_t_3; goto __pyx_L4_bool_binop_done; } __pyx_t_3 = (__pyx_v_val != Py_None); __pyx_t_2 = (__pyx_t_3 != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { /* "src/internal.pxi":16 * global py_retval * if py_retval is not None and val is not None: * log.error('py_retval was not awaited - please report a bug at ' # <<<<<<<<<<<<<< * 'https://github.com/libfuse/pyfuse3/issues!') * py_retval = val */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_log); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_5, __pyx_kp_u_py_retval_was_not_awaited_please) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_py_retval_was_not_awaited_please); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 16, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/internal.pxi":15 * cdef void save_retval(object val): * global py_retval * if py_retval is not None and val is not None: # <<<<<<<<<<<<<< * log.error('py_retval was not awaited - please report a bug at ' * 'https://github.com/libfuse/pyfuse3/issues!') */ } /* "src/internal.pxi":18 * log.error('py_retval was not awaited - please report a bug at ' * 'https://github.com/libfuse/pyfuse3/issues!') * py_retval = val # <<<<<<<<<<<<<< * * cdef object get_request_context(fuse_req_t req): */ __Pyx_INCREF(__pyx_v_val); __Pyx_XGOTREF(__pyx_v_7pyfuse3_py_retval); __Pyx_DECREF_SET(__pyx_v_7pyfuse3_py_retval, __pyx_v_val); __Pyx_GIVEREF(__pyx_v_val); /* "src/internal.pxi":13 * ''' * * cdef void save_retval(object val): # <<<<<<<<<<<<<< * global py_retval * if py_retval is not None and val is not None: */ /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_WriteUnraisable("pyfuse3.save_retval", __pyx_clineno, __pyx_lineno, __pyx_filename, 1, 0); __pyx_L0:; __Pyx_RefNannyFinishContext(); } /* "src/internal.pxi":20 * py_retval = val * * cdef object get_request_context(fuse_req_t req): # <<<<<<<<<<<<<< * '''Get RequestContext() object''' * */ static PyObject *__pyx_f_7pyfuse3_get_request_context(fuse_req_t __pyx_v_req) { const struct fuse_ctx *__pyx_v_context; struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_ctx = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; pid_t __pyx_t_2; uid_t __pyx_t_3; gid_t __pyx_t_4; mode_t __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_request_context", 0); /* "src/internal.pxi":26 * cdef RequestContext ctx * * context = fuse_req_ctx(req) # <<<<<<<<<<<<<< * ctx = RequestContext.__new__(RequestContext) * ctx.pid = context.pid */ __pyx_v_context = fuse_req_ctx(__pyx_v_req); /* "src/internal.pxi":27 * * context = fuse_req_ctx(req) * ctx = RequestContext.__new__(RequestContext) # <<<<<<<<<<<<<< * ctx.pid = context.pid * ctx.uid = context.uid */ __pyx_t_1 = ((PyObject *)__pyx_tp_new_7pyfuse3_RequestContext(((PyTypeObject *)__pyx_ptype_7pyfuse3_RequestContext), __pyx_empty_tuple, NULL)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 27, __pyx_L1_error) __Pyx_GOTREF(((PyObject *)__pyx_t_1)); __pyx_v_ctx = ((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":28 * context = fuse_req_ctx(req) * ctx = RequestContext.__new__(RequestContext) * ctx.pid = context.pid # <<<<<<<<<<<<<< * ctx.uid = context.uid * ctx.gid = context.gid */ __pyx_t_2 = __pyx_v_context->pid; __pyx_v_ctx->pid = __pyx_t_2; /* "src/internal.pxi":29 * ctx = RequestContext.__new__(RequestContext) * ctx.pid = context.pid * ctx.uid = context.uid # <<<<<<<<<<<<<< * ctx.gid = context.gid * ctx.umask = context.umask */ __pyx_t_3 = __pyx_v_context->uid; __pyx_v_ctx->uid = __pyx_t_3; /* "src/internal.pxi":30 * ctx.pid = context.pid * ctx.uid = context.uid * ctx.gid = context.gid # <<<<<<<<<<<<<< * ctx.umask = context.umask * */ __pyx_t_4 = __pyx_v_context->gid; __pyx_v_ctx->gid = __pyx_t_4; /* "src/internal.pxi":31 * ctx.uid = context.uid * ctx.gid = context.gid * ctx.umask = context.umask # <<<<<<<<<<<<<< * * return ctx */ __pyx_t_5 = __pyx_v_context->umask; __pyx_v_ctx->umask = __pyx_t_5; /* "src/internal.pxi":33 * ctx.umask = context.umask * * return ctx # <<<<<<<<<<<<<< * * cdef void init_fuse_ops(): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(((PyObject *)__pyx_v_ctx)); __pyx_r = ((PyObject *)__pyx_v_ctx); goto __pyx_L0; /* "src/internal.pxi":20 * py_retval = val * * cdef object get_request_context(fuse_req_t req): # <<<<<<<<<<<<<< * '''Get RequestContext() object''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.get_request_context", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_ctx); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":35 * return ctx * * cdef void init_fuse_ops(): # <<<<<<<<<<<<<< * '''Initialize fuse_lowlevel_ops structure''' * */ static void __pyx_f_7pyfuse3_init_fuse_ops(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("init_fuse_ops", 0); /* "src/internal.pxi":38 * '''Initialize fuse_lowlevel_ops structure''' * * string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) # <<<<<<<<<<<<<< * * fuse_ops.init = fuse_init */ (void)(memset((&__pyx_v_7pyfuse3_fuse_ops), 0, (sizeof(struct fuse_lowlevel_ops)))); /* "src/internal.pxi":40 * string.memset(&fuse_ops, 0, sizeof(fuse_lowlevel_ops)) * * fuse_ops.init = fuse_init # <<<<<<<<<<<<<< * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget */ __pyx_v_7pyfuse3_fuse_ops.init = __pyx_f_7pyfuse3_fuse_init; /* "src/internal.pxi":41 * * fuse_ops.init = fuse_init * fuse_ops.lookup = fuse_lookup # <<<<<<<<<<<<<< * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr */ __pyx_v_7pyfuse3_fuse_ops.lookup = __pyx_f_7pyfuse3_fuse_lookup; /* "src/internal.pxi":42 * fuse_ops.init = fuse_init * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget # <<<<<<<<<<<<<< * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr */ __pyx_v_7pyfuse3_fuse_ops.forget = __pyx_f_7pyfuse3_fuse_forget; /* "src/internal.pxi":43 * fuse_ops.lookup = fuse_lookup * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr # <<<<<<<<<<<<<< * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink */ __pyx_v_7pyfuse3_fuse_ops.getattr = __pyx_f_7pyfuse3_fuse_getattr; /* "src/internal.pxi":44 * fuse_ops.forget = fuse_forget * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr # <<<<<<<<<<<<<< * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod */ __pyx_v_7pyfuse3_fuse_ops.setattr = __pyx_f_7pyfuse3_fuse_setattr; /* "src/internal.pxi":45 * fuse_ops.getattr = fuse_getattr * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink # <<<<<<<<<<<<<< * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir */ __pyx_v_7pyfuse3_fuse_ops.readlink = __pyx_f_7pyfuse3_fuse_readlink; /* "src/internal.pxi":46 * fuse_ops.setattr = fuse_setattr * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod # <<<<<<<<<<<<<< * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink */ __pyx_v_7pyfuse3_fuse_ops.mknod = __pyx_f_7pyfuse3_fuse_mknod; /* "src/internal.pxi":47 * fuse_ops.readlink = fuse_readlink * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir # <<<<<<<<<<<<<< * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir */ __pyx_v_7pyfuse3_fuse_ops.mkdir = __pyx_f_7pyfuse3_fuse_mkdir; /* "src/internal.pxi":48 * fuse_ops.mknod = fuse_mknod * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink # <<<<<<<<<<<<<< * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink */ __pyx_v_7pyfuse3_fuse_ops.unlink = __pyx_f_7pyfuse3_fuse_unlink; /* "src/internal.pxi":49 * fuse_ops.mkdir = fuse_mkdir * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir # <<<<<<<<<<<<<< * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename */ __pyx_v_7pyfuse3_fuse_ops.rmdir = __pyx_f_7pyfuse3_fuse_rmdir; /* "src/internal.pxi":50 * fuse_ops.unlink = fuse_unlink * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink # <<<<<<<<<<<<<< * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link */ __pyx_v_7pyfuse3_fuse_ops.symlink = __pyx_f_7pyfuse3_fuse_symlink; /* "src/internal.pxi":51 * fuse_ops.rmdir = fuse_rmdir * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename # <<<<<<<<<<<<<< * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open */ __pyx_v_7pyfuse3_fuse_ops.rename = __pyx_f_7pyfuse3_fuse_rename; /* "src/internal.pxi":52 * fuse_ops.symlink = fuse_symlink * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link # <<<<<<<<<<<<<< * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read */ __pyx_v_7pyfuse3_fuse_ops.link = __pyx_f_7pyfuse3_fuse_link; /* "src/internal.pxi":53 * fuse_ops.rename = fuse_rename * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open # <<<<<<<<<<<<<< * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write */ __pyx_v_7pyfuse3_fuse_ops.open = __pyx_f_7pyfuse3_fuse_open; /* "src/internal.pxi":54 * fuse_ops.link = fuse_link * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read # <<<<<<<<<<<<<< * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush */ __pyx_v_7pyfuse3_fuse_ops.read = __pyx_f_7pyfuse3_fuse_read; /* "src/internal.pxi":55 * fuse_ops.open = fuse_open * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write # <<<<<<<<<<<<<< * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release */ __pyx_v_7pyfuse3_fuse_ops.write = __pyx_f_7pyfuse3_fuse_write; /* "src/internal.pxi":56 * fuse_ops.read = fuse_read * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush # <<<<<<<<<<<<<< * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync */ __pyx_v_7pyfuse3_fuse_ops.flush = __pyx_f_7pyfuse3_fuse_flush; /* "src/internal.pxi":57 * fuse_ops.write = fuse_write * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release # <<<<<<<<<<<<<< * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir */ __pyx_v_7pyfuse3_fuse_ops.release = __pyx_f_7pyfuse3_fuse_release; /* "src/internal.pxi":58 * fuse_ops.flush = fuse_flush * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync # <<<<<<<<<<<<<< * fuse_ops.opendir = fuse_opendir * fuse_ops.readdirplus = fuse_readdirplus */ __pyx_v_7pyfuse3_fuse_ops.fsync = __pyx_f_7pyfuse3_fuse_fsync; /* "src/internal.pxi":59 * fuse_ops.release = fuse_release * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir # <<<<<<<<<<<<<< * fuse_ops.readdirplus = fuse_readdirplus * fuse_ops.releasedir = fuse_releasedir */ __pyx_v_7pyfuse3_fuse_ops.opendir = __pyx_f_7pyfuse3_fuse_opendir; /* "src/internal.pxi":60 * fuse_ops.fsync = fuse_fsync * fuse_ops.opendir = fuse_opendir * fuse_ops.readdirplus = fuse_readdirplus # <<<<<<<<<<<<<< * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir */ __pyx_v_7pyfuse3_fuse_ops.readdirplus = __pyx_f_7pyfuse3_fuse_readdirplus; /* "src/internal.pxi":61 * fuse_ops.opendir = fuse_opendir * fuse_ops.readdirplus = fuse_readdirplus * fuse_ops.releasedir = fuse_releasedir # <<<<<<<<<<<<<< * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs */ __pyx_v_7pyfuse3_fuse_ops.releasedir = __pyx_f_7pyfuse3_fuse_releasedir; /* "src/internal.pxi":62 * fuse_ops.readdirplus = fuse_readdirplus * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir # <<<<<<<<<<<<<< * fuse_ops.statfs = fuse_statfs * ASSIGN_NOT_DARWIN(fuse_ops.setxattr, &fuse_setxattr) */ __pyx_v_7pyfuse3_fuse_ops.fsyncdir = __pyx_f_7pyfuse3_fuse_fsyncdir; /* "src/internal.pxi":63 * fuse_ops.releasedir = fuse_releasedir * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs # <<<<<<<<<<<<<< * ASSIGN_NOT_DARWIN(fuse_ops.setxattr, &fuse_setxattr) * ASSIGN_NOT_DARWIN(fuse_ops.getxattr, &fuse_getxattr) */ __pyx_v_7pyfuse3_fuse_ops.statfs = __pyx_f_7pyfuse3_fuse_statfs; /* "src/internal.pxi":64 * fuse_ops.fsyncdir = fuse_fsyncdir * fuse_ops.statfs = fuse_statfs * ASSIGN_NOT_DARWIN(fuse_ops.setxattr, &fuse_setxattr) # <<<<<<<<<<<<<< * ASSIGN_NOT_DARWIN(fuse_ops.getxattr, &fuse_getxattr) * fuse_ops.listxattr = fuse_listxattr */ ASSIGN_NOT_DARWIN(__pyx_v_7pyfuse3_fuse_ops.setxattr, (&__pyx_f_7pyfuse3_fuse_setxattr)); /* "src/internal.pxi":65 * fuse_ops.statfs = fuse_statfs * ASSIGN_NOT_DARWIN(fuse_ops.setxattr, &fuse_setxattr) * ASSIGN_NOT_DARWIN(fuse_ops.getxattr, &fuse_getxattr) # <<<<<<<<<<<<<< * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr */ ASSIGN_NOT_DARWIN(__pyx_v_7pyfuse3_fuse_ops.getxattr, (&__pyx_f_7pyfuse3_fuse_getxattr)); /* "src/internal.pxi":66 * ASSIGN_NOT_DARWIN(fuse_ops.setxattr, &fuse_setxattr) * ASSIGN_NOT_DARWIN(fuse_ops.getxattr, &fuse_getxattr) * fuse_ops.listxattr = fuse_listxattr # <<<<<<<<<<<<<< * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access */ __pyx_v_7pyfuse3_fuse_ops.listxattr = __pyx_f_7pyfuse3_fuse_listxattr; /* "src/internal.pxi":67 * ASSIGN_NOT_DARWIN(fuse_ops.getxattr, &fuse_getxattr) * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr # <<<<<<<<<<<<<< * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create */ __pyx_v_7pyfuse3_fuse_ops.removexattr = __pyx_f_7pyfuse3_fuse_removexattr; /* "src/internal.pxi":68 * fuse_ops.listxattr = fuse_listxattr * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access # <<<<<<<<<<<<<< * fuse_ops.create = fuse_create * fuse_ops.forget_multi = fuse_forget_multi */ __pyx_v_7pyfuse3_fuse_ops.access = __pyx_f_7pyfuse3_fuse_access; /* "src/internal.pxi":69 * fuse_ops.removexattr = fuse_removexattr * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create # <<<<<<<<<<<<<< * fuse_ops.forget_multi = fuse_forget_multi * fuse_ops.write_buf = fuse_write_buf */ __pyx_v_7pyfuse3_fuse_ops.create = __pyx_f_7pyfuse3_fuse_create; /* "src/internal.pxi":70 * fuse_ops.access = fuse_access * fuse_ops.create = fuse_create * fuse_ops.forget_multi = fuse_forget_multi # <<<<<<<<<<<<<< * fuse_ops.write_buf = fuse_write_buf * */ __pyx_v_7pyfuse3_fuse_ops.forget_multi = __pyx_f_7pyfuse3_fuse_forget_multi; /* "src/internal.pxi":71 * fuse_ops.create = fuse_create * fuse_ops.forget_multi = fuse_forget_multi * fuse_ops.write_buf = fuse_write_buf # <<<<<<<<<<<<<< * * cdef make_fuse_args(args, fuse_args* f_args): */ __pyx_v_7pyfuse3_fuse_ops.write_buf = __pyx_f_7pyfuse3_fuse_write_buf; /* "src/internal.pxi":35 * return ctx * * cdef void init_fuse_ops(): # <<<<<<<<<<<<<< * '''Initialize fuse_lowlevel_ops structure''' * */ /* function exit code */ __Pyx_RefNannyFinishContext(); } /* "src/internal.pxi":73 * fuse_ops.write_buf = fuse_write_buf * * cdef make_fuse_args(args, fuse_args* f_args): # <<<<<<<<<<<<<< * cdef char* arg * cdef int i */ static PyObject *__pyx_f_7pyfuse3_make_fuse_args(PyObject *__pyx_v_args, struct fuse_args *__pyx_v_f_args) { char *__pyx_v_arg; int __pyx_v_i; Py_ssize_t __pyx_v_size_s; size_t __pyx_v_size; PyObject *__pyx_v_args_new = NULL; PyObject *__pyx_v_el = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *(*__pyx_t_3)(PyObject *); PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; int __pyx_t_15; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("make_fuse_args", 0); __Pyx_INCREF(__pyx_v_args); /* "src/internal.pxi":79 * cdef size_t size * * args_new = [ b'pyfuse3' ] # <<<<<<<<<<<<<< * for el in args: * args_new.append(b'-o') */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 79, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_b_pyfuse3); __Pyx_GIVEREF(__pyx_n_b_pyfuse3); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_b_pyfuse3); __pyx_v_args_new = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":80 * * args_new = [ b'pyfuse3' ] * for el in args: # <<<<<<<<<<<<<< * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) */ if (likely(PyList_CheckExact(__pyx_v_args)) || PyTuple_CheckExact(__pyx_v_args)) { __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = NULL; } else { __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 80, __pyx_L1_error) } for (;;) { if (likely(!__pyx_t_3)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 80, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 80, __pyx_L1_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 80, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); #endif } } else { __pyx_t_4 = __pyx_t_3(__pyx_t_1); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(2, 80, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_4); } __Pyx_XDECREF_SET(__pyx_v_el, __pyx_t_4); __pyx_t_4 = 0; /* "src/internal.pxi":81 * args_new = [ b'pyfuse3' ] * for el in args: * args_new.append(b'-o') # <<<<<<<<<<<<<< * args_new.append(el.encode('us-ascii')) * args = args_new */ __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_args_new, __pyx_kp_b_o); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 81, __pyx_L1_error) /* "src/internal.pxi":82 * for el in args: * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) # <<<<<<<<<<<<<< * args = args_new * */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_el, __pyx_n_s_encode); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_kp_u_us_ascii) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_kp_u_us_ascii); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_5 = __Pyx_PyList_Append(__pyx_v_args_new, __pyx_t_4); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(2, 82, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "src/internal.pxi":80 * * args_new = [ b'pyfuse3' ] * for el in args: # <<<<<<<<<<<<<< * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":83 * args_new.append(b'-o') * args_new.append(el.encode('us-ascii')) * args = args_new # <<<<<<<<<<<<<< * * f_args.argc = len(args) */ __Pyx_INCREF(__pyx_v_args_new); __Pyx_DECREF_SET(__pyx_v_args, __pyx_v_args_new); /* "src/internal.pxi":85 * args = args_new * * f_args.argc = len(args) # <<<<<<<<<<<<<< * if f_args.argc == 0: * f_args.argv = NULL */ __pyx_t_2 = PyObject_Length(__pyx_v_args); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(2, 85, __pyx_L1_error) __pyx_v_f_args->argc = ((int)__pyx_t_2); /* "src/internal.pxi":86 * * f_args.argc = len(args) * if f_args.argc == 0: # <<<<<<<<<<<<<< * f_args.argv = NULL * return */ __pyx_t_8 = ((__pyx_v_f_args->argc == 0) != 0); if (__pyx_t_8) { /* "src/internal.pxi":87 * f_args.argc = len(args) * if f_args.argc == 0: * f_args.argv = NULL # <<<<<<<<<<<<<< * return * */ __pyx_v_f_args->argv = NULL; /* "src/internal.pxi":88 * if f_args.argc == 0: * f_args.argv = NULL * return # <<<<<<<<<<<<<< * * f_args.allocated = 1 */ __Pyx_XDECREF(__pyx_r); __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; /* "src/internal.pxi":86 * * f_args.argc = len(args) * if f_args.argc == 0: # <<<<<<<<<<<<<< * f_args.argv = NULL * return */ } /* "src/internal.pxi":90 * return * * f_args.allocated = 1 # <<<<<<<<<<<<<< * f_args.argv = stdlib.calloc( f_args.argc, sizeof(char*)) * */ __pyx_v_f_args->allocated = 1; /* "src/internal.pxi":91 * * f_args.allocated = 1 * f_args.argv = stdlib.calloc( f_args.argc, sizeof(char*)) # <<<<<<<<<<<<<< * * if f_args.argv is NULL: */ __pyx_v_f_args->argv = ((char **)calloc(((size_t)__pyx_v_f_args->argc), (sizeof(char *)))); /* "src/internal.pxi":93 * f_args.argv = stdlib.calloc( f_args.argc, sizeof(char*)) * * if f_args.argv is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_8 = ((__pyx_v_f_args->argv == NULL) != 0); if (__pyx_t_8) { /* "src/internal.pxi":94 * * if f_args.argv is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * try: */ __pyx_t_9 = PyErr_NoMemory(); if (unlikely(__pyx_t_9 == ((PyObject *)NULL))) __PYX_ERR(2, 94, __pyx_L1_error) /* "src/internal.pxi":93 * f_args.argv = stdlib.calloc( f_args.argc, sizeof(char*)) * * if f_args.argv is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ } /* "src/internal.pxi":96 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size_s) */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); /*try:*/ { /* "src/internal.pxi":97 * * try: * for (i, el) in enumerate(args): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(el, &arg, &size_s) * size = size_s # guaranteed positive */ __pyx_t_13 = 0; if (likely(PyList_CheckExact(__pyx_v_args)) || PyTuple_CheckExact(__pyx_v_args)) { __pyx_t_1 = __pyx_v_args; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; __pyx_t_3 = NULL; } else { __pyx_t_2 = -1; __pyx_t_1 = PyObject_GetIter(__pyx_v_args); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 97, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = Py_TYPE(__pyx_t_1)->tp_iternext; if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 97, __pyx_L7_error) } for (;;) { if (likely(!__pyx_t_3)) { if (likely(PyList_CheckExact(__pyx_t_1))) { if (__pyx_t_2 >= PyList_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyList_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 97, __pyx_L7_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 97, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_4); #endif } else { if (__pyx_t_2 >= PyTuple_GET_SIZE(__pyx_t_1)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_4 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_4); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(2, 97, __pyx_L7_error) #else __pyx_t_4 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 97, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_4); #endif } } else { __pyx_t_4 = __pyx_t_3(__pyx_t_1); if (unlikely(!__pyx_t_4)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(2, 97, __pyx_L7_error) } break; } __Pyx_GOTREF(__pyx_t_4); } __Pyx_XDECREF_SET(__pyx_v_el, __pyx_t_4); __pyx_t_4 = 0; __pyx_v_i = __pyx_t_13; __pyx_t_13 = (__pyx_t_13 + 1); /* "src/internal.pxi":98 * try: * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size_s) # <<<<<<<<<<<<<< * size = size_s # guaranteed positive * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) */ __pyx_t_14 = PyBytes_AsStringAndSize(__pyx_v_el, (&__pyx_v_arg), ((Py_ssize_t *)(&__pyx_v_size_s))); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(2, 98, __pyx_L7_error) /* "src/internal.pxi":99 * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size_s) * size = size_s # guaranteed positive # <<<<<<<<<<<<<< * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * */ __pyx_v_size = ((size_t)__pyx_v_size_s); /* "src/internal.pxi":100 * PyBytes_AsStringAndSize(el, &arg, &size_s) * size = size_s # guaranteed positive * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) # <<<<<<<<<<<<<< * * if f_args.argv[i] is NULL: */ (__pyx_v_f_args->argv[__pyx_v_i]) = ((char *)malloc(((__pyx_v_size + 1) * (sizeof(char))))); /* "src/internal.pxi":102 * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * * if f_args.argv[i] is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_8 = (((__pyx_v_f_args->argv[__pyx_v_i]) == NULL) != 0); if (__pyx_t_8) { /* "src/internal.pxi":103 * * if f_args.argv[i] is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * string.strncpy(f_args.argv[i], arg, size+1) */ __pyx_t_9 = PyErr_NoMemory(); if (unlikely(__pyx_t_9 == ((PyObject *)NULL))) __PYX_ERR(2, 103, __pyx_L7_error) /* "src/internal.pxi":102 * f_args.argv[i] = stdlib.malloc((size+1)*sizeof(char)) * * if f_args.argv[i] is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ } /* "src/internal.pxi":105 * cpython.exc.PyErr_NoMemory() * * string.strncpy(f_args.argv[i], arg, size+1) # <<<<<<<<<<<<<< * except: * for i in range(f_args.argc): */ (void)(strncpy((__pyx_v_f_args->argv[__pyx_v_i]), __pyx_v_arg, (__pyx_v_size + 1))); /* "src/internal.pxi":97 * * try: * for (i, el) in enumerate(args): # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(el, &arg, &size_s) * size = size_s # guaranteed positive */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":96 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size_s) */ } __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; goto __pyx_L12_try_end; __pyx_L7_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/internal.pxi":106 * * string.strncpy(f_args.argv[i], arg, size+1) * except: # <<<<<<<<<<<<<< * for i in range(f_args.argc): * # Freeing a NULL pointer (if this element has not been allocated */ /*except:*/ { __Pyx_AddTraceback("pyfuse3.make_fuse_args", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_1, &__pyx_t_4, &__pyx_t_6) < 0) __PYX_ERR(2, 106, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); /* "src/internal.pxi":107 * string.strncpy(f_args.argv[i], arg, size+1) * except: * for i in range(f_args.argc): # <<<<<<<<<<<<<< * # Freeing a NULL pointer (if this element has not been allocated * # yet) is fine. */ __pyx_t_13 = __pyx_v_f_args->argc; __pyx_t_14 = __pyx_t_13; for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { __pyx_v_i = __pyx_t_15; /* "src/internal.pxi":110 * # Freeing a NULL pointer (if this element has not been allocated * # yet) is fine. * stdlib.free(f_args.argv[i]) # <<<<<<<<<<<<<< * stdlib.free(f_args.argv) * raise */ free((__pyx_v_f_args->argv[__pyx_v_i])); } /* "src/internal.pxi":111 * # yet) is fine. * stdlib.free(f_args.argv[i]) * stdlib.free(f_args.argv) # <<<<<<<<<<<<<< * raise * */ free(__pyx_v_f_args->argv); /* "src/internal.pxi":112 * stdlib.free(f_args.argv[i]) * stdlib.free(f_args.argv) * raise # <<<<<<<<<<<<<< * * def _notify_loop(): */ __Pyx_GIVEREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ErrRestoreWithState(__pyx_t_1, __pyx_t_4, __pyx_t_6); __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_6 = 0; __PYX_ERR(2, 112, __pyx_L9_except_error) } __pyx_L9_except_error:; /* "src/internal.pxi":96 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * for (i, el) in enumerate(args): * PyBytes_AsStringAndSize(el, &arg, &size_s) */ __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); goto __pyx_L1_error; __pyx_L12_try_end:; } /* "src/internal.pxi":73 * fuse_ops.write_buf = fuse_write_buf * * cdef make_fuse_args(args, fuse_args* f_args): # <<<<<<<<<<<<<< * cdef char* arg * cdef int i */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("pyfuse3.make_fuse_args", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_args_new); __Pyx_XDECREF(__pyx_v_el); __Pyx_XDECREF(__pyx_v_args); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":114 * raise * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Process async invalidate_entry calls.''' * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_88_notify_loop(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_87_notify_loop[] = "_notify_loop()\nProcess async invalidate_entry calls."; static PyMethodDef __pyx_mdef_7pyfuse3_88_notify_loop = {"_notify_loop", (PyCFunction)__pyx_pw_7pyfuse3_88_notify_loop, METH_NOARGS, __pyx_doc_7pyfuse3_87_notify_loop}; static PyObject *__pyx_pw_7pyfuse3_88_notify_loop(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_notify_loop (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_87_notify_loop(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_87_notify_loop(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_v_req = NULL; PyObject *__pyx_v_inode_p = NULL; PyObject *__pyx_v_name = NULL; PyObject *__pyx_v_deleted = NULL; PyObject *__pyx_v_ignore_enoent = NULL; PyObject *__pyx_v_exc = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *(*__pyx_t_8)(PyObject *); PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; int __pyx_t_13; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; int __pyx_t_18; char const *__pyx_t_19; PyObject *__pyx_t_20 = NULL; PyObject *__pyx_t_21 = NULL; PyObject *__pyx_t_22 = NULL; PyObject *__pyx_t_23 = NULL; PyObject *__pyx_t_24 = NULL; PyObject *__pyx_t_25 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_notify_loop", 0); /* "src/internal.pxi":117 * '''Process async invalidate_entry calls.''' * * while True: # <<<<<<<<<<<<<< * req = _notify_queue.get() * if req is None: */ while (1) { /* "src/internal.pxi":118 * * while True: * req = _notify_queue.get() # <<<<<<<<<<<<<< * if req is None: * log.debug('terminating notify thread') */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3__notify_queue, __pyx_n_s_get); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 118, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF_SET(__pyx_v_req, __pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":119 * while True: * req = _notify_queue.get() * if req is None: # <<<<<<<<<<<<<< * log.debug('terminating notify thread') * break */ __pyx_t_4 = (__pyx_v_req == Py_None); __pyx_t_5 = (__pyx_t_4 != 0); if (__pyx_t_5) { /* "src/internal.pxi":120 * req = _notify_queue.get() * if req is None: * log.debug('terminating notify thread') # <<<<<<<<<<<<<< * break * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_log); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_kp_u_terminating_notify_thread) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_terminating_notify_thread); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 120, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":121 * if req is None: * log.debug('terminating notify thread') * break # <<<<<<<<<<<<<< * * (inode_p, name, deleted, ignore_enoent) = req */ goto __pyx_L4_break; /* "src/internal.pxi":119 * while True: * req = _notify_queue.get() * if req is None: # <<<<<<<<<<<<<< * log.debug('terminating notify thread') * break */ } /* "src/internal.pxi":123 * break * * (inode_p, name, deleted, ignore_enoent) = req # <<<<<<<<<<<<<< * try: * invalidate_entry(inode_p, name, deleted) */ if ((likely(PyTuple_CheckExact(__pyx_v_req))) || (PyList_CheckExact(__pyx_v_req))) { PyObject* sequence = __pyx_v_req; Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); if (unlikely(size != 4)) { if (size > 4) __Pyx_RaiseTooManyValuesError(4); else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); __PYX_ERR(2, 123, __pyx_L1_error) } #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS if (likely(PyTuple_CheckExact(sequence))) { __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); __pyx_t_2 = PyTuple_GET_ITEM(sequence, 2); __pyx_t_6 = PyTuple_GET_ITEM(sequence, 3); } else { __pyx_t_1 = PyList_GET_ITEM(sequence, 0); __pyx_t_3 = PyList_GET_ITEM(sequence, 1); __pyx_t_2 = PyList_GET_ITEM(sequence, 2); __pyx_t_6 = PyList_GET_ITEM(sequence, 3); } __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_6); #else { Py_ssize_t i; PyObject** temps[4] = {&__pyx_t_1,&__pyx_t_3,&__pyx_t_2,&__pyx_t_6}; for (i=0; i < 4; i++) { PyObject* item = PySequence_ITEM(sequence, i); if (unlikely(!item)) __PYX_ERR(2, 123, __pyx_L1_error) __Pyx_GOTREF(item); *(temps[i]) = item; } } #endif } else { Py_ssize_t index = -1; PyObject** temps[4] = {&__pyx_t_1,&__pyx_t_3,&__pyx_t_2,&__pyx_t_6}; __pyx_t_7 = PyObject_GetIter(__pyx_v_req); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 123, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = Py_TYPE(__pyx_t_7)->tp_iternext; for (index=0; index < 4; index++) { PyObject* item = __pyx_t_8(__pyx_t_7); if (unlikely(!item)) goto __pyx_L6_unpacking_failed; __Pyx_GOTREF(item); *(temps[index]) = item; } if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 4) < 0) __PYX_ERR(2, 123, __pyx_L1_error) __pyx_t_8 = NULL; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L7_unpacking_done; __pyx_L6_unpacking_failed:; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_8 = NULL; if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); __PYX_ERR(2, 123, __pyx_L1_error) __pyx_L7_unpacking_done:; } __Pyx_XDECREF_SET(__pyx_v_inode_p, __pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF_SET(__pyx_v_deleted, __pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF_SET(__pyx_v_ignore_enoent, __pyx_t_6); __pyx_t_6 = 0; /* "src/internal.pxi":124 * * (inode_p, name, deleted, ignore_enoent) = req * try: # <<<<<<<<<<<<<< * invalidate_entry(inode_p, name, deleted) * except Exception as exc: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_9, &__pyx_t_10, &__pyx_t_11); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); /*try:*/ { /* "src/internal.pxi":125 * (inode_p, name, deleted, ignore_enoent) = req * try: * invalidate_entry(inode_p, name, deleted) # <<<<<<<<<<<<<< * except Exception as exc: * if ignore_enoent and isinstance(exc, FileNotFoundError): */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_invalidate_entry); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 125, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; __pyx_t_12 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_12 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_inode_p, __pyx_v_name, __pyx_v_deleted}; __pyx_t_6 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 125, __pyx_L8_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[4] = {__pyx_t_3, __pyx_v_inode_p, __pyx_v_name, __pyx_v_deleted}; __pyx_t_6 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 125, __pyx_L8_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_6); } else #endif { __pyx_t_1 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 125, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_1); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_v_inode_p); __Pyx_GIVEREF(__pyx_v_inode_p); PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_12, __pyx_v_inode_p); __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_12, __pyx_v_name); __Pyx_INCREF(__pyx_v_deleted); __Pyx_GIVEREF(__pyx_v_deleted); PyTuple_SET_ITEM(__pyx_t_1, 2+__pyx_t_12, __pyx_v_deleted); __pyx_t_6 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 125, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; /* "src/internal.pxi":124 * * (inode_p, name, deleted, ignore_enoent) = req * try: # <<<<<<<<<<<<<< * invalidate_entry(inode_p, name, deleted) * except Exception as exc: */ } __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; goto __pyx_L15_try_end; __pyx_L8_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/internal.pxi":126 * try: * invalidate_entry(inode_p, name, deleted) * except Exception as exc: # <<<<<<<<<<<<<< * if ignore_enoent and isinstance(exc, FileNotFoundError): * pass */ __pyx_t_12 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(&((PyTypeObject*)PyExc_Exception)[0]))); if (__pyx_t_12) { __Pyx_AddTraceback("pyfuse3._notify_loop", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_6, &__pyx_t_2, &__pyx_t_1) < 0) __PYX_ERR(2, 126, __pyx_L10_except_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_2); __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_2); __pyx_v_exc = __pyx_t_2; /*try:*/ { /* "src/internal.pxi":127 * invalidate_entry(inode_p, name, deleted) * except Exception as exc: * if ignore_enoent and isinstance(exc, FileNotFoundError): # <<<<<<<<<<<<<< * pass * else: */ __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_ignore_enoent); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 127, __pyx_L21_error) if (__pyx_t_4) { } else { __pyx_t_5 = __pyx_t_4; goto __pyx_L24_bool_binop_done; } __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_FileNotFoundError); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 127, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyObject_IsInstance(__pyx_v_exc, __pyx_t_3); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 127, __pyx_L21_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_13 = (__pyx_t_4 != 0); __pyx_t_5 = __pyx_t_13; __pyx_L24_bool_binop_done:; if (__pyx_t_5) { goto __pyx_L23; } /* "src/internal.pxi":130 * pass * else: * log.exception('Failed to submit invalidate_entry request for ' # <<<<<<<<<<<<<< * 'parent inode %d, name %s', req[0], req[1]) * */ /*else*/ { __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_log); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 130, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_14 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_exception); if (unlikely(!__pyx_t_14)) __PYX_ERR(2, 130, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_14); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/internal.pxi":131 * else: * log.exception('Failed to submit invalidate_entry request for ' * 'parent inode %d, name %s', req[0], req[1]) # <<<<<<<<<<<<<< * * cdef str2bytes(s): */ __pyx_t_7 = __Pyx_GetItemInt(__pyx_v_req, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 131, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_15 = __Pyx_GetItemInt(__pyx_v_req, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_15)) __PYX_ERR(2, 131, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_15); __pyx_t_16 = NULL; __pyx_t_12 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_14))) { __pyx_t_16 = PyMethod_GET_SELF(__pyx_t_14); if (likely(__pyx_t_16)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_14); __Pyx_INCREF(__pyx_t_16); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_14, function); __pyx_t_12 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_14)) { PyObject *__pyx_temp[4] = {__pyx_t_16, __pyx_kp_u_Failed_to_submit_invalidate_entr, __pyx_t_7, __pyx_t_15}; __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 130, __pyx_L21_error) __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_14)) { PyObject *__pyx_temp[4] = {__pyx_t_16, __pyx_kp_u_Failed_to_submit_invalidate_entr, __pyx_t_7, __pyx_t_15}; __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_14, __pyx_temp+1-__pyx_t_12, 3+__pyx_t_12); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 130, __pyx_L21_error) __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; } else #endif { __pyx_t_17 = PyTuple_New(3+__pyx_t_12); if (unlikely(!__pyx_t_17)) __PYX_ERR(2, 130, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_17); if (__pyx_t_16) { __Pyx_GIVEREF(__pyx_t_16); PyTuple_SET_ITEM(__pyx_t_17, 0, __pyx_t_16); __pyx_t_16 = NULL; } __Pyx_INCREF(__pyx_kp_u_Failed_to_submit_invalidate_entr); __Pyx_GIVEREF(__pyx_kp_u_Failed_to_submit_invalidate_entr); PyTuple_SET_ITEM(__pyx_t_17, 0+__pyx_t_12, __pyx_kp_u_Failed_to_submit_invalidate_entr); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_17, 1+__pyx_t_12, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_15); PyTuple_SET_ITEM(__pyx_t_17, 2+__pyx_t_12, __pyx_t_15); __pyx_t_7 = 0; __pyx_t_15 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_14, __pyx_t_17, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 130, __pyx_L21_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; } __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } __pyx_L23:; } /* "src/internal.pxi":126 * try: * invalidate_entry(inode_p, name, deleted) * except Exception as exc: # <<<<<<<<<<<<<< * if ignore_enoent and isinstance(exc, FileNotFoundError): * pass */ /*finally:*/ { /*normal exit:*/{ __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = NULL; goto __pyx_L22; } __pyx_L21_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __Pyx_XDECREF(__pyx_t_14); __pyx_t_14 = 0; __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_16); __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_23, &__pyx_t_24, &__pyx_t_25); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22) < 0)) __Pyx_ErrFetch(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); __Pyx_XGOTREF(__pyx_t_20); __Pyx_XGOTREF(__pyx_t_21); __Pyx_XGOTREF(__pyx_t_22); __Pyx_XGOTREF(__pyx_t_23); __Pyx_XGOTREF(__pyx_t_24); __Pyx_XGOTREF(__pyx_t_25); __pyx_t_12 = __pyx_lineno; __pyx_t_18 = __pyx_clineno; __pyx_t_19 = __pyx_filename; { __Pyx_DECREF(__pyx_v_exc); __pyx_v_exc = NULL; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_23); __Pyx_XGIVEREF(__pyx_t_24); __Pyx_XGIVEREF(__pyx_t_25); __Pyx_ExceptionReset(__pyx_t_23, __pyx_t_24, __pyx_t_25); } __Pyx_XGIVEREF(__pyx_t_20); __Pyx_XGIVEREF(__pyx_t_21); __Pyx_XGIVEREF(__pyx_t_22); __Pyx_ErrRestore(__pyx_t_20, __pyx_t_21, __pyx_t_22); __pyx_t_20 = 0; __pyx_t_21 = 0; __pyx_t_22 = 0; __pyx_t_23 = 0; __pyx_t_24 = 0; __pyx_t_25 = 0; __pyx_lineno = __pyx_t_12; __pyx_clineno = __pyx_t_18; __pyx_filename = __pyx_t_19; goto __pyx_L10_except_error; } __pyx_L22:; } __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; goto __pyx_L9_exception_handled; } goto __pyx_L10_except_error; __pyx_L10_except_error:; /* "src/internal.pxi":124 * * (inode_p, name, deleted, ignore_enoent) = req * try: # <<<<<<<<<<<<<< * invalidate_entry(inode_p, name, deleted) * except Exception as exc: */ __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); goto __pyx_L1_error; __pyx_L9_exception_handled:; __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_ExceptionReset(__pyx_t_9, __pyx_t_10, __pyx_t_11); __pyx_L15_try_end:; } } __pyx_L4_break:; /* "src/internal.pxi":114 * raise * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Process async invalidate_entry calls.''' * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_14); __Pyx_XDECREF(__pyx_t_15); __Pyx_XDECREF(__pyx_t_16); __Pyx_XDECREF(__pyx_t_17); __Pyx_AddTraceback("pyfuse3._notify_loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_req); __Pyx_XDECREF(__pyx_v_inode_p); __Pyx_XDECREF(__pyx_v_name); __Pyx_XDECREF(__pyx_v_deleted); __Pyx_XDECREF(__pyx_v_ignore_enoent); __Pyx_XDECREF(__pyx_v_exc); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":133 * 'parent inode %d, name %s', req[0], req[1]) * * cdef str2bytes(s): # <<<<<<<<<<<<<< * '''Convert *s* to bytes''' * */ static PyObject *__pyx_f_7pyfuse3_str2bytes(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("str2bytes", 0); /* "src/internal.pxi":136 * '''Convert *s* to bytes''' * * return s.encode(fse, 'surrogateescape') # <<<<<<<<<<<<<< * * cdef bytes2str(s): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_encode); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fse); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_n_u_surrogateescape}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 136, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_n_u_surrogateescape}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 136, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_n_u_surrogateescape); __Pyx_GIVEREF(__pyx_n_u_surrogateescape); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_n_u_surrogateescape); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/internal.pxi":133 * 'parent inode %d, name %s', req[0], req[1]) * * cdef str2bytes(s): # <<<<<<<<<<<<<< * '''Convert *s* to bytes''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pyfuse3.str2bytes", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":138 * return s.encode(fse, 'surrogateescape') * * cdef bytes2str(s): # <<<<<<<<<<<<<< * '''Convert *s* to str''' * */ static PyObject *__pyx_f_7pyfuse3_bytes2str(PyObject *__pyx_v_s) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("bytes2str", 0); /* "src/internal.pxi":141 * '''Convert *s* to str''' * * return s.decode(fse, 'surrogateescape') # <<<<<<<<<<<<<< * * cdef strerror(int errno): */ __Pyx_XDECREF(__pyx_r); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_s, __pyx_n_s_decode); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_fse); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); __pyx_t_5 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_n_u_surrogateescape}; __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 141, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_n_u_surrogateescape}; __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_5, 2+__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 141, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_6 = PyTuple_New(2+__pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); if (__pyx_t_4) { __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_4); __pyx_t_4 = NULL; } __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0+__pyx_t_5, __pyx_t_3); __Pyx_INCREF(__pyx_n_u_surrogateescape); __Pyx_GIVEREF(__pyx_n_u_surrogateescape); PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_n_u_surrogateescape); __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 141, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "src/internal.pxi":138 * return s.encode(fse, 'surrogateescape') * * cdef bytes2str(s): # <<<<<<<<<<<<<< * '''Convert *s* to str''' * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pyfuse3.bytes2str", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":143 * return s.decode(fse, 'surrogateescape') * * cdef strerror(int errno): # <<<<<<<<<<<<<< * try: * return os.strerror(errno) */ static PyObject *__pyx_f_7pyfuse3_strerror(int __pyx_v_errno) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("strerror", 0); /* "src/internal.pxi":144 * * cdef strerror(int errno): * try: # <<<<<<<<<<<<<< * return os.strerror(errno) * except ValueError: */ { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/internal.pxi":145 * cdef strerror(int errno): * try: * return os.strerror(errno) # <<<<<<<<<<<<<< * except ValueError: * return 'errno: %d' % errno */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_os); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 145, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_strerror); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 145, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_errno); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 145, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_4 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_7, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_5); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 145, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L7_try_return; /* "src/internal.pxi":144 * * cdef strerror(int errno): * try: # <<<<<<<<<<<<<< * return os.strerror(errno) * except ValueError: */ } __pyx_L3_error:; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/internal.pxi":146 * try: * return os.strerror(errno) * except ValueError: # <<<<<<<<<<<<<< * return 'errno: %d' % errno * */ __pyx_t_8 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_ValueError); if (__pyx_t_8) { __Pyx_AddTraceback("pyfuse3.strerror", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_5) < 0) __PYX_ERR(2, 146, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_5); /* "src/internal.pxi":147 * return os.strerror(errno) * except ValueError: * return 'errno: %d' % errno # <<<<<<<<<<<<<< * * cdef PyBytes_from_bufvec(fuse_bufvec *src): */ __Pyx_XDECREF(__pyx_r); __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 147, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = PyUnicode_Format(__pyx_kp_u_errno_d, __pyx_t_7); if (unlikely(!__pyx_t_9)) __PYX_ERR(2, 147, __pyx_L5_except_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_r = __pyx_t_9; __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L6_except_return; } goto __pyx_L5_except_error; __pyx_L5_except_error:; /* "src/internal.pxi":144 * * cdef strerror(int errno): * try: # <<<<<<<<<<<<<< * return os.strerror(errno) * except ValueError: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L1_error; __pyx_L7_try_return:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L0; __pyx_L6_except_return:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L0; } /* "src/internal.pxi":143 * return s.decode(fse, 'surrogateescape') * * cdef strerror(int errno): # <<<<<<<<<<<<<< * try: * return os.strerror(errno) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("pyfuse3.strerror", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":149 * return 'errno: %d' % errno * * cdef PyBytes_from_bufvec(fuse_bufvec *src): # <<<<<<<<<<<<<< * cdef fuse_bufvec dst * cdef size_t len_ */ static PyObject *__pyx_f_7pyfuse3_PyBytes_from_bufvec(struct fuse_bufvec *__pyx_v_src) { struct fuse_bufvec __pyx_v_dst; size_t __pyx_v_len_; Py_ssize_t __pyx_v_res; PyObject *__pyx_v_buf = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("PyBytes_from_bufvec", 0); /* "src/internal.pxi":154 * cdef ssize_t res * * len_ = fuse_buf_size(src) - src.off # <<<<<<<<<<<<<< * if len_ > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') */ __pyx_v_len_ = (fuse_buf_size(__pyx_v_src) - __pyx_v_src->off); /* "src/internal.pxi":155 * * len_ = fuse_buf_size(src) - src.off * if len_ > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< * raise OverflowError('Value too long to convert to Python') * buf = PyBytes_FromStringAndSize(NULL, len_) */ __pyx_t_1 = ((__pyx_v_len_ > PY_SSIZE_T_MAX) != 0); if (unlikely(__pyx_t_1)) { /* "src/internal.pxi":156 * len_ = fuse_buf_size(src) - src.off * if len_ > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') # <<<<<<<<<<<<<< * buf = PyBytes_FromStringAndSize(NULL, len_) * dst.count = 1 */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_OverflowError, __pyx_tuple__17, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 156, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(2, 156, __pyx_L1_error) /* "src/internal.pxi":155 * * len_ = fuse_buf_size(src) - src.off * if len_ > PY_SSIZE_T_MAX: # <<<<<<<<<<<<<< * raise OverflowError('Value too long to convert to Python') * buf = PyBytes_FromStringAndSize(NULL, len_) */ } /* "src/internal.pxi":157 * if len_ > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') * buf = PyBytes_FromStringAndSize(NULL, len_) # <<<<<<<<<<<<<< * dst.count = 1 * dst.idx = 0 */ __pyx_t_2 = PyBytes_FromStringAndSize(NULL, ((Py_ssize_t)__pyx_v_len_)); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 157, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_buf = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "src/internal.pxi":158 * raise OverflowError('Value too long to convert to Python') * buf = PyBytes_FromStringAndSize(NULL, len_) * dst.count = 1 # <<<<<<<<<<<<<< * dst.idx = 0 * dst.off = 0 */ __pyx_v_dst.count = 1; /* "src/internal.pxi":159 * buf = PyBytes_FromStringAndSize(NULL, len_) * dst.count = 1 * dst.idx = 0 # <<<<<<<<<<<<<< * dst.off = 0 * dst.buf[0].mem = PyBytes_AS_STRING(buf) */ __pyx_v_dst.idx = 0; /* "src/internal.pxi":160 * dst.count = 1 * dst.idx = 0 * dst.off = 0 # <<<<<<<<<<<<<< * dst.buf[0].mem = PyBytes_AS_STRING(buf) * dst.buf[0].size = len_ */ __pyx_v_dst.off = 0; /* "src/internal.pxi":161 * dst.idx = 0 * dst.off = 0 * dst.buf[0].mem = PyBytes_AS_STRING(buf) # <<<<<<<<<<<<<< * dst.buf[0].size = len_ * dst.buf[0].flags = 0 */ (__pyx_v_dst.buf[0]).mem = PyBytes_AS_STRING(__pyx_v_buf); /* "src/internal.pxi":162 * dst.off = 0 * dst.buf[0].mem = PyBytes_AS_STRING(buf) * dst.buf[0].size = len_ # <<<<<<<<<<<<<< * dst.buf[0].flags = 0 * res = fuse_buf_copy(&dst, src, 0) */ (__pyx_v_dst.buf[0]).size = __pyx_v_len_; /* "src/internal.pxi":163 * dst.buf[0].mem = PyBytes_AS_STRING(buf) * dst.buf[0].size = len_ * dst.buf[0].flags = 0 # <<<<<<<<<<<<<< * res = fuse_buf_copy(&dst, src, 0) * if res < 0: */ (__pyx_v_dst.buf[0]).flags = 0; /* "src/internal.pxi":164 * dst.buf[0].size = len_ * dst.buf[0].flags = 0 * res = fuse_buf_copy(&dst, src, 0) # <<<<<<<<<<<<<< * if res < 0: * raise OSError(errno.errno, 'fuse_buf_copy failed with ' */ __pyx_v_res = fuse_buf_copy((&__pyx_v_dst), __pyx_v_src, 0); /* "src/internal.pxi":165 * dst.buf[0].flags = 0 * res = fuse_buf_copy(&dst, src, 0) * if res < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, 'fuse_buf_copy failed with ' * + strerror(errno.errno)) */ __pyx_t_1 = ((__pyx_v_res < 0) != 0); if (unlikely(__pyx_t_1)) { /* "src/internal.pxi":166 * res = fuse_buf_copy(&dst, src, 0) * if res < 0: * raise OSError(errno.errno, 'fuse_buf_copy failed with ' # <<<<<<<<<<<<<< * + strerror(errno.errno)) * elif res < len_: */ __pyx_t_2 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "src/internal.pxi":167 * if res < 0: * raise OSError(errno.errno, 'fuse_buf_copy failed with ' * + strerror(errno.errno)) # <<<<<<<<<<<<<< * elif res < len_: * # This is expected to be rare */ __pyx_t_3 = __pyx_f_7pyfuse3_strerror(errno); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyNumber_Add(__pyx_kp_u_fuse_buf_copy_failed_with, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 167, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/internal.pxi":166 * res = fuse_buf_copy(&dst, src, 0) * if res < 0: * raise OSError(errno.errno, 'fuse_buf_copy failed with ' # <<<<<<<<<<<<<< * + strerror(errno.errno)) * elif res < len_: */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 166, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(2, 166, __pyx_L1_error) /* "src/internal.pxi":165 * dst.buf[0].flags = 0 * res = fuse_buf_copy(&dst, src, 0) * if res < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, 'fuse_buf_copy failed with ' * + strerror(errno.errno)) */ } /* "src/internal.pxi":168 * raise OSError(errno.errno, 'fuse_buf_copy failed with ' * + strerror(errno.errno)) * elif res < len_: # <<<<<<<<<<<<<< * # This is expected to be rare * return buf[:res] */ __pyx_t_1 = ((((size_t)__pyx_v_res) < __pyx_v_len_) != 0); if (__pyx_t_1) { /* "src/internal.pxi":170 * elif res < len_: * # This is expected to be rare * return buf[:res] # <<<<<<<<<<<<<< * else: * return buf */ __Pyx_XDECREF(__pyx_r); if (unlikely(__pyx_v_buf == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(2, 170, __pyx_L1_error) } __pyx_t_4 = PySequence_GetSlice(__pyx_v_buf, 0, __pyx_v_res); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 170, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; /* "src/internal.pxi":168 * raise OSError(errno.errno, 'fuse_buf_copy failed with ' * + strerror(errno.errno)) * elif res < len_: # <<<<<<<<<<<<<< * # This is expected to be rare * return buf[:res] */ } /* "src/internal.pxi":172 * return buf[:res] * else: * return buf # <<<<<<<<<<<<<< * * cdef void* calloc_or_raise(size_t nmemb, size_t size) except NULL: */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_buf); __pyx_r = __pyx_v_buf; goto __pyx_L0; } /* "src/internal.pxi":149 * return 'errno: %d' % errno * * cdef PyBytes_from_bufvec(fuse_bufvec *src): # <<<<<<<<<<<<<< * cdef fuse_bufvec dst * cdef size_t len_ */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyfuse3.PyBytes_from_bufvec", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XDECREF(__pyx_v_buf); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":174 * return buf * * cdef void* calloc_or_raise(size_t nmemb, size_t size) except NULL: # <<<<<<<<<<<<<< * cdef void* mem * mem = stdlib.calloc(nmemb, size) */ static void *__pyx_f_7pyfuse3_calloc_or_raise(size_t __pyx_v_nmemb, size_t __pyx_v_size) { void *__pyx_v_mem; void *__pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("calloc_or_raise", 0); /* "src/internal.pxi":176 * cdef void* calloc_or_raise(size_t nmemb, size_t size) except NULL: * cdef void* mem * mem = stdlib.calloc(nmemb, size) # <<<<<<<<<<<<<< * if mem is NULL: * raise MemoryError() */ __pyx_v_mem = calloc(__pyx_v_nmemb, __pyx_v_size); /* "src/internal.pxi":177 * cdef void* mem * mem = stdlib.calloc(nmemb, size) * if mem is NULL: # <<<<<<<<<<<<<< * raise MemoryError() * return mem */ __pyx_t_1 = ((__pyx_v_mem == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "src/internal.pxi":178 * mem = stdlib.calloc(nmemb, size) * if mem is NULL: * raise MemoryError() # <<<<<<<<<<<<<< * return mem * */ PyErr_NoMemory(); __PYX_ERR(2, 178, __pyx_L1_error) /* "src/internal.pxi":177 * cdef void* mem * mem = stdlib.calloc(nmemb, size) * if mem is NULL: # <<<<<<<<<<<<<< * raise MemoryError() * return mem */ } /* "src/internal.pxi":179 * if mem is NULL: * raise MemoryError() * return mem # <<<<<<<<<<<<<< * * cdef class _WorkerData: */ __pyx_r = __pyx_v_mem; goto __pyx_L0; /* "src/internal.pxi":174 * return buf * * cdef void* calloc_or_raise(size_t nmemb, size_t size) except NULL: # <<<<<<<<<<<<<< * cdef void* mem * mem = stdlib.calloc(nmemb, size) */ /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.calloc_or_raise", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":189 * cdef int active_readers * * def __init__(self): # <<<<<<<<<<<<<< * self.read_lock = trio.Lock() * self.active_readers = 0 */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11_WorkerData_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_7pyfuse3_11_WorkerData_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_7pyfuse3_11_WorkerData___init__(((struct __pyx_obj_7pyfuse3__WorkerData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11_WorkerData___init__(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__init__", 0); /* "src/internal.pxi":190 * * def __init__(self): * self.read_lock = trio.Lock() # <<<<<<<<<<<<<< * self.active_readers = 0 * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_trio); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_Lock); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_2) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 190, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v_self->read_lock); __Pyx_DECREF(__pyx_v_self->read_lock); __pyx_v_self->read_lock = __pyx_t_1; __pyx_t_1 = 0; /* "src/internal.pxi":191 * def __init__(self): * self.read_lock = trio.Lock() * self.active_readers = 0 # <<<<<<<<<<<<<< * * cdef get_name(self): */ __pyx_v_self->active_readers = 0; /* "src/internal.pxi":189 * cdef int active_readers * * def __init__(self): # <<<<<<<<<<<<<< * self.read_lock = trio.Lock() * self.active_readers = 0 */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3._WorkerData.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "src/internal.pxi":193 * self.active_readers = 0 * * cdef get_name(self): # <<<<<<<<<<<<<< * self.task_serial += 1 * return 'pyfuse-%02d' % self.task_serial */ static PyObject *__pyx_f_7pyfuse3_11_WorkerData_get_name(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_name", 0); /* "src/internal.pxi":194 * * cdef get_name(self): * self.task_serial += 1 # <<<<<<<<<<<<<< * return 'pyfuse-%02d' % self.task_serial * */ __pyx_v_self->task_serial = (__pyx_v_self->task_serial + 1); /* "src/internal.pxi":195 * cdef get_name(self): * self.task_serial += 1 * return 'pyfuse-%02d' % self.task_serial # <<<<<<<<<<<<<< * * # Delay initialization so that pyfuse3_asyncio can replace */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->task_serial); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 195, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyUnicode_Format(__pyx_kp_u_pyfuse_02d, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 195, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "src/internal.pxi":193 * self.active_readers = 0 * * cdef get_name(self): # <<<<<<<<<<<<<< * self.task_serial += 1 * return 'pyfuse-%02d' % self.task_serial */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyfuse3._WorkerData.get_name", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11_WorkerData_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_11_WorkerData_2__reduce_cython__[] = "_WorkerData.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_11_WorkerData_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11_WorkerData_2__reduce_cython__(((struct __pyx_obj_7pyfuse3__WorkerData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11_WorkerData_2__reduce_cython__(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.active_readers, self.read_lock, self.task_count, self.task_serial) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->active_readers); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->task_count); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_self->task_serial); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); __Pyx_INCREF(__pyx_v_self->read_lock); __Pyx_GIVEREF(__pyx_v_self->read_lock); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_self->read_lock); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_t_3); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_v_state = ((PyObject*)__pyx_t_4); __pyx_t_4 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.active_readers, self.read_lock, self.task_count, self.task_serial) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_4 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v__dict = __pyx_t_4; __pyx_t_4 = 0; /* "(tree fragment)":7 * state = (self.active_readers, self.read_lock, self.task_count, self.task_serial) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_5 = (__pyx_v__dict != Py_None); __pyx_t_6 = (__pyx_t_5 != 0); if (__pyx_t_6) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_4 = PyTuple_New(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v__dict); __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = self.read_lock is not None */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.active_readers, self.read_lock, self.task_count, self.task_serial) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = self.read_lock is not None # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, None), state */ /*else*/ { __pyx_t_6 = (__pyx_v_self->read_lock != Py_None); __pyx_v_use_setstate = __pyx_t_6; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = self.read_lock is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, None), state * else: */ __pyx_t_6 = (__pyx_v_use_setstate != 0); if (__pyx_t_6) { /* "(tree fragment)":13 * use_setstate = self.read_lock is not None * if use_setstate: * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle__WorkerData); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_244161614); __Pyx_GIVEREF(__pyx_int_244161614); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_244161614); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_4, 2, Py_None); __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state); __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = self.read_lock is not None * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, None), state * else: * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle__WorkerData__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pyx_unpickle__WorkerData); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_4, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_244161614); __Pyx_GIVEREF(__pyx_int_244161614); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_int_244161614); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_state); __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyfuse3._WorkerData.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle__WorkerData__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11_WorkerData_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_11_WorkerData_4__setstate_cython__[] = "_WorkerData.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_11_WorkerData_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11_WorkerData_4__setstate_cython__(((struct __pyx_obj_7pyfuse3__WorkerData *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11_WorkerData_4__setstate_cython__(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle__WorkerData__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(0, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_7pyfuse3___pyx_unpickle__WorkerData__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle__WorkerData, (type(self), 0xe8d9c4e, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle__WorkerData__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3._WorkerData.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_91generator29(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/internal.pxi":201 * cdef _WorkerData worker_data * * async def _wait_fuse_readable(): # <<<<<<<<<<<<<< * '''Wait for FUSE fd to become readable * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_90_wait_fuse_readable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_89_wait_fuse_readable[] = "_wait_fuse_readable()\nWait for FUSE fd to become readable\n\n Return True if the fd is readable, or False if the main loop\n should terminate.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_90_wait_fuse_readable = {"_wait_fuse_readable", (PyCFunction)__pyx_pw_7pyfuse3_90_wait_fuse_readable, METH_NOARGS, __pyx_doc_7pyfuse3_89_wait_fuse_readable}; static PyObject *__pyx_pw_7pyfuse3_90_wait_fuse_readable(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_wait_fuse_readable (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_89_wait_fuse_readable(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_89_wait_fuse_readable(CYTHON_UNUSED PyObject *__pyx_self) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_wait_fuse_readable", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable(__pyx_ptype_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(2, 201, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_91generator29, __pyx_codeobj__37, (PyObject *) __pyx_cur_scope, __pyx_n_s_wait_fuse_readable, __pyx_n_s_wait_fuse_readable, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(2, 201, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3._wait_fuse_readable", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_91generator29(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; int __pyx_t_11; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; int __pyx_t_14; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; PyObject *__pyx_t_17 = NULL; PyObject *__pyx_t_18 = NULL; PyObject *__pyx_t_19 = NULL; int __pyx_t_20; PyObject *__pyx_t_21 = NULL; int __pyx_t_22; char const *__pyx_t_23; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_wait_fuse_readable", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L14_resume_from_await; case 2: goto __pyx_L25_resume_from_await; case 3: goto __pyx_L29_resume_from_await; case 4: goto __pyx_L30_resume_from_await; case 5: goto __pyx_L31_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 201, __pyx_L1_error) /* "src/internal.pxi":209 * * #name = trio.lowlevel.current_task().name * worker_data.active_readers += 1 # <<<<<<<<<<<<<< * try: * #log.debug('%s: Waiting for read lock...', name) */ __pyx_v_7pyfuse3_worker_data->active_readers = (__pyx_v_7pyfuse3_worker_data->active_readers + 1); /* "src/internal.pxi":210 * #name = trio.lowlevel.current_task().name * worker_data.active_readers += 1 * try: # <<<<<<<<<<<<<< * #log.debug('%s: Waiting for read lock...', name) * async with worker_data.read_lock: */ /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); /*try:*/ { /* "src/internal.pxi":212 * try: * #log.debug('%s: Waiting for read lock...', name) * async with worker_data.read_lock: # <<<<<<<<<<<<<< * #log.debug('%s: Waiting for fuse fd to become readable...', name) * if fuse_session_exited(session): */ /*with:*/ { __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_v_7pyfuse3_worker_data->read_lock, __pyx_n_s_aexit); if (unlikely(!__pyx_t_4)) __PYX_ERR(2, 212, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyObject_LookupSpecial(__pyx_v_7pyfuse3_worker_data->read_lock, __pyx_n_s_aenter); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 212, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_7)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_7); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_5 = (__pyx_t_7) ? __Pyx_PyObject_CallOneArg(__pyx_t_6, __pyx_t_7) : __Pyx_PyObject_CallNoArg(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 212, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_3 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L14_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_3; __pyx_cur_scope->__pyx_t_3 = 0; __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 212, __pyx_L13_error) __pyx_t_5 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_5); } else { __pyx_t_5 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_5) < 0) __PYX_ERR(2, 212, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_5); } __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_10); /*try:*/ { /* "src/internal.pxi":214 * async with worker_data.read_lock: * #log.debug('%s: Waiting for fuse fd to become readable...', name) * if fuse_session_exited(session): # <<<<<<<<<<<<<< * log.debug('FUSE session exit flag set while waiting for FUSE fd ' * 'to become readable.') */ __pyx_t_11 = (fuse_session_exited(__pyx_v_7pyfuse3_session) != 0); if (__pyx_t_11) { /* "src/internal.pxi":215 * #log.debug('%s: Waiting for fuse fd to become readable...', name) * if fuse_session_exited(session): * log.debug('FUSE session exit flag set while waiting for FUSE fd ' # <<<<<<<<<<<<<< * 'to become readable.') * return False */ __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_log); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 215, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_debug); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 215, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_7))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_5 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_6, __pyx_kp_u_FUSE_session_exit_flag_set_while) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_kp_u_FUSE_session_exit_flag_set_while); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 215, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/internal.pxi":217 * log.debug('FUSE session exit flag set while waiting for FUSE fd ' * 'to become readable.') * return False # <<<<<<<<<<<<<< * await trio.lowlevel.wait_readable(session_fd) * #log.debug('%s: fuse fd readable, unparking next task.', name) */ __Pyx_XDECREF(__pyx_r); __pyx_r = NULL; __Pyx_ReturnWithStopIteration(Py_False); goto __pyx_L22_try_return; /* "src/internal.pxi":214 * async with worker_data.read_lock: * #log.debug('%s: Waiting for fuse fd to become readable...', name) * if fuse_session_exited(session): # <<<<<<<<<<<<<< * log.debug('FUSE session exit flag set while waiting for FUSE fd ' * 'to become readable.') */ } /* "src/internal.pxi":218 * 'to become readable.') * return False * await trio.lowlevel.wait_readable(session_fd) # <<<<<<<<<<<<<< * #log.debug('%s: fuse fd readable, unparking next task.', name) * except trio.ClosedResourceError: */ __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_n_s_trio); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 218, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_lowlevel); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 218, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_wait_readable); if (unlikely(!__pyx_t_7)) __PYX_ERR(2, 218, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_7pyfuse3_session_fd); if (unlikely(!__pyx_t_6)) __PYX_ERR(2, 218, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_7); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_7, function); } } __pyx_t_5 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_12, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 218, __pyx_L18_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_5); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_3 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_t_8); __pyx_cur_scope->__pyx_t_4 = __pyx_t_8; __Pyx_XGIVEREF(__pyx_t_9); __pyx_cur_scope->__pyx_t_5 = __pyx_t_9; __Pyx_XGIVEREF(__pyx_t_10); __pyx_cur_scope->__pyx_t_6 = __pyx_t_10; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 2; return __pyx_r; __pyx_L25_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_3; __pyx_cur_scope->__pyx_t_3 = 0; __Pyx_XGOTREF(__pyx_t_4); __pyx_t_8 = __pyx_cur_scope->__pyx_t_4; __pyx_cur_scope->__pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_t_8); __pyx_t_9 = __pyx_cur_scope->__pyx_t_5; __pyx_cur_scope->__pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_t_9); __pyx_t_10 = __pyx_cur_scope->__pyx_t_6; __pyx_cur_scope->__pyx_t_6 = 0; __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 218, __pyx_L18_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(2, 218, __pyx_L18_error) } } /* "src/internal.pxi":212 * try: * #log.debug('%s: Waiting for read lock...', name) * async with worker_data.read_lock: # <<<<<<<<<<<<<< * #log.debug('%s: Waiting for fuse fd to become readable...', name) * if fuse_session_exited(session): */ } __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L23_try_end; __pyx_L18_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /*except:*/ { __Pyx_AddTraceback("pyfuse3._wait_fuse_readable", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(2, 212, __pyx_L20_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); __pyx_t_12 = PyTuple_Pack(3, __pyx_t_5, __pyx_t_7, __pyx_t_6); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 212, __pyx_L20_except_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_13 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_t_12, NULL); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_13)) __PYX_ERR(2, 212, __pyx_L20_except_error) __Pyx_GOTREF(__pyx_t_13); __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_3 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_t_4 = __pyx_t_5; __Pyx_XGIVEREF(__pyx_t_6); __pyx_cur_scope->__pyx_t_5 = __pyx_t_6; __Pyx_XGIVEREF(__pyx_t_7); __pyx_cur_scope->__pyx_t_6 = __pyx_t_7; __Pyx_XGIVEREF(__pyx_t_8); __pyx_cur_scope->__pyx_t_7 = __pyx_t_8; __Pyx_XGIVEREF(__pyx_t_9); __pyx_cur_scope->__pyx_t_8 = __pyx_t_9; __Pyx_XGIVEREF(__pyx_t_10); __pyx_cur_scope->__pyx_t_9 = __pyx_t_10; __Pyx_XGIVEREF(__pyx_t_13); __pyx_cur_scope->__pyx_t_10 = __pyx_t_13; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_SwapException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 3; return __pyx_r; __pyx_L29_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_3; __pyx_cur_scope->__pyx_t_3 = 0; __Pyx_XGOTREF(__pyx_t_4); __pyx_t_5 = __pyx_cur_scope->__pyx_t_4; __pyx_cur_scope->__pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_t_5); __pyx_t_6 = __pyx_cur_scope->__pyx_t_5; __pyx_cur_scope->__pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_t_6); __pyx_t_7 = __pyx_cur_scope->__pyx_t_6; __pyx_cur_scope->__pyx_t_6 = 0; __Pyx_XGOTREF(__pyx_t_7); __pyx_t_8 = __pyx_cur_scope->__pyx_t_7; __pyx_cur_scope->__pyx_t_7 = 0; __Pyx_XGOTREF(__pyx_t_8); __pyx_t_9 = __pyx_cur_scope->__pyx_t_8; __pyx_cur_scope->__pyx_t_8 = 0; __Pyx_XGOTREF(__pyx_t_9); __pyx_t_10 = __pyx_cur_scope->__pyx_t_9; __pyx_cur_scope->__pyx_t_9 = 0; __Pyx_XGOTREF(__pyx_t_10); __pyx_t_13 = __pyx_cur_scope->__pyx_t_10; __pyx_cur_scope->__pyx_t_10 = 0; __Pyx_XGOTREF(__pyx_t_13); if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 212, __pyx_L20_except_error) __pyx_t_12 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_12); } else { __pyx_t_12 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_12) < 0) __PYX_ERR(2, 212, __pyx_L20_except_error) __Pyx_GOTREF(__pyx_t_12); } __pyx_t_13 = __pyx_t_12; __pyx_t_12 = 0; __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_13); __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; if (__pyx_t_11 < 0) __PYX_ERR(2, 212, __pyx_L20_except_error) __pyx_t_14 = ((!(__pyx_t_11 != 0)) != 0); if (__pyx_t_14) { __Pyx_GIVEREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_6); __Pyx_ErrRestoreWithState(__pyx_t_5, __pyx_t_7, __pyx_t_6); __pyx_t_5 = 0; __pyx_t_7 = 0; __pyx_t_6 = 0; __PYX_ERR(2, 212, __pyx_L20_except_error) } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; goto __pyx_L19_exception_handled; } __pyx_L20_except_error:; __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); goto __pyx_L7_error; __pyx_L22_try_return:; __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); goto __pyx_L15_return; __pyx_L19_exception_handled:; __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ExceptionReset(__pyx_t_8, __pyx_t_9, __pyx_t_10); __pyx_L23_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_4) { __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__38, NULL); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(2, 212, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_10); __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_10); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_3 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_t_10); __pyx_cur_scope->__pyx_t_4 = __pyx_t_10; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 4; return __pyx_r; __pyx_L30_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_3; __pyx_cur_scope->__pyx_t_3 = 0; __Pyx_XGOTREF(__pyx_t_4); __pyx_t_10 = __pyx_cur_scope->__pyx_t_4; __pyx_cur_scope->__pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 212, __pyx_L7_error) __pyx_t_6 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_6); } else { __pyx_t_6 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_6) < 0) __PYX_ERR(2, 212, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_6); } __pyx_t_10 = __pyx_t_6; __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; } goto __pyx_L17; } __pyx_L15_return: { __Pyx_PyThreadState_assign __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_13 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_13, &__pyx_t_15, &__pyx_t_16); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __pyx_t_17 = __pyx_r; __pyx_r = 0; if (__pyx_t_4) { __pyx_t_18 = __Pyx_PyObject_Call(__pyx_t_4, __pyx_tuple__38, NULL); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_18)) __PYX_ERR(2, 212, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_18); __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_18); __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_1); __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_t_2 = __pyx_t_3; __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_3 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_t_8); __pyx_cur_scope->__pyx_t_4 = __pyx_t_8; __Pyx_XGIVEREF(__pyx_t_9); __pyx_cur_scope->__pyx_t_5 = __pyx_t_9; __Pyx_XGIVEREF(__pyx_t_10); __pyx_cur_scope->__pyx_t_6 = __pyx_t_10; __Pyx_XGIVEREF(__pyx_t_13); __pyx_cur_scope->__pyx_t_7 = __pyx_t_13; __Pyx_XGIVEREF(__pyx_t_15); __pyx_cur_scope->__pyx_t_8 = __pyx_t_15; __Pyx_XGIVEREF(__pyx_t_16); __pyx_cur_scope->__pyx_t_9 = __pyx_t_16; __Pyx_XGIVEREF(__pyx_t_17); __pyx_cur_scope->__pyx_t_10 = __pyx_t_17; __Pyx_XGIVEREF(__pyx_t_18); __pyx_cur_scope->__pyx_t_11 = __pyx_t_18; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 5; return __pyx_r; __pyx_L31_resume_from_await:; __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_1); __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_3 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_3); __pyx_t_4 = __pyx_cur_scope->__pyx_t_3; __pyx_cur_scope->__pyx_t_3 = 0; __Pyx_XGOTREF(__pyx_t_4); __pyx_t_8 = __pyx_cur_scope->__pyx_t_4; __pyx_cur_scope->__pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_t_8); __pyx_t_9 = __pyx_cur_scope->__pyx_t_5; __pyx_cur_scope->__pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_t_9); __pyx_t_10 = __pyx_cur_scope->__pyx_t_6; __pyx_cur_scope->__pyx_t_6 = 0; __Pyx_XGOTREF(__pyx_t_10); __pyx_t_13 = __pyx_cur_scope->__pyx_t_7; __pyx_cur_scope->__pyx_t_7 = 0; __Pyx_XGOTREF(__pyx_t_13); __pyx_t_15 = __pyx_cur_scope->__pyx_t_8; __pyx_cur_scope->__pyx_t_8 = 0; __Pyx_XGOTREF(__pyx_t_15); __pyx_t_16 = __pyx_cur_scope->__pyx_t_9; __pyx_cur_scope->__pyx_t_9 = 0; __Pyx_XGOTREF(__pyx_t_16); __pyx_t_17 = __pyx_cur_scope->__pyx_t_10; __pyx_cur_scope->__pyx_t_10 = 0; __Pyx_XGOTREF(__pyx_t_17); __pyx_t_18 = __pyx_cur_scope->__pyx_t_11; __pyx_cur_scope->__pyx_t_11 = 0; __Pyx_XGOTREF(__pyx_t_18); if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 212, __pyx_L7_error) __pyx_t_6 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_6); } else { __pyx_t_6 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_6) < 0) __PYX_ERR(2, 212, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_6); } __pyx_t_18 = __pyx_t_6; __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; } __pyx_r = __pyx_t_17; __pyx_t_17 = 0; if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_15, __pyx_t_16); } __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ErrRestore(__pyx_t_10, __pyx_t_9, __pyx_t_8); __pyx_t_10 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_13 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; goto __pyx_L11_try_return; } __pyx_L17:; } goto __pyx_L32; __pyx_L13_error:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; goto __pyx_L7_error; __pyx_L32:; } /* "src/internal.pxi":210 * #name = trio.lowlevel.current_task().name * worker_data.active_readers += 1 * try: # <<<<<<<<<<<<<< * #log.debug('%s: Waiting for read lock...', name) * async with worker_data.read_lock: */ } __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L12_try_end; __pyx_L7_error:; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; /* "src/internal.pxi":220 * await trio.lowlevel.wait_readable(session_fd) * #log.debug('%s: fuse fd readable, unparking next task.', name) * except trio.ClosedResourceError: # <<<<<<<<<<<<<< * log.debug('FUSE fd about to be closed.') * return False */ __Pyx_ErrFetch(&__pyx_t_6, &__pyx_t_7, &__pyx_t_5); __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_trio); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 220, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_ClosedResourceError); if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 220, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_20 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_6, __pyx_t_19); __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_ErrRestore(__pyx_t_6, __pyx_t_7, __pyx_t_5); __pyx_t_6 = 0; __pyx_t_7 = 0; __pyx_t_5 = 0; if (__pyx_t_20) { __Pyx_AddTraceback("pyfuse3._wait_fuse_readable", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_7, &__pyx_t_6) < 0) __PYX_ERR(2, 220, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_7); __Pyx_GOTREF(__pyx_t_6); /* "src/internal.pxi":221 * #log.debug('%s: fuse fd readable, unparking next task.', name) * except trio.ClosedResourceError: * log.debug('FUSE fd about to be closed.') # <<<<<<<<<<<<<< * return False * */ __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_n_s_log); if (unlikely(!__pyx_t_12)) __PYX_ERR(2, 221, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_n_s_debug); if (unlikely(!__pyx_t_21)) __PYX_ERR(2, 221, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_21); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_21))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_21); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_21); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_21, function); } } __pyx_t_19 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_21, __pyx_t_12, __pyx_kp_u_FUSE_fd_about_to_be_closed) : __Pyx_PyObject_CallOneArg(__pyx_t_21, __pyx_kp_u_FUSE_fd_about_to_be_closed); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; if (unlikely(!__pyx_t_19)) __PYX_ERR(2, 221, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_19); __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; /* "src/internal.pxi":222 * except trio.ClosedResourceError: * log.debug('FUSE fd about to be closed.') * return False # <<<<<<<<<<<<<< * * finally: */ __Pyx_XDECREF(__pyx_r); __pyx_r = NULL; __Pyx_ReturnWithStopIteration(Py_False); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; goto __pyx_L10_except_return; } goto __pyx_L9_except_error; __pyx_L9_except_error:; /* "src/internal.pxi":210 * #name = trio.lowlevel.current_task().name * worker_data.active_readers += 1 * try: # <<<<<<<<<<<<<< * #log.debug('%s: Waiting for read lock...', name) * async with worker_data.read_lock: */ __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L5_error; __pyx_L11_try_return:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L4_return; __pyx_L10_except_return:; __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); goto __pyx_L4_return; __pyx_L12_try_end:; } } /* "src/internal.pxi":225 * * finally: * worker_data.active_readers -= 1 # <<<<<<<<<<<<<< * * return True */ /*finally:*/ { /*normal exit:*/{ __pyx_v_7pyfuse3_worker_data->active_readers = (__pyx_v_7pyfuse3_worker_data->active_readers - 1); goto __pyx_L6; } __pyx_L5_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_XDECREF(__pyx_t_19); __pyx_t_19 = 0; __Pyx_XDECREF(__pyx_t_21); __pyx_t_21 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_4, &__pyx_t_16, &__pyx_t_15); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1) < 0)) __Pyx_ErrFetch(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); __Pyx_XGOTREF(__pyx_t_3); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_15); __pyx_t_20 = __pyx_lineno; __pyx_t_22 = __pyx_clineno; __pyx_t_23 = __pyx_filename; { __pyx_v_7pyfuse3_worker_data->active_readers = (__pyx_v_7pyfuse3_worker_data->active_readers - 1); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_4); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_4, __pyx_t_16, __pyx_t_15); } __Pyx_XGIVEREF(__pyx_t_3); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_1); __Pyx_ErrRestore(__pyx_t_3, __pyx_t_2, __pyx_t_1); __pyx_t_3 = 0; __pyx_t_2 = 0; __pyx_t_1 = 0; __pyx_t_4 = 0; __pyx_t_16 = 0; __pyx_t_15 = 0; __pyx_lineno = __pyx_t_20; __pyx_clineno = __pyx_t_22; __pyx_filename = __pyx_t_23; goto __pyx_L1_error; } __pyx_L4_return: { __Pyx_PyThreadState_assign __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_15, &__pyx_t_16, &__pyx_t_4) < 0)) __Pyx_ErrFetch(&__pyx_t_15, &__pyx_t_16, &__pyx_t_4); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __Pyx_XGOTREF(__pyx_t_4); __Pyx_XGOTREF(__pyx_t_1); __Pyx_XGOTREF(__pyx_t_2); __Pyx_XGOTREF(__pyx_t_3); __pyx_t_13 = __pyx_r; __pyx_r = 0; __pyx_v_7pyfuse3_worker_data->active_readers = (__pyx_v_7pyfuse3_worker_data->active_readers - 1); __pyx_r = __pyx_t_13; __pyx_t_13 = 0; if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_XGIVEREF(__pyx_t_3); __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); } __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_XGIVEREF(__pyx_t_4); __Pyx_ErrRestore(__pyx_t_15, __pyx_t_16, __pyx_t_4); __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; goto __pyx_L0; } __pyx_L6:; } /* "src/internal.pxi":227 * worker_data.active_readers -= 1 * * return True # <<<<<<<<<<<<<< * * @async_wrapper */ __Pyx_XDECREF(__pyx_r); __pyx_r = NULL; __Pyx_ReturnWithStopIteration(Py_True); goto __pyx_L0; CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/internal.pxi":201 * cdef _WorkerData worker_data * * async def _wait_fuse_readable(): # <<<<<<<<<<<<<< * '''Wait for FUSE fd to become readable * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_12); __Pyx_XDECREF(__pyx_t_19); __Pyx_XDECREF(__pyx_t_21); __Pyx_AddTraceback("_wait_fuse_readable", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_94generator30(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "src/internal.pxi":230 * * @async_wrapper * async def _session_loop(nursery, int min_tasks, int max_tasks): # <<<<<<<<<<<<<< * cdef int res * cdef fuse_buf buf */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_93_session_loop(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_92_session_loop[] = "_session_loop(nursery, int min_tasks, int max_tasks)"; static PyMethodDef __pyx_mdef_7pyfuse3_93_session_loop = {"_session_loop", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_93_session_loop, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_92_session_loop}; static PyObject *__pyx_pw_7pyfuse3_93_session_loop(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_nursery = 0; int __pyx_v_min_tasks; int __pyx_v_max_tasks; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_session_loop (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_nursery,&__pyx_n_s_min_tasks,&__pyx_n_s_max_tasks,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nursery)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_min_tasks)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_session_loop", 1, 3, 3, 1); __PYX_ERR(2, 230, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_tasks)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("_session_loop", 1, 3, 3, 2); __PYX_ERR(2, 230, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "_session_loop") < 0)) __PYX_ERR(2, 230, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_nursery = values[0]; __pyx_v_min_tasks = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_min_tasks == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 230, __pyx_L3_error) __pyx_v_max_tasks = __Pyx_PyInt_As_int(values[2]); if (unlikely((__pyx_v_max_tasks == (int)-1) && PyErr_Occurred())) __PYX_ERR(2, 230, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("_session_loop", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(2, 230, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3._session_loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_92_session_loop(__pyx_self, __pyx_v_nursery, __pyx_v_min_tasks, __pyx_v_max_tasks); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_92_session_loop(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_nursery, int __pyx_v_min_tasks, int __pyx_v_max_tasks) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("_session_loop", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_30__session_loop(__pyx_ptype_7pyfuse3___pyx_scope_struct_30__session_loop, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(2, 230, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_nursery = __pyx_v_nursery; __Pyx_INCREF(__pyx_cur_scope->__pyx_v_nursery); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_nursery); __pyx_cur_scope->__pyx_v_min_tasks = __pyx_v_min_tasks; __pyx_cur_scope->__pyx_v_max_tasks = __pyx_v_max_tasks; { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_94generator30, __pyx_codeobj__39, (PyObject *) __pyx_cur_scope, __pyx_n_s_session_loop, __pyx_n_s_session_loop, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(2, 230, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3._session_loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_94generator30(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *)__pyx_generator->closure); PyObject *__pyx_r = NULL; PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; PyObject *__pyx_t_8 = NULL; int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("_session_loop", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L8_resume_from_await; case 2: goto __pyx_L14_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 230, __pyx_L1_error) /* "src/internal.pxi":234 * cdef fuse_buf buf * * name = trio.lowlevel.current_task().name # <<<<<<<<<<<<<< * * buf.mem = NULL */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_trio); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_lowlevel); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_current_task); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_name); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_v_name = __pyx_t_2; __pyx_t_2 = 0; /* "src/internal.pxi":236 * name = trio.lowlevel.current_task().name * * buf.mem = NULL # <<<<<<<<<<<<<< * buf.size = 0 * buf.pos = 0 */ __pyx_cur_scope->__pyx_v_buf.mem = NULL; /* "src/internal.pxi":237 * * buf.mem = NULL * buf.size = 0 # <<<<<<<<<<<<<< * buf.pos = 0 * buf.flags = 0 */ __pyx_cur_scope->__pyx_v_buf.size = 0; /* "src/internal.pxi":238 * buf.mem = NULL * buf.size = 0 * buf.pos = 0 # <<<<<<<<<<<<<< * buf.flags = 0 * while not fuse_session_exited(session): */ __pyx_cur_scope->__pyx_v_buf.pos = 0; /* "src/internal.pxi":239 * buf.size = 0 * buf.pos = 0 * buf.flags = 0 # <<<<<<<<<<<<<< * while not fuse_session_exited(session): * if worker_data.active_readers > min_tasks: */ __pyx_cur_scope->__pyx_v_buf.flags = 0; /* "src/internal.pxi":240 * buf.pos = 0 * buf.flags = 0 * while not fuse_session_exited(session): # <<<<<<<<<<<<<< * if worker_data.active_readers > min_tasks: * log.debug('%s: too many idle tasks (%d total, %d waiting), terminating.', */ while (1) { __pyx_t_4 = ((!(fuse_session_exited(__pyx_v_7pyfuse3_session) != 0)) != 0); if (!__pyx_t_4) break; /* "src/internal.pxi":241 * buf.flags = 0 * while not fuse_session_exited(session): * if worker_data.active_readers > min_tasks: # <<<<<<<<<<<<<< * log.debug('%s: too many idle tasks (%d total, %d waiting), terminating.', * name, worker_data.task_count, worker_data.active_readers) */ __pyx_t_4 = ((__pyx_v_7pyfuse3_worker_data->active_readers > __pyx_cur_scope->__pyx_v_min_tasks) != 0); if (__pyx_t_4) { /* "src/internal.pxi":242 * while not fuse_session_exited(session): * if worker_data.active_readers > min_tasks: * log.debug('%s: too many idle tasks (%d total, %d waiting), terminating.', # <<<<<<<<<<<<<< * name, worker_data.task_count, worker_data.active_readers) * break */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":243 * if worker_data.active_readers > min_tasks: * log.debug('%s: too many idle tasks (%d total, %d waiting), terminating.', * name, worker_data.task_count, worker_data.active_readers) # <<<<<<<<<<<<<< * break * */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_7pyfuse3_worker_data->task_count); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_7pyfuse3_worker_data->active_readers); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 243, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_6, __pyx_kp_u_s_too_many_idle_tasks_d_total_d, __pyx_cur_scope->__pyx_v_name, __pyx_t_1, __pyx_t_5}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 4+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 242, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_3)) { PyObject *__pyx_temp[5] = {__pyx_t_6, __pyx_kp_u_s_too_many_idle_tasks_d_total_d, __pyx_cur_scope->__pyx_v_name, __pyx_t_1, __pyx_t_5}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_3, __pyx_temp+1-__pyx_t_7, 4+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 242, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; } else #endif { __pyx_t_8 = PyTuple_New(4+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); if (__pyx_t_6) { __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_6); __pyx_t_6 = NULL; } __Pyx_INCREF(__pyx_kp_u_s_too_many_idle_tasks_d_total_d); __Pyx_GIVEREF(__pyx_kp_u_s_too_many_idle_tasks_d_total_d); PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_kp_u_s_too_many_idle_tasks_d_total_d); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_8, 2+__pyx_t_7, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 3+__pyx_t_7, __pyx_t_5); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/internal.pxi":244 * log.debug('%s: too many idle tasks (%d total, %d waiting), terminating.', * name, worker_data.task_count, worker_data.active_readers) * break # <<<<<<<<<<<<<< * * if not await _wait_fuse_readable(): */ goto __pyx_L5_break; /* "src/internal.pxi":241 * buf.flags = 0 * while not fuse_session_exited(session): * if worker_data.active_readers > min_tasks: # <<<<<<<<<<<<<< * log.debug('%s: too many idle tasks (%d total, %d waiting), terminating.', * name, worker_data.task_count, worker_data.active_readers) */ } /* "src/internal.pxi":246 * break * * if not await _wait_fuse_readable(): # <<<<<<<<<<<<<< * break * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_wait_fuse_readable); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_8)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_8); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_2 = (__pyx_t_8) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_8) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_2); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L8_resume_from_await:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 246, __pyx_L1_error) __pyx_t_2 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_2); } else { __pyx_t_2 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_2) < 0) __PYX_ERR(2, 246, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); } __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(2, 246, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_9 = ((!__pyx_t_4) != 0); if (__pyx_t_9) { /* "src/internal.pxi":247 * * if not await _wait_fuse_readable(): * break # <<<<<<<<<<<<<< * * res = fuse_session_receive_buf(session, &buf) */ goto __pyx_L5_break; /* "src/internal.pxi":246 * break * * if not await _wait_fuse_readable(): # <<<<<<<<<<<<<< * break * */ } /* "src/internal.pxi":249 * break * * res = fuse_session_receive_buf(session, &buf) # <<<<<<<<<<<<<< * if not worker_data.active_readers and worker_data.task_count < max_tasks: * worker_data.task_count += 1 */ __pyx_cur_scope->__pyx_v_res = fuse_session_receive_buf(__pyx_v_7pyfuse3_session, (&__pyx_cur_scope->__pyx_v_buf)); /* "src/internal.pxi":250 * * res = fuse_session_receive_buf(session, &buf) * if not worker_data.active_readers and worker_data.task_count < max_tasks: # <<<<<<<<<<<<<< * worker_data.task_count += 1 * log.debug('%s: No tasks waiting, starting another worker (now %d total).', */ __pyx_t_4 = ((!(__pyx_v_7pyfuse3_worker_data->active_readers != 0)) != 0); if (__pyx_t_4) { } else { __pyx_t_9 = __pyx_t_4; goto __pyx_L10_bool_binop_done; } __pyx_t_4 = ((__pyx_v_7pyfuse3_worker_data->task_count < __pyx_cur_scope->__pyx_v_max_tasks) != 0); __pyx_t_9 = __pyx_t_4; __pyx_L10_bool_binop_done:; if (__pyx_t_9) { /* "src/internal.pxi":251 * res = fuse_session_receive_buf(session, &buf) * if not worker_data.active_readers and worker_data.task_count < max_tasks: * worker_data.task_count += 1 # <<<<<<<<<<<<<< * log.debug('%s: No tasks waiting, starting another worker (now %d total).', * name, worker_data.task_count) */ __pyx_v_7pyfuse3_worker_data->task_count = (__pyx_v_7pyfuse3_worker_data->task_count + 1); /* "src/internal.pxi":252 * if not worker_data.active_readers and worker_data.task_count < max_tasks: * worker_data.task_count += 1 * log.debug('%s: No tasks waiting, starting another worker (now %d total).', # <<<<<<<<<<<<<< * name, worker_data.task_count) * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_log); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/internal.pxi":253 * worker_data.task_count += 1 * log.debug('%s: No tasks waiting, starting another worker (now %d total).', * name, worker_data.task_count) # <<<<<<<<<<<<<< * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, * name=worker_data.get_name()) */ __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_7pyfuse3_worker_data->task_count); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 253, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_8))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_kp_u_s_No_tasks_waiting_starting_ano, __pyx_cur_scope->__pyx_v_name, __pyx_t_3}; __pyx_t_2 = __Pyx_PyFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 252, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_8)) { PyObject *__pyx_temp[4] = {__pyx_t_5, __pyx_kp_u_s_No_tasks_waiting_starting_ano, __pyx_cur_scope->__pyx_v_name, __pyx_t_3}; __pyx_t_2 = __Pyx_PyCFunction_FastCall(__pyx_t_8, __pyx_temp+1-__pyx_t_7, 3+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 252, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } else #endif { __pyx_t_1 = PyTuple_New(3+__pyx_t_7); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__pyx_t_5) { __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __pyx_t_5 = NULL; } __Pyx_INCREF(__pyx_kp_u_s_No_tasks_waiting_starting_ano); __Pyx_GIVEREF(__pyx_kp_u_s_No_tasks_waiting_starting_ano); PyTuple_SET_ITEM(__pyx_t_1, 0+__pyx_t_7, __pyx_kp_u_s_No_tasks_waiting_starting_ano); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_1, 1+__pyx_t_7, __pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 2+__pyx_t_7, __pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_8, __pyx_t_1, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 252, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; } __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/internal.pxi":254 * log.debug('%s: No tasks waiting, starting another worker (now %d total).', * name, worker_data.task_count) * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, # <<<<<<<<<<<<<< * name=worker_data.get_name()) * */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_nursery, __pyx_n_s_start_soon); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_n_s_session_loop); if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_min_tasks); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_max_tasks); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_8); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_nursery); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_nursery); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_cur_scope->__pyx_v_nursery); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_3); __pyx_t_8 = 0; __pyx_t_1 = 0; __pyx_t_3 = 0; /* "src/internal.pxi":255 * name, worker_data.task_count) * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, * name=worker_data.get_name()) # <<<<<<<<<<<<<< * * if res == -errno.EINTR: */ __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = ((struct __pyx_vtabstruct_7pyfuse3__WorkerData *)__pyx_v_7pyfuse3_worker_data->__pyx_vtab)->get_name(__pyx_v_7pyfuse3_worker_data); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 255, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_name, __pyx_t_1) < 0) __PYX_ERR(2, 255, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":254 * log.debug('%s: No tasks waiting, starting another worker (now %d total).', * name, worker_data.task_count) * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, # <<<<<<<<<<<<<< * name=worker_data.get_name()) * */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_5, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 254, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "src/internal.pxi":250 * * res = fuse_session_receive_buf(session, &buf) * if not worker_data.active_readers and worker_data.task_count < max_tasks: # <<<<<<<<<<<<<< * worker_data.task_count += 1 * log.debug('%s: No tasks waiting, starting another worker (now %d total).', */ } /* "src/internal.pxi":257 * name=worker_data.get_name()) * * if res == -errno.EINTR: # <<<<<<<<<<<<<< * continue * elif res < 0: */ __pyx_t_9 = ((__pyx_cur_scope->__pyx_v_res == (-EINTR)) != 0); if (__pyx_t_9) { /* "src/internal.pxi":258 * * if res == -errno.EINTR: * continue # <<<<<<<<<<<<<< * elif res < 0: * raise OSError(-res, 'fuse_session_receive_buf failed with ' */ goto __pyx_L4_continue; /* "src/internal.pxi":257 * name=worker_data.get_name()) * * if res == -errno.EINTR: # <<<<<<<<<<<<<< * continue * elif res < 0: */ } /* "src/internal.pxi":259 * if res == -errno.EINTR: * continue * elif res < 0: # <<<<<<<<<<<<<< * raise OSError(-res, 'fuse_session_receive_buf failed with ' * + strerror(-res)) */ __pyx_t_9 = ((__pyx_cur_scope->__pyx_v_res < 0) != 0); if (unlikely(__pyx_t_9)) { /* "src/internal.pxi":260 * continue * elif res < 0: * raise OSError(-res, 'fuse_session_receive_buf failed with ' # <<<<<<<<<<<<<< * + strerror(-res)) * elif res == 0: */ __pyx_t_1 = __Pyx_PyInt_From_int((-__pyx_cur_scope->__pyx_v_res)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "src/internal.pxi":261 * elif res < 0: * raise OSError(-res, 'fuse_session_receive_buf failed with ' * + strerror(-res)) # <<<<<<<<<<<<<< * elif res == 0: * break */ __pyx_t_3 = __pyx_f_7pyfuse3_strerror((-__pyx_cur_scope->__pyx_v_res)); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyNumber_Add(__pyx_kp_u_fuse_session_receive_buf_failed, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 261, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "src/internal.pxi":260 * continue * elif res < 0: * raise OSError(-res, 'fuse_session_receive_buf failed with ' # <<<<<<<<<<<<<< * + strerror(-res)) * elif res == 0: */ __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(2, 260, __pyx_L1_error) /* "src/internal.pxi":259 * if res == -errno.EINTR: * continue * elif res < 0: # <<<<<<<<<<<<<< * raise OSError(-res, 'fuse_session_receive_buf failed with ' * + strerror(-res)) */ } /* "src/internal.pxi":262 * raise OSError(-res, 'fuse_session_receive_buf failed with ' * + strerror(-res)) * elif res == 0: # <<<<<<<<<<<<<< * break * */ __pyx_t_9 = ((__pyx_cur_scope->__pyx_v_res == 0) != 0); if (__pyx_t_9) { /* "src/internal.pxi":263 * + strerror(-res)) * elif res == 0: * break # <<<<<<<<<<<<<< * * # When fuse_session_process_buf() calls back into one of our handler */ goto __pyx_L5_break; /* "src/internal.pxi":262 * raise OSError(-res, 'fuse_session_receive_buf failed with ' * + strerror(-res)) * elif res == 0: # <<<<<<<<<<<<<< * break * */ } /* "src/internal.pxi":269 * # py_retval. * #log.debug('%s: processing request...', name) * save_retval(None) # <<<<<<<<<<<<<< * fuse_session_process_buf(session, &buf) * if py_retval is not None: */ __pyx_f_7pyfuse3_save_retval(Py_None); /* "src/internal.pxi":270 * #log.debug('%s: processing request...', name) * save_retval(None) * fuse_session_process_buf(session, &buf) # <<<<<<<<<<<<<< * if py_retval is not None: * await py_retval */ fuse_session_process_buf(__pyx_v_7pyfuse3_session, (&__pyx_cur_scope->__pyx_v_buf)); /* "src/internal.pxi":271 * save_retval(None) * fuse_session_process_buf(session, &buf) * if py_retval is not None: # <<<<<<<<<<<<<< * await py_retval * #log.debug('%s: processing complete.', name) */ __pyx_t_9 = (__pyx_v_7pyfuse3_py_retval != Py_None); __pyx_t_4 = (__pyx_t_9 != 0); if (__pyx_t_4) { /* "src/internal.pxi":272 * fuse_session_process_buf(session, &buf) * if py_retval is not None: * await py_retval # <<<<<<<<<<<<<< * #log.debug('%s: processing complete.', name) * */ __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_v_7pyfuse3_py_retval); __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 2; return __pyx_r; __pyx_L14_resume_from_await:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(2, 272, __pyx_L1_error) } else { PyObject* exc_type = __Pyx_PyErr_Occurred(); if (exc_type) { if (likely(exc_type == PyExc_StopIteration || (exc_type != PyExc_GeneratorExit && __Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration)))) PyErr_Clear(); else __PYX_ERR(2, 272, __pyx_L1_error) } } /* "src/internal.pxi":271 * save_retval(None) * fuse_session_process_buf(session, &buf) * if py_retval is not None: # <<<<<<<<<<<<<< * await py_retval * #log.debug('%s: processing complete.', name) */ } __pyx_L4_continue:; } __pyx_L5_break:; /* "src/internal.pxi":275 * #log.debug('%s: processing complete.', name) * * log.debug('%s: terminated', name) # <<<<<<<<<<<<<< * stdlib.free(buf.mem) * worker_data.task_count -= 1 */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_log); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; __pyx_t_7 = 0; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); __pyx_t_7 = 1; } } #if CYTHON_FAST_PYCALL if (PyFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_kp_u_s_terminated, __pyx_cur_scope->__pyx_v_name}; __pyx_t_5 = __Pyx_PyFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 275, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(__pyx_t_1)) { PyObject *__pyx_temp[3] = {__pyx_t_3, __pyx_kp_u_s_terminated, __pyx_cur_scope->__pyx_v_name}; __pyx_t_5 = __Pyx_PyCFunction_FastCall(__pyx_t_1, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 275, __pyx_L1_error) __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_GOTREF(__pyx_t_5); } else #endif { __pyx_t_2 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (__pyx_t_3) { __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3); __pyx_t_3 = NULL; } __Pyx_INCREF(__pyx_kp_u_s_terminated); __Pyx_GIVEREF(__pyx_kp_u_s_terminated); PyTuple_SET_ITEM(__pyx_t_2, 0+__pyx_t_7, __pyx_kp_u_s_terminated); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_name); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_2, 1+__pyx_t_7, __pyx_cur_scope->__pyx_v_name); __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_2, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(2, 275, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "src/internal.pxi":276 * * log.debug('%s: terminated', name) * stdlib.free(buf.mem) # <<<<<<<<<<<<<< * worker_data.task_count -= 1 */ free(__pyx_cur_scope->__pyx_v_buf.mem); /* "src/internal.pxi":277 * log.debug('%s: terminated', name) * stdlib.free(buf.mem) * worker_data.task_count -= 1 # <<<<<<<<<<<<<< */ __pyx_v_7pyfuse3_worker_data->task_count = (__pyx_v_7pyfuse3_worker_data->task_count - 1); CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "src/internal.pxi":230 * * @async_wrapper * async def _session_loop(nursery, int min_tasks, int max_tasks): # <<<<<<<<<<<<<< * cdef int res * cdef fuse_buf buf */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("_session_loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":139 * cdef readonly mode_t umask * * def __getstate__(self): # <<<<<<<<<<<<<< * raise PicklingError("RequestContext instances can't be pickled") * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_1__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_14RequestContext___getstate__[] = "RequestContext.__getstate__(self)"; static PyObject *__pyx_pw_7pyfuse3_14RequestContext_1__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getstate__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_14RequestContext___getstate__(((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_14RequestContext___getstate__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getstate__", 0); /* "pyfuse3.pyx":140 * * def __getstate__(self): * raise PicklingError("RequestContext instances can't be pickled") # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PicklingError); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_RequestContext_instances_can_t_b) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_RequestContext_instances_can_t_b); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 140, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(3, 140, __pyx_L1_error) /* "pyfuse3.pyx":139 * cdef readonly mode_t umask * * def __getstate__(self): # <<<<<<<<<<<<<< * raise PicklingError("RequestContext instances can't be pickled") * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.RequestContext.__getstate__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":134 * ''' * * cdef readonly uid_t uid # <<<<<<<<<<<<<< * cdef readonly pid_t pid * cdef readonly gid_t gid */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_3uid_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_3uid_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_14RequestContext_3uid___get__(((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_14RequestContext_3uid___get__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_uid_t(__pyx_v_self->uid); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 134, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.RequestContext.uid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":135 * * cdef readonly uid_t uid * cdef readonly pid_t pid # <<<<<<<<<<<<<< * cdef readonly gid_t gid * cdef readonly mode_t umask */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_3pid_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_3pid_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_14RequestContext_3pid___get__(((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_14RequestContext_3pid___get__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_pid_t(__pyx_v_self->pid); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 135, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.RequestContext.pid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":136 * cdef readonly uid_t uid * cdef readonly pid_t pid * cdef readonly gid_t gid # <<<<<<<<<<<<<< * cdef readonly mode_t umask * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_3gid_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_3gid_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_14RequestContext_3gid___get__(((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_14RequestContext_3gid___get__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_gid_t(__pyx_v_self->gid); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 136, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.RequestContext.gid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":137 * cdef readonly pid_t pid * cdef readonly gid_t gid * cdef readonly mode_t umask # <<<<<<<<<<<<<< * * def __getstate__(self): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_5umask_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_5umask_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_14RequestContext_5umask___get__(((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_14RequestContext_5umask___get__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_mode_t(__pyx_v_self->umask); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 137, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.RequestContext.umask.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_14RequestContext_2__reduce_cython__[] = "RequestContext.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_14RequestContext_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_14RequestContext_2__reduce_cython__(((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_14RequestContext_2__reduce_cython__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self) { PyObject *__pyx_v_state = 0; PyObject *__pyx_v__dict = 0; int __pyx_v_use_setstate; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":5 * cdef object _dict * cdef bint use_setstate * state = (self.gid, self.pid, self.uid, self.umask) # <<<<<<<<<<<<<< * _dict = getattr(self, '__dict__', None) * if _dict is not None: */ __pyx_t_1 = __Pyx_PyInt_From_gid_t(__pyx_v_self->gid); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_From_pid_t(__pyx_v_self->pid); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyInt_From_uid_t(__pyx_v_self->uid); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyInt_From_mode_t(__pyx_v_self->umask); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_t_4 = 0; __pyx_v_state = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; /* "(tree fragment)":6 * cdef bint use_setstate * state = (self.gid, self.pid, self.uid, self.umask) * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< * if _dict is not None: * state += (_dict,) */ __pyx_t_5 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v__dict = __pyx_t_5; __pyx_t_5 = 0; /* "(tree fragment)":7 * state = (self.gid, self.pid, self.uid, self.umask) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ __pyx_t_6 = (__pyx_v__dict != Py_None); __pyx_t_7 = (__pyx_t_6 != 0); if (__pyx_t_7) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) * if _dict is not None: * state += (_dict,) # <<<<<<<<<<<<<< * use_setstate = True * else: */ __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v__dict); __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); __pyx_t_4 = 0; /* "(tree fragment)":9 * if _dict is not None: * state += (_dict,) * use_setstate = True # <<<<<<<<<<<<<< * else: * use_setstate = False */ __pyx_v_use_setstate = 1; /* "(tree fragment)":7 * state = (self.gid, self.pid, self.uid, self.umask) * _dict = getattr(self, '__dict__', None) * if _dict is not None: # <<<<<<<<<<<<<< * state += (_dict,) * use_setstate = True */ goto __pyx_L3; } /* "(tree fragment)":11 * use_setstate = True * else: * use_setstate = False # <<<<<<<<<<<<<< * if use_setstate: * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, None), state */ /*else*/ { __pyx_v_use_setstate = 0; } __pyx_L3:; /* "(tree fragment)":12 * else: * use_setstate = False * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, None), state * else: */ __pyx_t_7 = (__pyx_v_use_setstate != 0); if (__pyx_t_7) { /* "(tree fragment)":13 * use_setstate = False * if use_setstate: * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, None), state # <<<<<<<<<<<<<< * else: * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_RequestContext); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_35895208); __Pyx_GIVEREF(__pyx_int_35895208); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_35895208); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); PyTuple_SET_ITEM(__pyx_t_5, 2, Py_None); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state); __pyx_t_4 = 0; __pyx_t_5 = 0; __pyx_r = __pyx_t_3; __pyx_t_3 = 0; goto __pyx_L0; /* "(tree fragment)":12 * else: * use_setstate = False * if use_setstate: # <<<<<<<<<<<<<< * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, None), state * else: */ } /* "(tree fragment)":15 * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, None), state * else: * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_RequestContext__set_state(self, __pyx_state) */ /*else*/ { __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_pyx_unpickle_RequestContext); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_INCREF(__pyx_int_35895208); __Pyx_GIVEREF(__pyx_int_35895208); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_int_35895208); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5); __pyx_t_3 = 0; __pyx_t_5 = 0; __pyx_r = __pyx_t_4; __pyx_t_4 = 0; goto __pyx_L0; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * cdef tuple state * cdef object _dict */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyfuse3.RequestContext.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v__dict); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":16 * else: * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_RequestContext__set_state(self, __pyx_state) */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_14RequestContext_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_14RequestContext_4__setstate_cython__[] = "RequestContext.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_14RequestContext_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_14RequestContext_4__setstate_cython__(((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_14RequestContext_4__setstate_cython__(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":17 * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle_RequestContext__set_state(self, __pyx_state) # <<<<<<<<<<<<<< */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(0, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_7pyfuse3___pyx_unpickle_RequestContext__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":16 * else: * return __pyx_unpickle_RequestContext, (type(self), 0x223b7a8, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle_RequestContext__set_state(self, __pyx_state) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.RequestContext.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":158 * cdef readonly object update_size * * def __cinit__(self): # <<<<<<<<<<<<<< * self.update_atime = False * self.update_mtime = False */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_13SetattrFields_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_7pyfuse3_13SetattrFields_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields___cinit__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_13SetattrFields___cinit__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__", 0); /* "pyfuse3.pyx":159 * * def __cinit__(self): * self.update_atime = False # <<<<<<<<<<<<<< * self.update_mtime = False * self.update_ctime = False */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->update_atime); __Pyx_DECREF(__pyx_v_self->update_atime); __pyx_v_self->update_atime = Py_False; /* "pyfuse3.pyx":160 * def __cinit__(self): * self.update_atime = False * self.update_mtime = False # <<<<<<<<<<<<<< * self.update_ctime = False * self.update_mode = False */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->update_mtime); __Pyx_DECREF(__pyx_v_self->update_mtime); __pyx_v_self->update_mtime = Py_False; /* "pyfuse3.pyx":161 * self.update_atime = False * self.update_mtime = False * self.update_ctime = False # <<<<<<<<<<<<<< * self.update_mode = False * self.update_uid = False */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->update_ctime); __Pyx_DECREF(__pyx_v_self->update_ctime); __pyx_v_self->update_ctime = Py_False; /* "pyfuse3.pyx":162 * self.update_mtime = False * self.update_ctime = False * self.update_mode = False # <<<<<<<<<<<<<< * self.update_uid = False * self.update_gid = False */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->update_mode); __Pyx_DECREF(__pyx_v_self->update_mode); __pyx_v_self->update_mode = Py_False; /* "pyfuse3.pyx":163 * self.update_ctime = False * self.update_mode = False * self.update_uid = False # <<<<<<<<<<<<<< * self.update_gid = False * self.update_size = False */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->update_uid); __Pyx_DECREF(__pyx_v_self->update_uid); __pyx_v_self->update_uid = Py_False; /* "pyfuse3.pyx":164 * self.update_mode = False * self.update_uid = False * self.update_gid = False # <<<<<<<<<<<<<< * self.update_size = False * */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->update_gid); __Pyx_DECREF(__pyx_v_self->update_gid); __pyx_v_self->update_gid = Py_False; /* "pyfuse3.pyx":165 * self.update_uid = False * self.update_gid = False * self.update_size = False # <<<<<<<<<<<<<< * * def __getstate__(self): */ __Pyx_INCREF(Py_False); __Pyx_GIVEREF(Py_False); __Pyx_GOTREF(__pyx_v_self->update_size); __Pyx_DECREF(__pyx_v_self->update_size); __pyx_v_self->update_size = Py_False; /* "pyfuse3.pyx":158 * cdef readonly object update_size * * def __cinit__(self): # <<<<<<<<<<<<<< * self.update_atime = False * self.update_mtime = False */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":167 * self.update_size = False * * def __getstate__(self): # <<<<<<<<<<<<<< * raise PicklingError("SetattrFields instances can't be pickled") * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_3__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_13SetattrFields_2__getstate__[] = "SetattrFields.__getstate__(self)"; static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_3__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getstate__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_2__getstate__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_2__getstate__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getstate__", 0); /* "pyfuse3.pyx":168 * * def __getstate__(self): * raise PicklingError("SetattrFields instances can't be pickled") # <<<<<<<<<<<<<< * * @cython.freelist(30) */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_PicklingError); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_3, __pyx_kp_u_SetattrFields_instances_can_t_be) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_SetattrFields_instances_can_t_be); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 168, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(3, 168, __pyx_L1_error) /* "pyfuse3.pyx":167 * self.update_size = False * * def __getstate__(self): # <<<<<<<<<<<<<< * raise PicklingError("SetattrFields instances can't be pickled") * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.SetattrFields.__getstate__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":150 * ''' * * cdef readonly object update_atime # <<<<<<<<<<<<<< * cdef readonly object update_mtime * cdef readonly object update_ctime */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_12update_atime_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_12update_atime_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_12update_atime___get__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_12update_atime___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->update_atime); __pyx_r = __pyx_v_self->update_atime; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":151 * * cdef readonly object update_atime * cdef readonly object update_mtime # <<<<<<<<<<<<<< * cdef readonly object update_ctime * cdef readonly object update_mode */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_12update_mtime_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_12update_mtime_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_12update_mtime___get__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_12update_mtime___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->update_mtime); __pyx_r = __pyx_v_self->update_mtime; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":152 * cdef readonly object update_atime * cdef readonly object update_mtime * cdef readonly object update_ctime # <<<<<<<<<<<<<< * cdef readonly object update_mode * cdef readonly object update_uid */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_12update_ctime_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_12update_ctime_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_12update_ctime___get__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_12update_ctime___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->update_ctime); __pyx_r = __pyx_v_self->update_ctime; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":153 * cdef readonly object update_mtime * cdef readonly object update_ctime * cdef readonly object update_mode # <<<<<<<<<<<<<< * cdef readonly object update_uid * cdef readonly object update_gid */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_11update_mode_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_11update_mode_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_11update_mode___get__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_11update_mode___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->update_mode); __pyx_r = __pyx_v_self->update_mode; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":154 * cdef readonly object update_ctime * cdef readonly object update_mode * cdef readonly object update_uid # <<<<<<<<<<<<<< * cdef readonly object update_gid * cdef readonly object update_size */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_10update_uid_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_10update_uid_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_10update_uid___get__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_10update_uid___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->update_uid); __pyx_r = __pyx_v_self->update_uid; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":155 * cdef readonly object update_mode * cdef readonly object update_uid * cdef readonly object update_gid # <<<<<<<<<<<<<< * cdef readonly object update_size * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_10update_gid_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_10update_gid_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_10update_gid___get__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_10update_gid___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->update_gid); __pyx_r = __pyx_v_self->update_gid; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":156 * cdef readonly object update_uid * cdef readonly object update_gid * cdef readonly object update_size # <<<<<<<<<<<<<< * * def __cinit__(self): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_11update_size_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_11update_size_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_11update_size___get__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_11update_size___get__(struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_self->update_size); __pyx_r = __pyx_v_self->update_size; goto __pyx_L0; /* function exit code */ __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_13SetattrFields_4__reduce_cython__[] = "SetattrFields.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_4__reduce_cython__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.SetattrFields.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_13SetattrFields_6__setstate_cython__[] = "SetattrFields.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_13SetattrFields_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_13SetattrFields_6__setstate_cython__(((struct __pyx_obj_7pyfuse3_SetattrFields *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_13SetattrFields_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.SetattrFields.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":184 * cdef struct_stat *attr * * def __cinit__(self): # <<<<<<<<<<<<<< * string.memset(&self.fuse_param, 0, sizeof(fuse_entry_param)) * self.attr = &self.fuse_param.attr */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes___cinit__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes___cinit__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__", 0); /* "pyfuse3.pyx":185 * * def __cinit__(self): * string.memset(&self.fuse_param, 0, sizeof(fuse_entry_param)) # <<<<<<<<<<<<<< * self.attr = &self.fuse_param.attr * self.fuse_param.generation = 0 */ (void)(memset((&__pyx_v_self->fuse_param), 0, (sizeof(struct fuse_entry_param)))); /* "pyfuse3.pyx":186 * def __cinit__(self): * string.memset(&self.fuse_param, 0, sizeof(fuse_entry_param)) * self.attr = &self.fuse_param.attr # <<<<<<<<<<<<<< * self.fuse_param.generation = 0 * self.fuse_param.entry_timeout = 300 */ __pyx_v_self->attr = (&__pyx_v_self->fuse_param.attr); /* "pyfuse3.pyx":187 * string.memset(&self.fuse_param, 0, sizeof(fuse_entry_param)) * self.attr = &self.fuse_param.attr * self.fuse_param.generation = 0 # <<<<<<<<<<<<<< * self.fuse_param.entry_timeout = 300 * self.fuse_param.attr_timeout = 300 */ __pyx_v_self->fuse_param.generation = 0; /* "pyfuse3.pyx":188 * self.attr = &self.fuse_param.attr * self.fuse_param.generation = 0 * self.fuse_param.entry_timeout = 300 # <<<<<<<<<<<<<< * self.fuse_param.attr_timeout = 300 * */ __pyx_v_self->fuse_param.entry_timeout = 300.0; /* "pyfuse3.pyx":189 * self.fuse_param.generation = 0 * self.fuse_param.entry_timeout = 300 * self.fuse_param.attr_timeout = 300 # <<<<<<<<<<<<<< * * self.attr.st_mode = S_IFREG */ __pyx_v_self->fuse_param.attr_timeout = 300.0; /* "pyfuse3.pyx":191 * self.fuse_param.attr_timeout = 300 * * self.attr.st_mode = S_IFREG # <<<<<<<<<<<<<< * self.attr.st_blksize = 4096 * self.attr.st_nlink = 1 */ __pyx_v_self->attr->st_mode = S_IFREG; /* "pyfuse3.pyx":192 * * self.attr.st_mode = S_IFREG * self.attr.st_blksize = 4096 # <<<<<<<<<<<<<< * self.attr.st_nlink = 1 * */ __pyx_v_self->attr->st_blksize = 0x1000; /* "pyfuse3.pyx":193 * self.attr.st_mode = S_IFREG * self.attr.st_blksize = 4096 * self.attr.st_nlink = 1 # <<<<<<<<<<<<<< * * @property */ __pyx_v_self->attr->st_nlink = 1; /* "pyfuse3.pyx":184 * cdef struct_stat *attr * * def __cinit__(self): # <<<<<<<<<<<<<< * string.memset(&self.fuse_param, 0, sizeof(fuse_entry_param)) * self.attr = &self.fuse_param.attr */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":196 * * @property * def st_ino(self): # <<<<<<<<<<<<<< * return self.fuse_param.ino * @st_ino.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_6st_ino_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_6st_ino_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_6st_ino___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_6st_ino___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":197 * @property * def st_ino(self): * return self.fuse_param.ino # <<<<<<<<<<<<<< * @st_ino.setter * def st_ino(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_fuse_ino_t(__pyx_v_self->fuse_param.ino); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 197, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":196 * * @property * def st_ino(self): # <<<<<<<<<<<<<< * return self.fuse_param.ino * @st_ino.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_ino.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":199 * return self.fuse_param.ino * @st_ino.setter * def st_ino(self, val): # <<<<<<<<<<<<<< * self.fuse_param.ino = val * self.attr.st_ino = val */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_6st_ino_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_6st_ino_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_6st_ino_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_6st_ino_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations fuse_ino_t __pyx_t_1; ino_t __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":200 * @st_ino.setter * def st_ino(self, val): * self.fuse_param.ino = val # <<<<<<<<<<<<<< * self.attr.st_ino = val * */ __pyx_t_1 = __Pyx_PyInt_As_fuse_ino_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((fuse_ino_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 200, __pyx_L1_error) __pyx_v_self->fuse_param.ino = __pyx_t_1; /* "pyfuse3.pyx":201 * def st_ino(self, val): * self.fuse_param.ino = val * self.attr.st_ino = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_2 = __Pyx_PyInt_As_ino_t(__pyx_v_val); if (unlikely((__pyx_t_2 == ((ino_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 201, __pyx_L1_error) __pyx_v_self->attr->st_ino = __pyx_t_2; /* "pyfuse3.pyx":199 * return self.fuse_param.ino * @st_ino.setter * def st_ino(self, val): # <<<<<<<<<<<<<< * self.fuse_param.ino = val * self.attr.st_ino = val */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_ino.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":204 * * @property * def generation(self): # <<<<<<<<<<<<<< * '''The inode generation number''' * return self.fuse_param.generation */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_10generation_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_10generation_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_10generation___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_10generation___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":206 * def generation(self): * '''The inode generation number''' * return self.fuse_param.generation # <<<<<<<<<<<<<< * @generation.setter * def generation(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->fuse_param.generation); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":204 * * @property * def generation(self): # <<<<<<<<<<<<<< * '''The inode generation number''' * return self.fuse_param.generation */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.generation.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":208 * return self.fuse_param.generation * @generation.setter * def generation(self, val): # <<<<<<<<<<<<<< * self.fuse_param.generation = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_10generation_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_10generation_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_10generation_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_10generation_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations uint64_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":209 * @generation.setter * def generation(self, val): * self.fuse_param.generation = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_uint64_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 209, __pyx_L1_error) __pyx_v_self->fuse_param.generation = __pyx_t_1; /* "pyfuse3.pyx":208 * return self.fuse_param.generation * @generation.setter * def generation(self, val): # <<<<<<<<<<<<<< * self.fuse_param.generation = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.generation.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":212 * * @property * def attr_timeout(self): # <<<<<<<<<<<<<< * '''Validity timeout for the attributes of the directory entry * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_12attr_timeout_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_12attr_timeout_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_12attr_timeout___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_12attr_timeout___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":217 * Floating point numbers may be used. Units are seconds. * ''' * return self.fuse_param.attr_timeout # <<<<<<<<<<<<<< * @attr_timeout.setter * def attr_timeout(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->fuse_param.attr_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 217, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":212 * * @property * def attr_timeout(self): # <<<<<<<<<<<<<< * '''Validity timeout for the attributes of the directory entry * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.attr_timeout.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":219 * return self.fuse_param.attr_timeout * @attr_timeout.setter * def attr_timeout(self, val): # <<<<<<<<<<<<<< * self.fuse_param.attr_timeout = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_12attr_timeout_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_12attr_timeout_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_12attr_timeout_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_12attr_timeout_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":220 * @attr_timeout.setter * def attr_timeout(self, val): * self.fuse_param.attr_timeout = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 220, __pyx_L1_error) __pyx_v_self->fuse_param.attr_timeout = __pyx_t_1; /* "pyfuse3.pyx":219 * return self.fuse_param.attr_timeout * @attr_timeout.setter * def attr_timeout(self, val): # <<<<<<<<<<<<<< * self.fuse_param.attr_timeout = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.attr_timeout.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":223 * * @property * def entry_timeout(self): # <<<<<<<<<<<<<< * '''Validity timeout for the name/existence of the directory entry * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_13entry_timeout_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_13entry_timeout_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_13entry_timeout___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_13entry_timeout___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":228 * Floating point numbers may be used. Units are seconds. * ''' * return self.fuse_param.entry_timeout # <<<<<<<<<<<<<< * @entry_timeout.setter * def entry_timeout(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyFloat_FromDouble(__pyx_v_self->fuse_param.entry_timeout); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 228, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":223 * * @property * def entry_timeout(self): # <<<<<<<<<<<<<< * '''Validity timeout for the name/existence of the directory entry * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.entry_timeout.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":230 * return self.fuse_param.entry_timeout * @entry_timeout.setter * def entry_timeout(self, val): # <<<<<<<<<<<<<< * self.fuse_param.entry_timeout = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_13entry_timeout_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_13entry_timeout_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_13entry_timeout_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_13entry_timeout_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations double __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":231 * @entry_timeout.setter * def entry_timeout(self, val): * self.fuse_param.entry_timeout = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __pyx_PyFloat_AsDouble(__pyx_v_val); if (unlikely((__pyx_t_1 == (double)-1) && PyErr_Occurred())) __PYX_ERR(3, 231, __pyx_L1_error) __pyx_v_self->fuse_param.entry_timeout = __pyx_t_1; /* "pyfuse3.pyx":230 * return self.fuse_param.entry_timeout * @entry_timeout.setter * def entry_timeout(self, val): # <<<<<<<<<<<<<< * self.fuse_param.entry_timeout = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.entry_timeout.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":234 * * @property * def st_mode(self): # <<<<<<<<<<<<<< * return self.attr.st_mode * @st_mode.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_7st_mode_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_7st_mode_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_7st_mode___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_7st_mode___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":235 * @property * def st_mode(self): * return self.attr.st_mode # <<<<<<<<<<<<<< * @st_mode.setter * def st_mode(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_mode_t(__pyx_v_self->attr->st_mode); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":234 * * @property * def st_mode(self): # <<<<<<<<<<<<<< * return self.attr.st_mode * @st_mode.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_mode.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":237 * return self.attr.st_mode * @st_mode.setter * def st_mode(self, val): # <<<<<<<<<<<<<< * self.attr.st_mode = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_7st_mode_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_7st_mode_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_7st_mode_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_7st_mode_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations mode_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":238 * @st_mode.setter * def st_mode(self, val): * self.attr.st_mode = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_mode_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((mode_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 238, __pyx_L1_error) __pyx_v_self->attr->st_mode = __pyx_t_1; /* "pyfuse3.pyx":237 * return self.attr.st_mode * @st_mode.setter * def st_mode(self, val): # <<<<<<<<<<<<<< * self.attr.st_mode = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_mode.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":241 * * @property * def st_nlink(self): # <<<<<<<<<<<<<< * return self.attr.st_nlink * @st_nlink.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_8st_nlink_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_8st_nlink_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_8st_nlink___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_8st_nlink___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":242 * @property * def st_nlink(self): * return self.attr.st_nlink # <<<<<<<<<<<<<< * @st_nlink.setter * def st_nlink(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_nlink_t(__pyx_v_self->attr->st_nlink); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 242, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":241 * * @property * def st_nlink(self): # <<<<<<<<<<<<<< * return self.attr.st_nlink * @st_nlink.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_nlink.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":244 * return self.attr.st_nlink * @st_nlink.setter * def st_nlink(self, val): # <<<<<<<<<<<<<< * self.attr.st_nlink = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_8st_nlink_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_8st_nlink_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_8st_nlink_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_8st_nlink_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations nlink_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":245 * @st_nlink.setter * def st_nlink(self, val): * self.attr.st_nlink = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_nlink_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((nlink_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 245, __pyx_L1_error) __pyx_v_self->attr->st_nlink = __pyx_t_1; /* "pyfuse3.pyx":244 * return self.attr.st_nlink * @st_nlink.setter * def st_nlink(self, val): # <<<<<<<<<<<<<< * self.attr.st_nlink = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_nlink.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":248 * * @property * def st_uid(self): # <<<<<<<<<<<<<< * return self.attr.st_uid * @st_uid.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_6st_uid_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_6st_uid_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_6st_uid___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_6st_uid___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":249 * @property * def st_uid(self): * return self.attr.st_uid # <<<<<<<<<<<<<< * @st_uid.setter * def st_uid(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_uid_t(__pyx_v_self->attr->st_uid); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 249, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":248 * * @property * def st_uid(self): # <<<<<<<<<<<<<< * return self.attr.st_uid * @st_uid.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_uid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":251 * return self.attr.st_uid * @st_uid.setter * def st_uid(self, val): # <<<<<<<<<<<<<< * self.attr.st_uid = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_6st_uid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_6st_uid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_6st_uid_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_6st_uid_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations uid_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":252 * @st_uid.setter * def st_uid(self, val): * self.attr.st_uid = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_uid_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((uid_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 252, __pyx_L1_error) __pyx_v_self->attr->st_uid = __pyx_t_1; /* "pyfuse3.pyx":251 * return self.attr.st_uid * @st_uid.setter * def st_uid(self, val): # <<<<<<<<<<<<<< * self.attr.st_uid = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_uid.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":255 * * @property * def st_gid(self): # <<<<<<<<<<<<<< * return self.attr.st_gid * @st_gid.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_6st_gid_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_6st_gid_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_6st_gid___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_6st_gid___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":256 * @property * def st_gid(self): * return self.attr.st_gid # <<<<<<<<<<<<<< * @st_gid.setter * def st_gid(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_gid_t(__pyx_v_self->attr->st_gid); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 256, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":255 * * @property * def st_gid(self): # <<<<<<<<<<<<<< * return self.attr.st_gid * @st_gid.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_gid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":258 * return self.attr.st_gid * @st_gid.setter * def st_gid(self, val): # <<<<<<<<<<<<<< * self.attr.st_gid = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_6st_gid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_6st_gid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_6st_gid_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_6st_gid_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations gid_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":259 * @st_gid.setter * def st_gid(self, val): * self.attr.st_gid = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_gid_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((gid_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 259, __pyx_L1_error) __pyx_v_self->attr->st_gid = __pyx_t_1; /* "pyfuse3.pyx":258 * return self.attr.st_gid * @st_gid.setter * def st_gid(self, val): # <<<<<<<<<<<<<< * self.attr.st_gid = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_gid.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":262 * * @property * def st_rdev(self): # <<<<<<<<<<<<<< * return self.attr.st_rdev * @st_rdev.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_7st_rdev_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_7st_rdev_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_7st_rdev___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_7st_rdev___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":263 * @property * def st_rdev(self): * return self.attr.st_rdev # <<<<<<<<<<<<<< * @st_rdev.setter * def st_rdev(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_dev_t(__pyx_v_self->attr->st_rdev); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 263, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":262 * * @property * def st_rdev(self): # <<<<<<<<<<<<<< * return self.attr.st_rdev * @st_rdev.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_rdev.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":265 * return self.attr.st_rdev * @st_rdev.setter * def st_rdev(self, val): # <<<<<<<<<<<<<< * self.attr.st_rdev = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_7st_rdev_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_7st_rdev_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_7st_rdev_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_7st_rdev_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations dev_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":266 * @st_rdev.setter * def st_rdev(self, val): * self.attr.st_rdev = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_dev_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((dev_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 266, __pyx_L1_error) __pyx_v_self->attr->st_rdev = __pyx_t_1; /* "pyfuse3.pyx":265 * return self.attr.st_rdev * @st_rdev.setter * def st_rdev(self, val): # <<<<<<<<<<<<<< * self.attr.st_rdev = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_rdev.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":269 * * @property * def st_size(self): # <<<<<<<<<<<<<< * return self.attr.st_size * @st_size.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_7st_size_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_7st_size_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_7st_size___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_7st_size___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":270 * @property * def st_size(self): * return self.attr.st_size # <<<<<<<<<<<<<< * @st_size.setter * def st_size(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_off_t(__pyx_v_self->attr->st_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 270, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":269 * * @property * def st_size(self): # <<<<<<<<<<<<<< * return self.attr.st_size * @st_size.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":272 * return self.attr.st_size * @st_size.setter * def st_size(self, val): # <<<<<<<<<<<<<< * self.attr.st_size = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_7st_size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_7st_size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_7st_size_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_7st_size_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations off_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":273 * @st_size.setter * def st_size(self, val): * self.attr.st_size = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_off_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((off_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 273, __pyx_L1_error) __pyx_v_self->attr->st_size = __pyx_t_1; /* "pyfuse3.pyx":272 * return self.attr.st_size * @st_size.setter * def st_size(self, val): # <<<<<<<<<<<<<< * self.attr.st_size = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_size.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":276 * * @property * def st_blocks(self): # <<<<<<<<<<<<<< * return self.attr.st_blocks * @st_blocks.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_9st_blocks_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_9st_blocks_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_9st_blocks___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_9st_blocks___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":277 * @property * def st_blocks(self): * return self.attr.st_blocks # <<<<<<<<<<<<<< * @st_blocks.setter * def st_blocks(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_blkcnt_t(__pyx_v_self->attr->st_blocks); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 277, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":276 * * @property * def st_blocks(self): # <<<<<<<<<<<<<< * return self.attr.st_blocks * @st_blocks.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_blocks.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":279 * return self.attr.st_blocks * @st_blocks.setter * def st_blocks(self, val): # <<<<<<<<<<<<<< * self.attr.st_blocks = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_9st_blocks_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_9st_blocks_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_9st_blocks_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_9st_blocks_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations blkcnt_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":280 * @st_blocks.setter * def st_blocks(self, val): * self.attr.st_blocks = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_blkcnt_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((blkcnt_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 280, __pyx_L1_error) __pyx_v_self->attr->st_blocks = __pyx_t_1; /* "pyfuse3.pyx":279 * return self.attr.st_blocks * @st_blocks.setter * def st_blocks(self, val): # <<<<<<<<<<<<<< * self.attr.st_blocks = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_blocks.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":283 * * @property * def st_blksize(self): # <<<<<<<<<<<<<< * return self.attr.st_blksize * @st_blksize.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_10st_blksize_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_10st_blksize_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_10st_blksize___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_10st_blksize___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":284 * @property * def st_blksize(self): * return self.attr.st_blksize # <<<<<<<<<<<<<< * @st_blksize.setter * def st_blksize(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_blksize_t(__pyx_v_self->attr->st_blksize); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 284, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":283 * * @property * def st_blksize(self): # <<<<<<<<<<<<<< * return self.attr.st_blksize * @st_blksize.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_blksize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":286 * return self.attr.st_blksize * @st_blksize.setter * def st_blksize(self, val): # <<<<<<<<<<<<<< * self.attr.st_blksize = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_10st_blksize_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_10st_blksize_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_10st_blksize_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_10st_blksize_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations blksize_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":287 * @st_blksize.setter * def st_blksize(self, val): * self.attr.st_blksize = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_blksize_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((blksize_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 287, __pyx_L1_error) __pyx_v_self->attr->st_blksize = __pyx_t_1; /* "pyfuse3.pyx":286 * return self.attr.st_blksize * @st_blksize.setter * def st_blksize(self, val): # <<<<<<<<<<<<<< * self.attr.st_blksize = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_blksize.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":290 * * @property * def st_atime_ns(self): # <<<<<<<<<<<<<< * '''Time of last access in (integer) nanoseconds''' * return (int(self.attr.st_atime) * _NANOS_PER_SEC + GET_ATIME_NS(self.attr)) */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_11st_atime_ns_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_11st_atime_ns_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_11st_atime_ns___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_11st_atime_ns___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":292 * def st_atime_ns(self): * '''Time of last access in (integer) nanoseconds''' * return (int(self.attr.st_atime) * _NANOS_PER_SEC + GET_ATIME_NS(self.attr)) # <<<<<<<<<<<<<< * @st_atime_ns.setter * def st_atime_ns(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->attr->st_atime); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_long(GET_ATIME_NS(__pyx_v_self->attr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 292, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyfuse3.pyx":290 * * @property * def st_atime_ns(self): # <<<<<<<<<<<<<< * '''Time of last access in (integer) nanoseconds''' * return (int(self.attr.st_atime) * _NANOS_PER_SEC + GET_ATIME_NS(self.attr)) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_atime_ns.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":294 * return (int(self.attr.st_atime) * _NANOS_PER_SEC + GET_ATIME_NS(self.attr)) * @st_atime_ns.setter * def st_atime_ns(self, val): # <<<<<<<<<<<<<< * self.attr.st_atime = val // _NANOS_PER_SEC * SET_ATIME_NS(self.attr, val % _NANOS_PER_SEC) */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_11st_atime_ns_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_11st_atime_ns_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_11st_atime_ns_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_11st_atime_ns_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; time_t __pyx_t_3; long __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":295 * @st_atime_ns.setter * def st_atime_ns(self, val): * self.attr.st_atime = val // _NANOS_PER_SEC # <<<<<<<<<<<<<< * SET_ATIME_NS(self.attr, val % _NANOS_PER_SEC) * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_FloorDivide(__pyx_v_val, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 295, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyInt_As_time_t(__pyx_t_2); if (unlikely((__pyx_t_3 == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 295, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_self->attr->st_atime = __pyx_t_3; /* "pyfuse3.pyx":296 * def st_atime_ns(self, val): * self.attr.st_atime = val // _NANOS_PER_SEC * SET_ATIME_NS(self.attr, val % _NANOS_PER_SEC) # <<<<<<<<<<<<<< * * @property */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyNumber_Remainder(__pyx_v_val, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 296, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_4 == (long)-1) && PyErr_Occurred())) __PYX_ERR(3, 296, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_ATIME_NS(__pyx_v_self->attr, __pyx_t_4); /* "pyfuse3.pyx":294 * return (int(self.attr.st_atime) * _NANOS_PER_SEC + GET_ATIME_NS(self.attr)) * @st_atime_ns.setter * def st_atime_ns(self, val): # <<<<<<<<<<<<<< * self.attr.st_atime = val // _NANOS_PER_SEC * SET_ATIME_NS(self.attr, val % _NANOS_PER_SEC) */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_atime_ns.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":299 * * @property * def st_mtime_ns(self): # <<<<<<<<<<<<<< * '''Time of last modification in (integer) nanoseconds''' * return (int(self.attr.st_mtime) * _NANOS_PER_SEC + GET_MTIME_NS(self.attr)) */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_11st_mtime_ns_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_11st_mtime_ns_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_11st_mtime_ns___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_11st_mtime_ns___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":301 * def st_mtime_ns(self): * '''Time of last modification in (integer) nanoseconds''' * return (int(self.attr.st_mtime) * _NANOS_PER_SEC + GET_MTIME_NS(self.attr)) # <<<<<<<<<<<<<< * @st_mtime_ns.setter * def st_mtime_ns(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->attr->st_mtime); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_long(GET_MTIME_NS(__pyx_v_self->attr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 301, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyfuse3.pyx":299 * * @property * def st_mtime_ns(self): # <<<<<<<<<<<<<< * '''Time of last modification in (integer) nanoseconds''' * return (int(self.attr.st_mtime) * _NANOS_PER_SEC + GET_MTIME_NS(self.attr)) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_mtime_ns.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":303 * return (int(self.attr.st_mtime) * _NANOS_PER_SEC + GET_MTIME_NS(self.attr)) * @st_mtime_ns.setter * def st_mtime_ns(self, val): # <<<<<<<<<<<<<< * self.attr.st_mtime = val // _NANOS_PER_SEC * SET_MTIME_NS(self.attr, val % _NANOS_PER_SEC) */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_11st_mtime_ns_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_11st_mtime_ns_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_11st_mtime_ns_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_11st_mtime_ns_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; time_t __pyx_t_3; long __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":304 * @st_mtime_ns.setter * def st_mtime_ns(self, val): * self.attr.st_mtime = val // _NANOS_PER_SEC # <<<<<<<<<<<<<< * SET_MTIME_NS(self.attr, val % _NANOS_PER_SEC) * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_FloorDivide(__pyx_v_val, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyInt_As_time_t(__pyx_t_2); if (unlikely((__pyx_t_3 == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 304, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_self->attr->st_mtime = __pyx_t_3; /* "pyfuse3.pyx":305 * def st_mtime_ns(self, val): * self.attr.st_mtime = val // _NANOS_PER_SEC * SET_MTIME_NS(self.attr, val % _NANOS_PER_SEC) # <<<<<<<<<<<<<< * * @property */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyNumber_Remainder(__pyx_v_val, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 305, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_4 == (long)-1) && PyErr_Occurred())) __PYX_ERR(3, 305, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_MTIME_NS(__pyx_v_self->attr, __pyx_t_4); /* "pyfuse3.pyx":303 * return (int(self.attr.st_mtime) * _NANOS_PER_SEC + GET_MTIME_NS(self.attr)) * @st_mtime_ns.setter * def st_mtime_ns(self, val): # <<<<<<<<<<<<<< * self.attr.st_mtime = val // _NANOS_PER_SEC * SET_MTIME_NS(self.attr, val % _NANOS_PER_SEC) */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_mtime_ns.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":308 * * @property * def st_ctime_ns(self): # <<<<<<<<<<<<<< * '''Time of last inode modification in (integer) nanoseconds''' * return (int(self.attr.st_ctime) * _NANOS_PER_SEC + GET_CTIME_NS(self.attr)) */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_11st_ctime_ns_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_11st_ctime_ns_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_11st_ctime_ns___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_11st_ctime_ns___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":310 * def st_ctime_ns(self): * '''Time of last inode modification in (integer) nanoseconds''' * return (int(self.attr.st_ctime) * _NANOS_PER_SEC + GET_CTIME_NS(self.attr)) # <<<<<<<<<<<<<< * @st_ctime_ns.setter * def st_ctime_ns(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_time_t(__pyx_v_self->attr->st_ctime); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)(&PyInt_Type)), __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = PyNumber_Multiply(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyInt_From_long(GET_CTIME_NS(__pyx_v_self->attr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_Add(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 310, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyfuse3.pyx":308 * * @property * def st_ctime_ns(self): # <<<<<<<<<<<<<< * '''Time of last inode modification in (integer) nanoseconds''' * return (int(self.attr.st_ctime) * _NANOS_PER_SEC + GET_CTIME_NS(self.attr)) */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_ctime_ns.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":312 * return (int(self.attr.st_ctime) * _NANOS_PER_SEC + GET_CTIME_NS(self.attr)) * @st_ctime_ns.setter * def st_ctime_ns(self, val): # <<<<<<<<<<<<<< * self.attr.st_ctime = val // _NANOS_PER_SEC * SET_CTIME_NS(self.attr, val % _NANOS_PER_SEC) */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_11st_ctime_ns_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_11st_ctime_ns_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_11st_ctime_ns_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_11st_ctime_ns_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; time_t __pyx_t_3; long __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":313 * @st_ctime_ns.setter * def st_ctime_ns(self, val): * self.attr.st_ctime = val // _NANOS_PER_SEC # <<<<<<<<<<<<<< * SET_CTIME_NS(self.attr, val % _NANOS_PER_SEC) * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_FloorDivide(__pyx_v_val, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 313, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyInt_As_time_t(__pyx_t_2); if (unlikely((__pyx_t_3 == ((time_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 313, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_self->attr->st_ctime = __pyx_t_3; /* "pyfuse3.pyx":314 * def st_ctime_ns(self, val): * self.attr.st_ctime = val // _NANOS_PER_SEC * SET_CTIME_NS(self.attr, val % _NANOS_PER_SEC) # <<<<<<<<<<<<<< * * @property */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyNumber_Remainder(__pyx_v_val, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 314, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_4 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_4 == (long)-1) && PyErr_Occurred())) __PYX_ERR(3, 314, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_CTIME_NS(__pyx_v_self->attr, __pyx_t_4); /* "pyfuse3.pyx":312 * return (int(self.attr.st_ctime) * _NANOS_PER_SEC + GET_CTIME_NS(self.attr)) * @st_ctime_ns.setter * def st_ctime_ns(self, val): # <<<<<<<<<<<<<< * self.attr.st_ctime = val // _NANOS_PER_SEC * SET_CTIME_NS(self.attr, val % _NANOS_PER_SEC) */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_ctime_ns.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":317 * * @property * def st_birthtime_ns(self): # <<<<<<<<<<<<<< * '''Time of inode creation in (integer) nanoseconds. * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_15st_birthtime_ns_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_15st_birthtime_ns_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_15st_birthtime_ns___get__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_15st_birthtime_ns___get__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":325 * # Use C macro to prevent compiler error on Linux * # (where st_birthtime does not exist) * return int(GET_BIRTHTIME(self.attr) * _NANOS_PER_SEC # <<<<<<<<<<<<<< * + GET_BIRTHTIME_NS(self.attr)) * */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_long(GET_BIRTHTIME(__pyx_v_self->attr)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":326 * # (where st_birthtime does not exist) * return int(GET_BIRTHTIME(self.attr) * _NANOS_PER_SEC * + GET_BIRTHTIME_NS(self.attr)) # <<<<<<<<<<<<<< * * @st_birthtime_ns.setter */ __pyx_t_2 = __Pyx_PyInt_From_long(GET_BIRTHTIME_NS(__pyx_v_self->attr)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyNumber_Add(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 326, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":325 * # Use C macro to prevent compiler error on Linux * # (where st_birthtime does not exist) * return int(GET_BIRTHTIME(self.attr) * _NANOS_PER_SEC # <<<<<<<<<<<<<< * + GET_BIRTHTIME_NS(self.attr)) * */ __pyx_t_2 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 325, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_r = __pyx_t_2; __pyx_t_2 = 0; goto __pyx_L0; /* "pyfuse3.pyx":317 * * @property * def st_birthtime_ns(self): # <<<<<<<<<<<<<< * '''Time of inode creation in (integer) nanoseconds. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_birthtime_ns.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":329 * * @st_birthtime_ns.setter * def st_birthtime_ns(self, val): # <<<<<<<<<<<<<< * # Use C macro to prevent compiler error on Linux * # (where st_birthtime does not exist) */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_15EntryAttributes_15st_birthtime_ns_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_15EntryAttributes_15st_birthtime_ns_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_15st_birthtime_ns_2__set__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_15EntryAttributes_15st_birthtime_ns_2__set__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; long __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":332 * # Use C macro to prevent compiler error on Linux * # (where st_birthtime does not exist) * SET_BIRTHTIME(self.attr, val // _NANOS_PER_SEC) # <<<<<<<<<<<<<< * SET_BIRTHTIME_NS(self.attr, val % _NANOS_PER_SEC) * */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyNumber_FloorDivide(__pyx_v_val, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_3 = __Pyx_PyInt_As_long(__pyx_t_2); if (unlikely((__pyx_t_3 == (long)-1) && PyErr_Occurred())) __PYX_ERR(3, 332, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; SET_BIRTHTIME(__pyx_v_self->attr, __pyx_t_3); /* "pyfuse3.pyx":333 * # (where st_birthtime does not exist) * SET_BIRTHTIME(self.attr, val // _NANOS_PER_SEC) * SET_BIRTHTIME_NS(self.attr, val % _NANOS_PER_SEC) # <<<<<<<<<<<<<< * * # Pickling and copy support */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_NANOS_PER_SEC); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = PyNumber_Remainder(__pyx_v_val, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 333, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyInt_As_long(__pyx_t_1); if (unlikely((__pyx_t_3 == (long)-1) && PyErr_Occurred())) __PYX_ERR(3, 333, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; SET_BIRTHTIME_NS(__pyx_v_self->attr, __pyx_t_3); /* "pyfuse3.pyx":329 * * @st_birthtime_ns.setter * def st_birthtime_ns(self, val): # <<<<<<<<<<<<<< * # Use C macro to prevent compiler error on Linux * # (where st_birthtime does not exist) */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_AddTraceback("pyfuse3.EntryAttributes.st_birthtime_ns.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":336 * * # Pickling and copy support * def __getstate__(self): # <<<<<<<<<<<<<< * state = dict() * for k in ('st_ino', 'generation', 'entry_timeout', 'attr_timeout', */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_3__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_15EntryAttributes_2__getstate__[] = "EntryAttributes.__getstate__(self)"; static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_3__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getstate__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_2__getstate__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_2__getstate__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_v_state = NULL; PyObject *__pyx_v_k = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getstate__", 0); /* "pyfuse3.pyx":337 * # Pickling and copy support * def __getstate__(self): * state = dict() # <<<<<<<<<<<<<< * for k in ('st_ino', 'generation', 'entry_timeout', 'attr_timeout', * 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev', */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 337, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":338 * def __getstate__(self): * state = dict() * for k in ('st_ino', 'generation', 'entry_timeout', 'attr_timeout', # <<<<<<<<<<<<<< * 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev', * 'st_size', 'st_blksize', 'st_blocks', 'st_atime_ns', */ __pyx_t_1 = __pyx_tuple__42; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= 16) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(3, 338, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_k, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "pyfuse3.pyx":342 * 'st_size', 'st_blksize', 'st_blocks', 'st_atime_ns', * 'st_ctime_ns', 'st_mtime_ns', 'st_birthtime_ns'): * state[k] = getattr(self, k) # <<<<<<<<<<<<<< * return state * */ __pyx_t_3 = __Pyx_GetAttr(((PyObject *)__pyx_v_self), __pyx_v_k); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 342, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (unlikely(PyDict_SetItem(__pyx_v_state, __pyx_v_k, __pyx_t_3) < 0)) __PYX_ERR(3, 342, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":338 * def __getstate__(self): * state = dict() * for k in ('st_ino', 'generation', 'entry_timeout', 'attr_timeout', # <<<<<<<<<<<<<< * 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev', * 'st_size', 'st_blksize', 'st_blocks', 'st_atime_ns', */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":343 * 'st_ctime_ns', 'st_mtime_ns', 'st_birthtime_ns'): * state[k] = getattr(self, k) * return state # <<<<<<<<<<<<<< * * def __setstate__(self, state): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_state); __pyx_r = __pyx_v_state; goto __pyx_L0; /* "pyfuse3.pyx":336 * * # Pickling and copy support * def __getstate__(self): # <<<<<<<<<<<<<< * state = dict() * for k in ('st_ino', 'generation', 'entry_timeout', 'attr_timeout', */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.EntryAttributes.__getstate__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v_k); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":345 * return state * * def __setstate__(self, state): # <<<<<<<<<<<<<< * for (k,v) in state.items(): * setattr(self, k, v) */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_5__setstate__(PyObject *__pyx_v_self, PyObject *__pyx_v_state); /*proto*/ static char __pyx_doc_7pyfuse3_15EntryAttributes_4__setstate__[] = "EntryAttributes.__setstate__(self, state)"; static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_5__setstate__(PyObject *__pyx_v_self, PyObject *__pyx_v_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_4__setstate__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_4__setstate__(struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, PyObject *__pyx_v_state) { PyObject *__pyx_v_k = NULL; PyObject *__pyx_v_v = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate__", 0); /* "pyfuse3.pyx":346 * * def __setstate__(self, state): * for (k,v) in state.items(): # <<<<<<<<<<<<<< * setattr(self, k, v) * */ __pyx_t_2 = 0; if (unlikely(__pyx_v_state == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); __PYX_ERR(3, 346, __pyx_L1_error) } __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_state, 0, __pyx_n_s_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_5; __pyx_t_5 = 0; while (1) { __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4); if (unlikely(__pyx_t_7 == 0)) break; if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(3, 346, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_k, __pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_6); __pyx_t_6 = 0; /* "pyfuse3.pyx":347 * def __setstate__(self, state): * for (k,v) in state.items(): * setattr(self, k, v) # <<<<<<<<<<<<<< * * */ __pyx_t_8 = PyObject_SetAttr(((PyObject *)__pyx_v_self), __pyx_v_k, __pyx_v_v); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(3, 347, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":345 * return state * * def __setstate__(self, state): # <<<<<<<<<<<<<< * for (k,v) in state.items(): * setattr(self, k, v) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pyfuse3.EntryAttributes.__setstate__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_k); __Pyx_XDECREF(__pyx_v_v); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_15EntryAttributes_6__reduce_cython__[] = "EntryAttributes.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_6__reduce_cython__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__43, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_15EntryAttributes_8__setstate_cython__[] = "EntryAttributes.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_15EntryAttributes_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_15EntryAttributes_8__setstate_cython__(((struct __pyx_obj_7pyfuse3_EntryAttributes *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_15EntryAttributes_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__44, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.EntryAttributes.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":363 * cdef public bint nonseekable * * def __cinit__(self, fh=0, direct_io=0, keep_cache=1, nonseekable=0): # <<<<<<<<<<<<<< * self.fh = fh * self.direct_io = direct_io */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_8FileInfo_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_7pyfuse3_8FileInfo_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_fh = 0; PyObject *__pyx_v_direct_io = 0; PyObject *__pyx_v_keep_cache = 0; PyObject *__pyx_v_nonseekable = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fh,&__pyx_n_s_direct_io,&__pyx_n_s_keep_cache,&__pyx_n_s_nonseekable,0}; PyObject* values[4] = {0,0,0,0}; values[0] = ((PyObject *)__pyx_int_0); values[1] = ((PyObject *)__pyx_int_0); values[2] = ((PyObject *)__pyx_int_1); values[3] = ((PyObject *)__pyx_int_0); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fh); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_direct_io); if (value) { values[1] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_keep_cache); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nonseekable); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(3, 363, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_fh = values[0]; __pyx_v_direct_io = values[1]; __pyx_v_keep_cache = values[2]; __pyx_v_nonseekable = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 0, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 363, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.FileInfo.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_8FileInfo___cinit__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self), __pyx_v_fh, __pyx_v_direct_io, __pyx_v_keep_cache, __pyx_v_nonseekable); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_8FileInfo___cinit__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_fh, PyObject *__pyx_v_direct_io, PyObject *__pyx_v_keep_cache, PyObject *__pyx_v_nonseekable) { int __pyx_r; __Pyx_RefNannyDeclarations uint64_t __pyx_t_1; int __pyx_t_2; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); /* "pyfuse3.pyx":364 * * def __cinit__(self, fh=0, direct_io=0, keep_cache=1, nonseekable=0): * self.fh = fh # <<<<<<<<<<<<<< * self.direct_io = direct_io * self.keep_cache = keep_cache */ __pyx_t_1 = __Pyx_PyInt_As_uint64_t(__pyx_v_fh); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 364, __pyx_L1_error) __pyx_v_self->fh = __pyx_t_1; /* "pyfuse3.pyx":365 * def __cinit__(self, fh=0, direct_io=0, keep_cache=1, nonseekable=0): * self.fh = fh * self.direct_io = direct_io # <<<<<<<<<<<<<< * self.keep_cache = keep_cache * self.nonseekable = nonseekable */ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_direct_io); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 365, __pyx_L1_error) __pyx_v_self->direct_io = __pyx_t_2; /* "pyfuse3.pyx":366 * self.fh = fh * self.direct_io = direct_io * self.keep_cache = keep_cache # <<<<<<<<<<<<<< * self.nonseekable = nonseekable * */ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_keep_cache); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 366, __pyx_L1_error) __pyx_v_self->keep_cache = __pyx_t_2; /* "pyfuse3.pyx":367 * self.direct_io = direct_io * self.keep_cache = keep_cache * self.nonseekable = nonseekable # <<<<<<<<<<<<<< * * cdef _copy_to_fuse(self, fuse_file_info *out): */ __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_nonseekable); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 367, __pyx_L1_error) __pyx_v_self->nonseekable = __pyx_t_2; /* "pyfuse3.pyx":363 * cdef public bint nonseekable * * def __cinit__(self, fh=0, direct_io=0, keep_cache=1, nonseekable=0): # <<<<<<<<<<<<<< * self.fh = fh * self.direct_io = direct_io */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.FileInfo.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":369 * self.nonseekable = nonseekable * * cdef _copy_to_fuse(self, fuse_file_info *out): # <<<<<<<<<<<<<< * out.fh = self.fh * */ static PyObject *__pyx_f_7pyfuse3_8FileInfo__copy_to_fuse(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, struct fuse_file_info *__pyx_v_out) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations uint64_t __pyx_t_1; int __pyx_t_2; __Pyx_RefNannySetupContext("_copy_to_fuse", 0); /* "pyfuse3.pyx":370 * * cdef _copy_to_fuse(self, fuse_file_info *out): * out.fh = self.fh # <<<<<<<<<<<<<< * * # Due to how Cython generates its C code, GCC will complain about */ __pyx_t_1 = __pyx_v_self->fh; __pyx_v_out->fh = __pyx_t_1; /* "pyfuse3.pyx":375 * # assigning to the bitfields in the fuse_file_info struct. * # This is the workaround. * if self.direct_io: # <<<<<<<<<<<<<< * out.direct_io = 1 * else: */ __pyx_t_2 = (__pyx_v_self->direct_io != 0); if (__pyx_t_2) { /* "pyfuse3.pyx":376 * # This is the workaround. * if self.direct_io: * out.direct_io = 1 # <<<<<<<<<<<<<< * else: * out.direct_io = 0 */ __pyx_v_out->direct_io = 1; /* "pyfuse3.pyx":375 * # assigning to the bitfields in the fuse_file_info struct. * # This is the workaround. * if self.direct_io: # <<<<<<<<<<<<<< * out.direct_io = 1 * else: */ goto __pyx_L3; } /* "pyfuse3.pyx":378 * out.direct_io = 1 * else: * out.direct_io = 0 # <<<<<<<<<<<<<< * * if self.keep_cache: */ /*else*/ { __pyx_v_out->direct_io = 0; } __pyx_L3:; /* "pyfuse3.pyx":380 * out.direct_io = 0 * * if self.keep_cache: # <<<<<<<<<<<<<< * out.keep_cache = 1 * else: */ __pyx_t_2 = (__pyx_v_self->keep_cache != 0); if (__pyx_t_2) { /* "pyfuse3.pyx":381 * * if self.keep_cache: * out.keep_cache = 1 # <<<<<<<<<<<<<< * else: * out.keep_cache = 0 */ __pyx_v_out->keep_cache = 1; /* "pyfuse3.pyx":380 * out.direct_io = 0 * * if self.keep_cache: # <<<<<<<<<<<<<< * out.keep_cache = 1 * else: */ goto __pyx_L4; } /* "pyfuse3.pyx":383 * out.keep_cache = 1 * else: * out.keep_cache = 0 # <<<<<<<<<<<<<< * * if self.nonseekable: */ /*else*/ { __pyx_v_out->keep_cache = 0; } __pyx_L4:; /* "pyfuse3.pyx":385 * out.keep_cache = 0 * * if self.nonseekable: # <<<<<<<<<<<<<< * out.nonseekable = 1 * else: */ __pyx_t_2 = (__pyx_v_self->nonseekable != 0); if (__pyx_t_2) { /* "pyfuse3.pyx":386 * * if self.nonseekable: * out.nonseekable = 1 # <<<<<<<<<<<<<< * else: * out.nonseekable = 0 */ __pyx_v_out->nonseekable = 1; /* "pyfuse3.pyx":385 * out.keep_cache = 0 * * if self.nonseekable: # <<<<<<<<<<<<<< * out.nonseekable = 1 * else: */ goto __pyx_L5; } /* "pyfuse3.pyx":388 * out.nonseekable = 1 * else: * out.nonseekable = 0 # <<<<<<<<<<<<<< * * @cython.freelist(1) */ /*else*/ { __pyx_v_out->nonseekable = 0; } __pyx_L5:; /* "pyfuse3.pyx":369 * self.nonseekable = nonseekable * * cdef _copy_to_fuse(self, fuse_file_info *out): # <<<<<<<<<<<<<< * out.fh = self.fh * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":358 * ''' * * cdef public uint64_t fh # <<<<<<<<<<<<<< * cdef public bint direct_io * cdef public bint keep_cache */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_2fh_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_2fh_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_2fh___get__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_8FileInfo_2fh___get__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_uint64_t(__pyx_v_self->fh); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 358, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FileInfo.fh.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_7pyfuse3_8FileInfo_2fh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_7pyfuse3_8FileInfo_2fh_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_2fh_2__set__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_8FileInfo_2fh_2__set__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations uint64_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyInt_As_uint64_t(__pyx_v_value); if (unlikely((__pyx_t_1 == ((uint64_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 358, __pyx_L1_error) __pyx_v_self->fh = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.FileInfo.fh.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":359 * * cdef public uint64_t fh * cdef public bint direct_io # <<<<<<<<<<<<<< * cdef public bint keep_cache * cdef public bint nonseekable */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_9direct_io_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_9direct_io_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_9direct_io___get__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_8FileInfo_9direct_io___get__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->direct_io); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 359, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FileInfo.direct_io.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_7pyfuse3_8FileInfo_9direct_io_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_7pyfuse3_8FileInfo_9direct_io_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_9direct_io_2__set__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_8FileInfo_9direct_io_2__set__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 359, __pyx_L1_error) __pyx_v_self->direct_io = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.FileInfo.direct_io.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":360 * cdef public uint64_t fh * cdef public bint direct_io * cdef public bint keep_cache # <<<<<<<<<<<<<< * cdef public bint nonseekable * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_10keep_cache_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_10keep_cache_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_10keep_cache___get__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_8FileInfo_10keep_cache___get__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->keep_cache); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 360, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FileInfo.keep_cache.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_7pyfuse3_8FileInfo_10keep_cache_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_7pyfuse3_8FileInfo_10keep_cache_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_10keep_cache_2__set__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_8FileInfo_10keep_cache_2__set__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 360, __pyx_L1_error) __pyx_v_self->keep_cache = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.FileInfo.keep_cache.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":361 * cdef public bint direct_io * cdef public bint keep_cache * cdef public bint nonseekable # <<<<<<<<<<<<<< * * def __cinit__(self, fh=0, direct_io=0, keep_cache=1, nonseekable=0): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_11nonseekable_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_11nonseekable_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_11nonseekable___get__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_8FileInfo_11nonseekable___get__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->nonseekable); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 361, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FileInfo.nonseekable.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* Python wrapper */ static int __pyx_pw_7pyfuse3_8FileInfo_11nonseekable_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_7pyfuse3_8FileInfo_11nonseekable_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_11nonseekable_2__set__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_8FileInfo_11nonseekable_2__set__(struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, PyObject *__pyx_v_value) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 361, __pyx_L1_error) __pyx_v_self->nonseekable = __pyx_t_1; /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.FileInfo.nonseekable.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_8FileInfo_2__reduce_cython__[] = "FileInfo.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_8FileInfo_3__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_2__reduce_cython__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_8FileInfo_2__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__45, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FileInfo.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_8FileInfo_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_8FileInfo_4__setstate_cython__[] = "FileInfo.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_8FileInfo_5__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_8FileInfo_4__setstate_cython__(((struct __pyx_obj_7pyfuse3_FileInfo *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_8FileInfo_4__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_FileInfo *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__46, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FileInfo.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":400 * cdef statvfs stat * * def __cinit__(self): # <<<<<<<<<<<<<< * string.memset(&self.stat, 0, sizeof(statvfs)) * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); if (unlikely(PyTuple_GET_SIZE(__pyx_args) > 0)) { __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 0, 0, PyTuple_GET_SIZE(__pyx_args)); return -1;} if (unlikely(__pyx_kwds) && unlikely(PyDict_Size(__pyx_kwds) > 0) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__cinit__", 0))) return -1; __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData___cinit__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData___cinit__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__", 0); /* "pyfuse3.pyx":401 * * def __cinit__(self): * string.memset(&self.stat, 0, sizeof(statvfs)) # <<<<<<<<<<<<<< * * @property */ (void)(memset((&__pyx_v_self->stat), 0, (sizeof(struct statvfs)))); /* "pyfuse3.pyx":400 * cdef statvfs stat * * def __cinit__(self): # <<<<<<<<<<<<<< * string.memset(&self.stat, 0, sizeof(statvfs)) * */ /* function exit code */ __pyx_r = 0; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":404 * * @property * def f_bsize(self): # <<<<<<<<<<<<<< * return self.stat.f_bsize * @f_bsize.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7f_bsize_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7f_bsize_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_7f_bsize___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_7f_bsize___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":405 * @property * def f_bsize(self): * return self.stat.f_bsize # <<<<<<<<<<<<<< * @f_bsize.setter * def f_bsize(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->stat.f_bsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 405, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":404 * * @property * def f_bsize(self): # <<<<<<<<<<<<<< * return self.stat.f_bsize * @f_bsize.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_bsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":407 * return self.stat.f_bsize * @f_bsize.setter * def f_bsize(self, val): # <<<<<<<<<<<<<< * self.stat.f_bsize = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_7f_bsize_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_7f_bsize_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_7f_bsize_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_7f_bsize_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations unsigned long __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":408 * @f_bsize.setter * def f_bsize(self, val): * self.stat.f_bsize = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_unsigned_long(__pyx_v_val); if (unlikely((__pyx_t_1 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(3, 408, __pyx_L1_error) __pyx_v_self->stat.f_bsize = __pyx_t_1; /* "pyfuse3.pyx":407 * return self.stat.f_bsize * @f_bsize.setter * def f_bsize(self, val): # <<<<<<<<<<<<<< * self.stat.f_bsize = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_bsize.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":411 * * @property * def f_frsize(self): # <<<<<<<<<<<<<< * return self.stat.f_frsize * @f_frsize.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_8f_frsize_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_8f_frsize_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8f_frsize___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8f_frsize___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":412 * @property * def f_frsize(self): * return self.stat.f_frsize # <<<<<<<<<<<<<< * @f_frsize.setter * def f_frsize(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->stat.f_frsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 412, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":411 * * @property * def f_frsize(self): # <<<<<<<<<<<<<< * return self.stat.f_frsize * @f_frsize.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_frsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":414 * return self.stat.f_frsize * @f_frsize.setter * def f_frsize(self, val): # <<<<<<<<<<<<<< * self.stat.f_frsize = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_8f_frsize_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_8f_frsize_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8f_frsize_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_8f_frsize_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations unsigned long __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":415 * @f_frsize.setter * def f_frsize(self, val): * self.stat.f_frsize = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_unsigned_long(__pyx_v_val); if (unlikely((__pyx_t_1 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(3, 415, __pyx_L1_error) __pyx_v_self->stat.f_frsize = __pyx_t_1; /* "pyfuse3.pyx":414 * return self.stat.f_frsize * @f_frsize.setter * def f_frsize(self, val): # <<<<<<<<<<<<<< * self.stat.f_frsize = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_frsize.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":418 * * @property * def f_blocks(self): # <<<<<<<<<<<<<< * return self.stat.f_blocks * @f_blocks.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_8f_blocks_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_8f_blocks_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8f_blocks___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8f_blocks___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":419 * @property * def f_blocks(self): * return self.stat.f_blocks # <<<<<<<<<<<<<< * @f_blocks.setter * def f_blocks(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_fsblkcnt_t(__pyx_v_self->stat.f_blocks); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 419, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":418 * * @property * def f_blocks(self): # <<<<<<<<<<<<<< * return self.stat.f_blocks * @f_blocks.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_blocks.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":421 * return self.stat.f_blocks * @f_blocks.setter * def f_blocks(self, val): # <<<<<<<<<<<<<< * self.stat.f_blocks = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_8f_blocks_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_8f_blocks_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8f_blocks_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_8f_blocks_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations fsblkcnt_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":422 * @f_blocks.setter * def f_blocks(self, val): * self.stat.f_blocks = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((fsblkcnt_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 422, __pyx_L1_error) __pyx_v_self->stat.f_blocks = __pyx_t_1; /* "pyfuse3.pyx":421 * return self.stat.f_blocks * @f_blocks.setter * def f_blocks(self, val): # <<<<<<<<<<<<<< * self.stat.f_blocks = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_blocks.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":425 * * @property * def f_bfree(self): # <<<<<<<<<<<<<< * return self.stat.f_bfree * @f_bfree.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7f_bfree_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7f_bfree_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_7f_bfree___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_7f_bfree___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":426 * @property * def f_bfree(self): * return self.stat.f_bfree # <<<<<<<<<<<<<< * @f_bfree.setter * def f_bfree(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_fsblkcnt_t(__pyx_v_self->stat.f_bfree); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 426, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":425 * * @property * def f_bfree(self): # <<<<<<<<<<<<<< * return self.stat.f_bfree * @f_bfree.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_bfree.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":428 * return self.stat.f_bfree * @f_bfree.setter * def f_bfree(self, val): # <<<<<<<<<<<<<< * self.stat.f_bfree = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_7f_bfree_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_7f_bfree_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_7f_bfree_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_7f_bfree_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations fsblkcnt_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":429 * @f_bfree.setter * def f_bfree(self, val): * self.stat.f_bfree = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((fsblkcnt_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 429, __pyx_L1_error) __pyx_v_self->stat.f_bfree = __pyx_t_1; /* "pyfuse3.pyx":428 * return self.stat.f_bfree * @f_bfree.setter * def f_bfree(self, val): # <<<<<<<<<<<<<< * self.stat.f_bfree = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_bfree.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":432 * * @property * def f_bavail(self): # <<<<<<<<<<<<<< * return self.stat.f_bavail * @f_bavail.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_8f_bavail_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_8f_bavail_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8f_bavail___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8f_bavail___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":433 * @property * def f_bavail(self): * return self.stat.f_bavail # <<<<<<<<<<<<<< * @f_bavail.setter * def f_bavail(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_fsblkcnt_t(__pyx_v_self->stat.f_bavail); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 433, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":432 * * @property * def f_bavail(self): # <<<<<<<<<<<<<< * return self.stat.f_bavail * @f_bavail.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_bavail.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":435 * return self.stat.f_bavail * @f_bavail.setter * def f_bavail(self, val): # <<<<<<<<<<<<<< * self.stat.f_bavail = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_8f_bavail_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_8f_bavail_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8f_bavail_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_8f_bavail_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations fsblkcnt_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":436 * @f_bavail.setter * def f_bavail(self, val): * self.stat.f_bavail = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_fsblkcnt_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((fsblkcnt_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 436, __pyx_L1_error) __pyx_v_self->stat.f_bavail = __pyx_t_1; /* "pyfuse3.pyx":435 * return self.stat.f_bavail * @f_bavail.setter * def f_bavail(self, val): # <<<<<<<<<<<<<< * self.stat.f_bavail = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_bavail.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":439 * * @property * def f_files(self): # <<<<<<<<<<<<<< * return self.stat.f_files * @f_files.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7f_files_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7f_files_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_7f_files___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_7f_files___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":440 * @property * def f_files(self): * return self.stat.f_files # <<<<<<<<<<<<<< * @f_files.setter * def f_files(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_fsfilcnt_t(__pyx_v_self->stat.f_files); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 440, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":439 * * @property * def f_files(self): # <<<<<<<<<<<<<< * return self.stat.f_files * @f_files.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_files.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":442 * return self.stat.f_files * @f_files.setter * def f_files(self, val): # <<<<<<<<<<<<<< * self.stat.f_files = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_7f_files_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_7f_files_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_7f_files_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_7f_files_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations fsfilcnt_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":443 * @f_files.setter * def f_files(self, val): * self.stat.f_files = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((fsfilcnt_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 443, __pyx_L1_error) __pyx_v_self->stat.f_files = __pyx_t_1; /* "pyfuse3.pyx":442 * return self.stat.f_files * @f_files.setter * def f_files(self, val): # <<<<<<<<<<<<<< * self.stat.f_files = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_files.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":446 * * @property * def f_ffree(self): # <<<<<<<<<<<<<< * return self.stat.f_ffree * @f_ffree.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7f_ffree_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7f_ffree_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_7f_ffree___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_7f_ffree___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":447 * @property * def f_ffree(self): * return self.stat.f_ffree # <<<<<<<<<<<<<< * @f_ffree.setter * def f_ffree(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_fsfilcnt_t(__pyx_v_self->stat.f_ffree); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 447, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":446 * * @property * def f_ffree(self): # <<<<<<<<<<<<<< * return self.stat.f_ffree * @f_ffree.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_ffree.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":449 * return self.stat.f_ffree * @f_ffree.setter * def f_ffree(self, val): # <<<<<<<<<<<<<< * self.stat.f_ffree = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_7f_ffree_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_7f_ffree_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_7f_ffree_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_7f_ffree_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations fsfilcnt_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":450 * @f_ffree.setter * def f_ffree(self, val): * self.stat.f_ffree = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((fsfilcnt_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 450, __pyx_L1_error) __pyx_v_self->stat.f_ffree = __pyx_t_1; /* "pyfuse3.pyx":449 * return self.stat.f_ffree * @f_ffree.setter * def f_ffree(self, val): # <<<<<<<<<<<<<< * self.stat.f_ffree = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_ffree.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":453 * * @property * def f_favail(self): # <<<<<<<<<<<<<< * return self.stat.f_favail * @f_favail.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_8f_favail_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_8f_favail_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8f_favail___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8f_favail___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":454 * @property * def f_favail(self): * return self.stat.f_favail # <<<<<<<<<<<<<< * @f_favail.setter * def f_favail(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_fsfilcnt_t(__pyx_v_self->stat.f_favail); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 454, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":453 * * @property * def f_favail(self): # <<<<<<<<<<<<<< * return self.stat.f_favail * @f_favail.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_favail.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":456 * return self.stat.f_favail * @f_favail.setter * def f_favail(self, val): # <<<<<<<<<<<<<< * self.stat.f_favail = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_8f_favail_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_8f_favail_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8f_favail_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_8f_favail_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations fsfilcnt_t __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":457 * @f_favail.setter * def f_favail(self, val): * self.stat.f_favail = val # <<<<<<<<<<<<<< * * @property */ __pyx_t_1 = __Pyx_PyInt_As_fsfilcnt_t(__pyx_v_val); if (unlikely((__pyx_t_1 == ((fsfilcnt_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 457, __pyx_L1_error) __pyx_v_self->stat.f_favail = __pyx_t_1; /* "pyfuse3.pyx":456 * return self.stat.f_favail * @f_favail.setter * def f_favail(self, val): # <<<<<<<<<<<<<< * self.stat.f_favail = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_favail.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":460 * * @property * def f_namemax(self): # <<<<<<<<<<<<<< * return self.stat.f_namemax * @f_namemax.setter */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_9f_namemax_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_9f_namemax_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_9f_namemax___get__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_9f_namemax___get__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":461 * @property * def f_namemax(self): * return self.stat.f_namemax # <<<<<<<<<<<<<< * @f_namemax.setter * def f_namemax(self, val): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_unsigned_long(__pyx_v_self->stat.f_namemax); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 461, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":460 * * @property * def f_namemax(self): # <<<<<<<<<<<<<< * return self.stat.f_namemax * @f_namemax.setter */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.f_namemax.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":463 * return self.stat.f_namemax * @f_namemax.setter * def f_namemax(self, val): # <<<<<<<<<<<<<< * self.stat.f_namemax = val * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_11StatvfsData_9f_namemax_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val); /*proto*/ static int __pyx_pw_7pyfuse3_11StatvfsData_9f_namemax_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_9f_namemax_2__set__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_val)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_11StatvfsData_9f_namemax_2__set__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_val) { int __pyx_r; __Pyx_RefNannyDeclarations unsigned long __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__set__", 0); /* "pyfuse3.pyx":464 * @f_namemax.setter * def f_namemax(self, val): * self.stat.f_namemax = val # <<<<<<<<<<<<<< * * # Pickling and copy support */ __pyx_t_1 = __Pyx_PyInt_As_unsigned_long(__pyx_v_val); if (unlikely((__pyx_t_1 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(3, 464, __pyx_L1_error) __pyx_v_self->stat.f_namemax = __pyx_t_1; /* "pyfuse3.pyx":463 * return self.stat.f_namemax * @f_namemax.setter * def f_namemax(self, val): # <<<<<<<<<<<<<< * self.stat.f_namemax = val * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.StatvfsData.f_namemax.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":467 * * # Pickling and copy support * def __getstate__(self): # <<<<<<<<<<<<<< * state = dict() * for k in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_3__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_11StatvfsData_2__getstate__[] = "StatvfsData.__getstate__(self)"; static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_3__getstate__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__getstate__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_2__getstate__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_2__getstate__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_v_state = NULL; PyObject *__pyx_v_k = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__getstate__", 0); /* "pyfuse3.pyx":468 * # Pickling and copy support * def __getstate__(self): * state = dict() # <<<<<<<<<<<<<< * for k in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', * 'f_bavail', 'f_files', 'f_ffree', 'f_favail', */ __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 468, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_v_state = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":469 * def __getstate__(self): * state = dict() * for k in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', # <<<<<<<<<<<<<< * 'f_bavail', 'f_files', 'f_ffree', 'f_favail', * 'f_namemax'): */ __pyx_t_1 = __pyx_tuple__47; __Pyx_INCREF(__pyx_t_1); __pyx_t_2 = 0; for (;;) { if (__pyx_t_2 >= 9) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_3 = PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_2); __Pyx_INCREF(__pyx_t_3); __pyx_t_2++; if (unlikely(0 < 0)) __PYX_ERR(3, 469, __pyx_L1_error) #else __pyx_t_3 = PySequence_ITEM(__pyx_t_1, __pyx_t_2); __pyx_t_2++; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); #endif __Pyx_XDECREF_SET(__pyx_v_k, ((PyObject*)__pyx_t_3)); __pyx_t_3 = 0; /* "pyfuse3.pyx":472 * 'f_bavail', 'f_files', 'f_ffree', 'f_favail', * 'f_namemax'): * state[k] = getattr(self, k) # <<<<<<<<<<<<<< * return state * */ __pyx_t_3 = __Pyx_GetAttr(((PyObject *)__pyx_v_self), __pyx_v_k); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 472, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (unlikely(PyDict_SetItem(__pyx_v_state, __pyx_v_k, __pyx_t_3) < 0)) __PYX_ERR(3, 472, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":469 * def __getstate__(self): * state = dict() * for k in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', # <<<<<<<<<<<<<< * 'f_bavail', 'f_files', 'f_ffree', 'f_favail', * 'f_namemax'): */ } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":473 * 'f_namemax'): * state[k] = getattr(self, k) * return state # <<<<<<<<<<<<<< * * def __setstate__(self, state): */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_state); __pyx_r = __pyx_v_state; goto __pyx_L0; /* "pyfuse3.pyx":467 * * # Pickling and copy support * def __getstate__(self): # <<<<<<<<<<<<<< * state = dict() * for k in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.StatvfsData.__getstate__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_state); __Pyx_XDECREF(__pyx_v_k); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":475 * return state * * def __setstate__(self, state): # <<<<<<<<<<<<<< * for (k,v) in state.items(): * setattr(self, k, v) */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_5__setstate__(PyObject *__pyx_v_self, PyObject *__pyx_v_state); /*proto*/ static char __pyx_doc_7pyfuse3_11StatvfsData_4__setstate__[] = "StatvfsData.__setstate__(self, state)"; static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_5__setstate__(PyObject *__pyx_v_self, PyObject *__pyx_v_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_4__setstate__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_4__setstate__(struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, PyObject *__pyx_v_state) { PyObject *__pyx_v_k = NULL; PyObject *__pyx_v_v = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; Py_ssize_t __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate__", 0); /* "pyfuse3.pyx":476 * * def __setstate__(self, state): * for (k,v) in state.items(): # <<<<<<<<<<<<<< * setattr(self, k, v) * */ __pyx_t_2 = 0; if (unlikely(__pyx_v_state == Py_None)) { PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "items"); __PYX_ERR(3, 476, __pyx_L1_error) } __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_state, 0, __pyx_n_s_items, (&__pyx_t_3), (&__pyx_t_4)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = __pyx_t_5; __pyx_t_5 = 0; while (1) { __pyx_t_7 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_3, &__pyx_t_2, &__pyx_t_5, &__pyx_t_6, NULL, __pyx_t_4); if (unlikely(__pyx_t_7 == 0)) break; if (unlikely(__pyx_t_7 == -1)) __PYX_ERR(3, 476, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_GOTREF(__pyx_t_6); __Pyx_XDECREF_SET(__pyx_v_k, __pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF_SET(__pyx_v_v, __pyx_t_6); __pyx_t_6 = 0; /* "pyfuse3.pyx":477 * def __setstate__(self, state): * for (k,v) in state.items(): * setattr(self, k, v) # <<<<<<<<<<<<<< * * # As of Cython 0.28.1, @cython.freelist cannot be used for */ __pyx_t_8 = PyObject_SetAttr(((PyObject *)__pyx_v_self), __pyx_v_k, __pyx_v_v); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(3, 477, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":475 * return state * * def __setstate__(self, state): # <<<<<<<<<<<<<< * for (k,v) in state.items(): * setattr(self, k, v) */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pyfuse3.StatvfsData.__setstate__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_k); __Pyx_XDECREF(__pyx_v_v); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_11StatvfsData_6__reduce_cython__[] = "StatvfsData.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_6__reduce_cython__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__48, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_11StatvfsData_8__setstate_cython__[] = "StatvfsData.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_11StatvfsData_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_11StatvfsData_8__setstate_cython__(((struct __pyx_obj_7pyfuse3_StatvfsData *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_11StatvfsData_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__49, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.StatvfsData.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":495 * * @property * def errno(self): # <<<<<<<<<<<<<< * '''Error code to return to client process''' * return self.errno_ */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_9FUSEError_5errno_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_9FUSEError_5errno_1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_9FUSEError_5errno___get__(((struct __pyx_obj_7pyfuse3_FUSEError *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_9FUSEError_5errno___get__(struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); /* "pyfuse3.pyx":497 * def errno(self): * '''Error code to return to client process''' * return self.errno_ # <<<<<<<<<<<<<< * * def __cinit__(self, errno): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->errno_); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 497, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":495 * * @property * def errno(self): # <<<<<<<<<<<<<< * '''Error code to return to client process''' * return self.errno_ */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FUSEError.errno.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":499 * return self.errno_ * * def __cinit__(self, errno): # <<<<<<<<<<<<<< * self.errno_ = errno * */ /* Python wrapper */ static int __pyx_pw_7pyfuse3_9FUSEError_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_7pyfuse3_9FUSEError_1__cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_errno = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_errno,0}; PyObject* values[1] = {0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_errno)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(3, 499, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); } __pyx_v_errno = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__cinit__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 499, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.FUSEError.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_9FUSEError___cinit__(((struct __pyx_obj_7pyfuse3_FUSEError *)__pyx_v_self), __pyx_v_errno); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_7pyfuse3_9FUSEError___cinit__(struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self, PyObject *__pyx_v_errno) { int __pyx_r; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__cinit__", 0); /* "pyfuse3.pyx":500 * * def __cinit__(self, errno): * self.errno_ = errno # <<<<<<<<<<<<<< * * def __str__(self): */ __pyx_t_1 = __Pyx_PyInt_As_int(__pyx_v_errno); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 500, __pyx_L1_error) __pyx_v_self->errno_ = __pyx_t_1; /* "pyfuse3.pyx":499 * return self.errno_ * * def __cinit__(self, errno): # <<<<<<<<<<<<<< * self.errno_ = errno * */ /* function exit code */ __pyx_r = 0; goto __pyx_L0; __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.FUSEError.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":502 * self.errno_ = errno * * def __str__(self): # <<<<<<<<<<<<<< * return strerror(self.errno_) * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_9FUSEError_3__str__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_9FUSEError_3__str__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_9FUSEError_2__str__(((struct __pyx_obj_7pyfuse3_FUSEError *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_9FUSEError_2__str__(struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__str__", 0); /* "pyfuse3.pyx":503 * * def __str__(self): * return strerror(self.errno_) # <<<<<<<<<<<<<< * * def listdir(path): */ __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __pyx_f_7pyfuse3_strerror(__pyx_v_self->errno_); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* "pyfuse3.pyx":502 * self.errno_ = errno * * def __str__(self): # <<<<<<<<<<<<<< * return strerror(self.errno_) * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FUSEError.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":492 * # during C compilation (maybe something else declares errno as * # a macro?) * cdef readonly int errno_ # <<<<<<<<<<<<<< * * @property */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_9FUSEError_6errno__1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_7pyfuse3_9FUSEError_6errno__1__get__(PyObject *__pyx_v_self) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_9FUSEError_6errno____get__(((struct __pyx_obj_7pyfuse3_FUSEError *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_9FUSEError_6errno____get__(struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__get__", 0); __Pyx_XDECREF(__pyx_r); __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->errno_); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 492, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FUSEError.errno_.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_9FUSEError_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_9FUSEError_4__reduce_cython__[] = "FUSEError.__reduce_cython__(self)"; static PyObject *__pyx_pw_7pyfuse3_9FUSEError_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_9FUSEError_4__reduce_cython__(((struct __pyx_obj_7pyfuse3_FUSEError *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_9FUSEError_4__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__reduce_cython__", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__50, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FUSEError.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_9FUSEError_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ static char __pyx_doc_7pyfuse3_9FUSEError_6__setstate_cython__[] = "FUSEError.__setstate_cython__(self, __pyx_state)"; static PyObject *__pyx_pw_7pyfuse3_9FUSEError_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_9FUSEError_6__setstate_cython__(((struct __pyx_obj_7pyfuse3_FUSEError *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_9FUSEError_6__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_7pyfuse3_FUSEError *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__setstate_cython__", 0); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__51, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(0, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("pyfuse3.FUSEError.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":505 * return strerror(self.errno_) * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_96listdir(PyObject *__pyx_self, PyObject *__pyx_v_path); /*proto*/ static char __pyx_doc_7pyfuse3_95listdir[] = "listdir(path)\nLike `os.listdir`, but releases the GIL.\n\n This function returns an iterator over the directory entries in *path*.\n\n The returned values are of type :ref:`str `. Surrogate\n escape coding (cf. `PEP 383 `_)\n is used for directory names that do not have a string representation.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_96listdir = {"listdir", (PyCFunction)__pyx_pw_7pyfuse3_96listdir, METH_O, __pyx_doc_7pyfuse3_95listdir}; static PyObject *__pyx_pw_7pyfuse3_96listdir(PyObject *__pyx_self, PyObject *__pyx_v_path) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("listdir (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_95listdir(__pyx_self, ((PyObject *)__pyx_v_path)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_95listdir(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path) { DIR *__pyx_v_dirp; struct dirent *__pyx_v_res; char *__pyx_v_buf; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_names = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; char *__pyx_t_4; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("listdir", 0); /* "pyfuse3.pyx":515 * ''' * * if not isinstance(path, str): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = PyUnicode_Check(__pyx_v_path); __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":516 * * if not isinstance(path, str): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * cdef libc_extra.DIR* dirp */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 516, __pyx_L1_error) /* "pyfuse3.pyx":515 * ''' * * if not isinstance(path, str): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ } /* "pyfuse3.pyx":522 * cdef char* buf * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * buf = path_b * */ __pyx_t_3 = __pyx_f_7pyfuse3_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 522, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_v_path_b = __pyx_t_3; __pyx_t_3 = 0; /* "pyfuse3.pyx":523 * * path_b = str2bytes(path) * buf = path_b # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_4 = __Pyx_PyObject_AsWritableString(__pyx_v_path_b); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(3, 523, __pyx_L1_error) __pyx_v_buf = ((char *)__pyx_t_4); /* "pyfuse3.pyx":525 * buf = path_b * * with nogil: # <<<<<<<<<<<<<< * dirp = libc_extra.opendir(buf) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":526 * * with nogil: * dirp = libc_extra.opendir(buf) # <<<<<<<<<<<<<< * * if dirp == NULL: */ __pyx_v_dirp = opendir(__pyx_v_buf); } /* "pyfuse3.pyx":525 * buf = path_b * * with nogil: # <<<<<<<<<<<<<< * dirp = libc_extra.opendir(buf) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "pyfuse3.pyx":528 * dirp = libc_extra.opendir(buf) * * if dirp == NULL: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_2 = ((__pyx_v_dirp == NULL) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":529 * * if dirp == NULL: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * names = list() */ __pyx_t_3 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __pyx_f_7pyfuse3_strerror(errno); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5); __Pyx_INCREF(__pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_v_path); __pyx_t_3 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_6, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 529, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(3, 529, __pyx_L1_error) /* "pyfuse3.pyx":528 * dirp = libc_extra.opendir(buf) * * if dirp == NULL: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ } /* "pyfuse3.pyx":531 * raise OSError(errno.errno, strerror(errno.errno), path) * * names = list() # <<<<<<<<<<<<<< * while True: * errno.errno = 0 */ __pyx_t_5 = PyList_New(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 531, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_v_names = ((PyObject*)__pyx_t_5); __pyx_t_5 = 0; /* "pyfuse3.pyx":532 * * names = list() * while True: # <<<<<<<<<<<<<< * errno.errno = 0 * with nogil: */ while (1) { /* "pyfuse3.pyx":533 * names = list() * while True: * errno.errno = 0 # <<<<<<<<<<<<<< * with nogil: * res = libc_extra.readdir(dirp) */ errno = 0; /* "pyfuse3.pyx":534 * while True: * errno.errno = 0 * with nogil: # <<<<<<<<<<<<<< * res = libc_extra.readdir(dirp) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":535 * errno.errno = 0 * with nogil: * res = libc_extra.readdir(dirp) # <<<<<<<<<<<<<< * * if res is NULL: */ __pyx_v_res = readdir(__pyx_v_dirp); } /* "pyfuse3.pyx":534 * while True: * errno.errno = 0 * with nogil: # <<<<<<<<<<<<<< * res = libc_extra.readdir(dirp) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L14; } __pyx_L14:; } } /* "pyfuse3.pyx":537 * res = libc_extra.readdir(dirp) * * if res is NULL: # <<<<<<<<<<<<<< * if errno.errno != 0: * raise OSError(errno.errno, strerror(errno.errno), path) */ __pyx_t_2 = ((__pyx_v_res == NULL) != 0); if (__pyx_t_2) { /* "pyfuse3.pyx":538 * * if res is NULL: * if errno.errno != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * else: */ __pyx_t_2 = ((errno != 0) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":539 * if res is NULL: * if errno.errno != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * else: * break */ __pyx_t_5 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_6 = __pyx_f_7pyfuse3_strerror(errno); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6); __Pyx_INCREF(__pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_path); __pyx_t_5 = 0; __pyx_t_6 = 0; __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 539, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_6, 0, 0, 0); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __PYX_ERR(3, 539, __pyx_L1_error) /* "pyfuse3.pyx":538 * * if res is NULL: * if errno.errno != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * else: */ } /* "pyfuse3.pyx":541 * raise OSError(errno.errno, strerror(errno.errno), path) * else: * break # <<<<<<<<<<<<<< * if string.strcmp(res.d_name, b'.') == 0 or \ * string.strcmp(res.d_name, b'..') == 0: */ /*else*/ { goto __pyx_L9_break; } /* "pyfuse3.pyx":537 * res = libc_extra.readdir(dirp) * * if res is NULL: # <<<<<<<<<<<<<< * if errno.errno != 0: * raise OSError(errno.errno, strerror(errno.errno), path) */ } /* "pyfuse3.pyx":542 * else: * break * if string.strcmp(res.d_name, b'.') == 0 or \ # <<<<<<<<<<<<<< * string.strcmp(res.d_name, b'..') == 0: * continue */ __pyx_t_1 = ((strcmp(__pyx_v_res->d_name, ((char const *)".")) == 0) != 0); if (!__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L18_bool_binop_done; } /* "pyfuse3.pyx":543 * break * if string.strcmp(res.d_name, b'.') == 0 or \ * string.strcmp(res.d_name, b'..') == 0: # <<<<<<<<<<<<<< * continue * */ __pyx_t_1 = ((strcmp(__pyx_v_res->d_name, ((char const *)"..")) == 0) != 0); __pyx_t_2 = __pyx_t_1; __pyx_L18_bool_binop_done:; /* "pyfuse3.pyx":542 * else: * break * if string.strcmp(res.d_name, b'.') == 0 or \ # <<<<<<<<<<<<<< * string.strcmp(res.d_name, b'..') == 0: * continue */ if (__pyx_t_2) { /* "pyfuse3.pyx":544 * if string.strcmp(res.d_name, b'.') == 0 or \ * string.strcmp(res.d_name, b'..') == 0: * continue # <<<<<<<<<<<<<< * * names.append(bytes2str(PyBytes_FromString(res.d_name))) */ goto __pyx_L8_continue; /* "pyfuse3.pyx":542 * else: * break * if string.strcmp(res.d_name, b'.') == 0 or \ # <<<<<<<<<<<<<< * string.strcmp(res.d_name, b'..') == 0: * continue */ } /* "pyfuse3.pyx":546 * continue * * names.append(bytes2str(PyBytes_FromString(res.d_name))) # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = PyBytes_FromString(__pyx_v_res->d_name); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_3 = __pyx_f_7pyfuse3_bytes2str(__pyx_t_6); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_names, __pyx_t_3); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(3, 546, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_L8_continue:; } __pyx_L9_break:; /* "pyfuse3.pyx":548 * names.append(bytes2str(PyBytes_FromString(res.d_name))) * * with nogil: # <<<<<<<<<<<<<< * libc_extra.closedir(dirp) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":549 * * with nogil: * libc_extra.closedir(dirp) # <<<<<<<<<<<<<< * * return names */ (void)(closedir(__pyx_v_dirp)); } /* "pyfuse3.pyx":548 * names.append(bytes2str(PyBytes_FromString(res.d_name))) * * with nogil: # <<<<<<<<<<<<<< * libc_extra.closedir(dirp) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L22; } __pyx_L22:; } } /* "pyfuse3.pyx":551 * libc_extra.closedir(dirp) * * return names # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_names); __pyx_r = __pyx_v_names; goto __pyx_L0; /* "pyfuse3.pyx":505 * return strerror(self.errno_) * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pyfuse3.listdir", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_names); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":554 * * * def syncfs(path): # <<<<<<<<<<<<<< * '''Sync filesystem mounted at *path* * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_98syncfs(PyObject *__pyx_self, PyObject *__pyx_v_path); /*proto*/ static char __pyx_doc_7pyfuse3_97syncfs[] = "syncfs(path)\nSync filesystem mounted at *path*\n\n This is a Python interface to the syncfs(2) system call. There is no\n particular relation to libfuse, it is provided by pyfuse3 as a convience.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_98syncfs = {"syncfs", (PyCFunction)__pyx_pw_7pyfuse3_98syncfs, METH_O, __pyx_doc_7pyfuse3_97syncfs}; static PyObject *__pyx_pw_7pyfuse3_98syncfs(PyObject *__pyx_self, PyObject *__pyx_v_path) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("syncfs (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_97syncfs(__pyx_self, ((PyObject *)__pyx_v_path)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_97syncfs(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path) { int __pyx_v_ret; PyObject *__pyx_v_fd = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_t_7; int __pyx_t_8; char const *__pyx_t_9; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("syncfs", 0); /* "pyfuse3.pyx":563 * cdef int ret * * fd = os.open(path, flags=os.O_DIRECTORY) # <<<<<<<<<<<<<< * try: * ret = libc_extra.syncfs(fd) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_open); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_path); __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_os); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_O_DIRECTORY); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_flags, __pyx_t_5) < 0) __PYX_ERR(3, 563, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_1, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 563, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_fd = __pyx_t_5; __pyx_t_5 = 0; /* "pyfuse3.pyx":564 * * fd = os.open(path, flags=os.O_DIRECTORY) * try: # <<<<<<<<<<<<<< * ret = libc_extra.syncfs(fd) * */ /*try:*/ { /* "pyfuse3.pyx":565 * fd = os.open(path, flags=os.O_DIRECTORY) * try: * ret = libc_extra.syncfs(fd) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_t_6 = __Pyx_PyInt_As_int(__pyx_v_fd); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 565, __pyx_L4_error) __pyx_v_ret = syncfs(__pyx_t_6); /* "pyfuse3.pyx":567 * ret = libc_extra.syncfs(fd) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * finally: */ __pyx_t_7 = ((__pyx_v_ret != 0) != 0); if (unlikely(__pyx_t_7)) { /* "pyfuse3.pyx":568 * * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * finally: * os.close(fd) */ __pyx_t_5 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 568, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __pyx_f_7pyfuse3_strerror(errno); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 568, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 568, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); __Pyx_INCREF(__pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_path); __pyx_t_5 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 568, __pyx_L4_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 568, __pyx_L4_error) /* "pyfuse3.pyx":567 * ret = libc_extra.syncfs(fd) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * finally: */ } } /* "pyfuse3.pyx":570 * raise OSError(errno.errno, strerror(errno.errno), path) * finally: * os.close(fd) # <<<<<<<<<<<<<< * * */ /*finally:*/ { /*normal exit:*/{ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_os); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 570, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_close); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 570, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_1, __pyx_v_fd) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_v_fd); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 570, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L5; } __pyx_L4_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_13, &__pyx_t_14, &__pyx_t_15); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12) < 0)) __Pyx_ErrFetch(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); __Pyx_XGOTREF(__pyx_t_10); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __pyx_t_6 = __pyx_lineno; __pyx_t_8 = __pyx_clineno; __pyx_t_9 = __pyx_filename; { __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_os); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 570, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_n_s_close); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 570, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v_fd) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v_fd); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 570, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); } __Pyx_XGIVEREF(__pyx_t_10); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_ErrRestore(__pyx_t_10, __pyx_t_11, __pyx_t_12); __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_lineno = __pyx_t_6; __pyx_clineno = __pyx_t_8; __pyx_filename = __pyx_t_9; goto __pyx_L1_error; __pyx_L8_error:; if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_13); __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_ExceptionReset(__pyx_t_13, __pyx_t_14, __pyx_t_15); } __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; goto __pyx_L1_error; } __pyx_L5:; } /* "pyfuse3.pyx":554 * * * def syncfs(path): # <<<<<<<<<<<<<< * '''Sync filesystem mounted at *path* * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyfuse3.syncfs", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_fd); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":573 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_100setxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_99setxattr[] = "setxattr(path, name, bytes value, namespace=u'user')\nSet extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. *value* has to be of type `bytes`.\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast to the `os.setxattr` function from the standard library, the\n method provided by pyfuse3 is also available for non-Linux systems.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_100setxattr = {"setxattr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_100setxattr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_99setxattr}; static PyObject *__pyx_pw_7pyfuse3_100setxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_name = 0; PyObject *__pyx_v_value = 0; PyObject *__pyx_v_namespace = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("setxattr (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_name,&__pyx_n_s_value,&__pyx_n_s_namespace,0}; PyObject* values[4] = {0,0,0,0}; values[3] = ((PyObject *)__pyx_n_u_user); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, 1); __PYX_ERR(3, 573, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_value)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, 2); __PYX_ERR(3, 573, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_namespace); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "setxattr") < 0)) __PYX_ERR(3, 573, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_name = values[1]; __pyx_v_value = ((PyObject*)values[2]); __pyx_v_namespace = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("setxattr", 0, 3, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 573, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_value), (&PyBytes_Type), 1, "value", 1))) __PYX_ERR(3, 573, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_99setxattr(__pyx_self, __pyx_v_path, __pyx_v_name, __pyx_v_value, __pyx_v_namespace); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_99setxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, PyObject *__pyx_v_value, PyObject *__pyx_v_namespace) { int __pyx_v_ret; Py_ssize_t __pyx_v_len_; char *__pyx_v_cvalue; char *__pyx_v_cpath; char *__pyx_v_cname; int __pyx_v_cnamespace; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_name_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_t_5; char *__pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("setxattr", 0); /* "pyfuse3.pyx":587 * ''' * * if not isinstance(path, str): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = PyUnicode_Check(__pyx_v_path); __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":588 * * if not isinstance(path, str): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str): */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 588, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 588, __pyx_L1_error) /* "pyfuse3.pyx":587 * ''' * * if not isinstance(path, str): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ } /* "pyfuse3.pyx":590 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ __pyx_t_2 = PyUnicode_Check(__pyx_v_name); __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pyfuse3.pyx":591 * * if not isinstance(name, str): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 591, __pyx_L1_error) /* "pyfuse3.pyx":590 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ } /* "pyfuse3.pyx":593 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ __Pyx_INCREF(__pyx_v_namespace); __pyx_t_3 = __pyx_v_namespace; __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_system, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 593, __pyx_L1_error) if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L6_bool_binop_done; } __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_user, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 593, __pyx_L1_error) __pyx_t_1 = __pyx_t_2; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":595 * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) # <<<<<<<<<<<<<< * * cdef int ret */ __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_v_namespace); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 595, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "pyfuse3.pyx":594 * * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' # <<<<<<<<<<<<<< * % namespace) * */ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 594, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(3, 594, __pyx_L1_error) /* "pyfuse3.pyx":593 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ } /* "pyfuse3.pyx":604 * cdef int cnamespace * * if namespace == 'system': # <<<<<<<<<<<<<< * cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM * else: */ __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_namespace, __pyx_n_u_system, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 604, __pyx_L1_error) if (__pyx_t_2) { /* "pyfuse3.pyx":605 * * if namespace == 'system': * cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM # <<<<<<<<<<<<<< * else: * cnamespace = libc_extra.EXTATTR_NAMESPACE_USER */ __pyx_v_cnamespace = EXTATTR_NAMESPACE_SYSTEM; /* "pyfuse3.pyx":604 * cdef int cnamespace * * if namespace == 'system': # <<<<<<<<<<<<<< * cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM * else: */ goto __pyx_L8; } /* "pyfuse3.pyx":607 * cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM * else: * cnamespace = libc_extra.EXTATTR_NAMESPACE_USER # <<<<<<<<<<<<<< * * path_b = str2bytes(path) */ /*else*/ { __pyx_v_cnamespace = EXTATTR_NAMESPACE_USER; } __pyx_L8:; /* "pyfuse3.pyx":609 * cnamespace = libc_extra.EXTATTR_NAMESPACE_USER * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) */ __pyx_t_4 = __pyx_f_7pyfuse3_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 609, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_path_b = __pyx_t_4; __pyx_t_4 = 0; /* "pyfuse3.pyx":610 * * path_b = str2bytes(path) * name_b = str2bytes(name) # <<<<<<<<<<<<<< * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b */ __pyx_t_4 = __pyx_f_7pyfuse3_str2bytes(__pyx_v_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_name_b = __pyx_t_4; __pyx_t_4 = 0; /* "pyfuse3.pyx":611 * path_b = str2bytes(path) * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) # <<<<<<<<<<<<<< * cpath = path_b * cname = name_b */ __pyx_t_5 = PyBytes_AsStringAndSize(__pyx_v_value, (&__pyx_v_cvalue), (&__pyx_v_len_)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(3, 611, __pyx_L1_error) /* "pyfuse3.pyx":612 * name_b = str2bytes(name) * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b # <<<<<<<<<<<<<< * cname = name_b * */ __pyx_t_6 = __Pyx_PyObject_AsWritableString(__pyx_v_path_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(3, 612, __pyx_L1_error) __pyx_v_cpath = ((char *)__pyx_t_6); /* "pyfuse3.pyx":613 * PyBytes_AsStringAndSize(value, &cvalue, &len_) * cpath = path_b * cname = name_b # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = __Pyx_PyObject_AsWritableString(__pyx_v_name_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(3, 613, __pyx_L1_error) __pyx_v_cname = ((char *)__pyx_t_6); /* "pyfuse3.pyx":615 * cname = name_b * * with nogil: # <<<<<<<<<<<<<< * # len_ is guaranteed positive * ret = libc_extra.setxattr_p( */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":617 * with nogil: * # len_ is guaranteed positive * ret = libc_extra.setxattr_p( # <<<<<<<<<<<<<< * cpath, cname, cvalue, len_, cnamespace) * */ __pyx_v_ret = setxattr_p(__pyx_v_cpath, __pyx_v_cname, __pyx_v_cvalue, ((size_t)__pyx_v_len_), __pyx_v_cnamespace); } /* "pyfuse3.pyx":615 * cname = name_b * * with nogil: # <<<<<<<<<<<<<< * # len_ is guaranteed positive * ret = libc_extra.setxattr_p( */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L11; } __pyx_L11:; } } /* "pyfuse3.pyx":620 * cpath, cname, cvalue, len_, cnamespace) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_2 = ((__pyx_v_ret != 0) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":621 * * if ret != 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * */ __pyx_t_4 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_f_7pyfuse3_strerror(errno); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); __Pyx_INCREF(__pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_path); __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 621, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 621, __pyx_L1_error) /* "pyfuse3.pyx":620 * cpath, cname, cvalue, len_, cnamespace) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ } /* "pyfuse3.pyx":573 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("pyfuse3.setxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_name_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":624 * * * def getxattr(path, name, size_t size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_102getxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_101getxattr[] = "getxattr(path, name, size_t size_guess=128, namespace=u'user')\nGet extended attribute\n\n *path* and *name* have to be of type `str`. In Python 3.x, they may\n contain surrogates. Returns a value of type `bytes`.\n\n If the caller knows the approximate size of the attribute value,\n it should be supplied in *size_guess*. If the guess turns out\n to be wrong, the system call has to be carried out three times\n (the first call will fail, the second determines the size and\n the third finally gets the value).\n\n Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to\n select the namespace for the extended attribute. For other platforms, this\n parameter is ignored.\n\n In contrast to the `os.getxattr` function from the standard library, the\n method provided by pyfuse3 is also available for non-Linux systems.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_102getxattr = {"getxattr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_102getxattr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_101getxattr}; static PyObject *__pyx_pw_7pyfuse3_102getxattr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_path = 0; PyObject *__pyx_v_name = 0; size_t __pyx_v_size_guess; PyObject *__pyx_v_namespace = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("getxattr (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_path,&__pyx_n_s_name,&__pyx_n_s_size_guess,&__pyx_n_s_namespace,0}; PyObject* values[4] = {0,0,0,0}; values[3] = ((PyObject *)__pyx_n_u_user); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_path)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("getxattr", 0, 2, 4, 1); __PYX_ERR(3, 624, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_size_guess); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_namespace); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "getxattr") < 0)) __PYX_ERR(3, 624, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_path = values[0]; __pyx_v_name = values[1]; if (values[2]) { __pyx_v_size_guess = __Pyx_PyInt_As_size_t(values[2]); if (unlikely((__pyx_v_size_guess == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 624, __pyx_L3_error) } else { __pyx_v_size_guess = ((size_t)0x80); } __pyx_v_namespace = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("getxattr", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 624, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_101getxattr(__pyx_self, __pyx_v_path, __pyx_v_name, __pyx_v_size_guess, __pyx_v_namespace); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_101getxattr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_path, PyObject *__pyx_v_name, size_t __pyx_v_size_guess, PyObject *__pyx_v_namespace) { Py_ssize_t __pyx_v_ret; char *__pyx_v_buf; char *__pyx_v_cpath; char *__pyx_v_cname; size_t __pyx_v_bufsize; int __pyx_v_cnamespace; PyObject *__pyx_v_path_b = NULL; PyObject *__pyx_v_name_b = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; char *__pyx_t_5; PyObject *__pyx_t_6; PyObject *__pyx_t_7 = NULL; int __pyx_t_8; int __pyx_t_9; char const *__pyx_t_10; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; PyObject *__pyx_t_13 = NULL; PyObject *__pyx_t_14 = NULL; PyObject *__pyx_t_15 = NULL; PyObject *__pyx_t_16 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("getxattr", 0); /* "pyfuse3.pyx":644 * ''' * * if not isinstance(path, str): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ __pyx_t_1 = PyUnicode_Check(__pyx_v_path); __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":645 * * if not isinstance(path, str): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * if not isinstance(name, str): */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__52, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 645, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 645, __pyx_L1_error) /* "pyfuse3.pyx":644 * ''' * * if not isinstance(path, str): # <<<<<<<<<<<<<< * raise TypeError('*path* argument must be of type str') * */ } /* "pyfuse3.pyx":647 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ __pyx_t_2 = PyUnicode_Check(__pyx_v_name); __pyx_t_1 = ((!(__pyx_t_2 != 0)) != 0); if (unlikely(__pyx_t_1)) { /* "pyfuse3.pyx":648 * * if not isinstance(name, str): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__53, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 648, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 648, __pyx_L1_error) /* "pyfuse3.pyx":647 * raise TypeError('*path* argument must be of type str') * * if not isinstance(name, str): # <<<<<<<<<<<<<< * raise TypeError('*name* argument must be of type str') * */ } /* "pyfuse3.pyx":650 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ __Pyx_INCREF(__pyx_v_namespace); __pyx_t_3 = __pyx_v_namespace; __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_system, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 650, __pyx_L1_error) if (__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; goto __pyx_L6_bool_binop_done; } __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_t_3, __pyx_n_u_user, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 650, __pyx_L1_error) __pyx_t_1 = __pyx_t_2; __pyx_L6_bool_binop_done:; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_2 = (__pyx_t_1 != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":652 * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) # <<<<<<<<<<<<<< * * cdef ssize_t ret */ __pyx_t_3 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_v_namespace); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 652, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "pyfuse3.pyx":651 * * if namespace not in ('system', 'user'): * raise ValueError('*namespace* parameter must be "system" or "user", not %s' # <<<<<<<<<<<<<< * % namespace) * */ __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 651, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(3, 651, __pyx_L1_error) /* "pyfuse3.pyx":650 * raise TypeError('*name* argument must be of type str') * * if namespace not in ('system', 'user'): # <<<<<<<<<<<<<< * raise ValueError('*namespace* parameter must be "system" or "user", not %s' * % namespace) */ } /* "pyfuse3.pyx":661 * cdef int cnamespace * * if namespace == 'system': # <<<<<<<<<<<<<< * cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM * else: */ __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_namespace, __pyx_n_u_system, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(3, 661, __pyx_L1_error) if (__pyx_t_2) { /* "pyfuse3.pyx":662 * * if namespace == 'system': * cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM # <<<<<<<<<<<<<< * else: * cnamespace = libc_extra.EXTATTR_NAMESPACE_USER */ __pyx_v_cnamespace = EXTATTR_NAMESPACE_SYSTEM; /* "pyfuse3.pyx":661 * cdef int cnamespace * * if namespace == 'system': # <<<<<<<<<<<<<< * cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM * else: */ goto __pyx_L8; } /* "pyfuse3.pyx":664 * cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM * else: * cnamespace = libc_extra.EXTATTR_NAMESPACE_USER # <<<<<<<<<<<<<< * * path_b = str2bytes(path) */ /*else*/ { __pyx_v_cnamespace = EXTATTR_NAMESPACE_USER; } __pyx_L8:; /* "pyfuse3.pyx":666 * cnamespace = libc_extra.EXTATTR_NAMESPACE_USER * * path_b = str2bytes(path) # <<<<<<<<<<<<<< * name_b = str2bytes(name) * cpath = path_b */ __pyx_t_4 = __pyx_f_7pyfuse3_str2bytes(__pyx_v_path); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 666, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_path_b = __pyx_t_4; __pyx_t_4 = 0; /* "pyfuse3.pyx":667 * * path_b = str2bytes(path) * name_b = str2bytes(name) # <<<<<<<<<<<<<< * cpath = path_b * cname = name_b */ __pyx_t_4 = __pyx_f_7pyfuse3_str2bytes(__pyx_v_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 667, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_name_b = __pyx_t_4; __pyx_t_4 = 0; /* "pyfuse3.pyx":668 * path_b = str2bytes(path) * name_b = str2bytes(name) * cpath = path_b # <<<<<<<<<<<<<< * cname = name_b * */ __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_path_b); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(3, 668, __pyx_L1_error) __pyx_v_cpath = ((char *)__pyx_t_5); /* "pyfuse3.pyx":669 * name_b = str2bytes(name) * cpath = path_b * cname = name_b # <<<<<<<<<<<<<< * * bufsize = size_guess */ __pyx_t_5 = __Pyx_PyObject_AsWritableString(__pyx_v_name_b); if (unlikely((!__pyx_t_5) && PyErr_Occurred())) __PYX_ERR(3, 669, __pyx_L1_error) __pyx_v_cname = ((char *)__pyx_t_5); /* "pyfuse3.pyx":671 * cname = name_b * * bufsize = size_guess # <<<<<<<<<<<<<< * buf = stdlib.malloc(bufsize * sizeof(char)) * */ __pyx_v_bufsize = __pyx_v_size_guess; /* "pyfuse3.pyx":672 * * bufsize = size_guess * buf = stdlib.malloc(bufsize * sizeof(char)) # <<<<<<<<<<<<<< * * if buf is NULL: */ __pyx_v_buf = ((char *)malloc((__pyx_v_bufsize * (sizeof(char))))); /* "pyfuse3.pyx":674 * buf = stdlib.malloc(bufsize * sizeof(char)) * * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_2 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_2) { /* "pyfuse3.pyx":675 * * if buf is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * try: */ __pyx_t_6 = PyErr_NoMemory(); if (unlikely(__pyx_t_6 == ((PyObject *)NULL))) __PYX_ERR(3, 675, __pyx_L1_error) /* "pyfuse3.pyx":674 * buf = stdlib.malloc(bufsize * sizeof(char)) * * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ } /* "pyfuse3.pyx":677 * cpython.exc.PyErr_NoMemory() * * try: # <<<<<<<<<<<<<< * with nogil: * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) */ /*try:*/ { /* "pyfuse3.pyx":678 * * try: * with nogil: # <<<<<<<<<<<<<< * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":679 * try: * with nogil: * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) # <<<<<<<<<<<<<< * * if ret < 0 and errno.errno == errno.ERANGE: */ __pyx_v_ret = getxattr_p(__pyx_v_cpath, __pyx_v_cname, __pyx_v_buf, __pyx_v_bufsize, __pyx_v_cnamespace); } /* "pyfuse3.pyx":678 * * try: * with nogil: # <<<<<<<<<<<<<< * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L15; } __pyx_L15:; } } /* "pyfuse3.pyx":681 * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) * * if ret < 0 and errno.errno == errno.ERANGE: # <<<<<<<<<<<<<< * with nogil: * ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) */ __pyx_t_1 = ((__pyx_v_ret < 0) != 0); if (__pyx_t_1) { } else { __pyx_t_2 = __pyx_t_1; goto __pyx_L17_bool_binop_done; } __pyx_t_1 = ((errno == ERANGE) != 0); __pyx_t_2 = __pyx_t_1; __pyx_L17_bool_binop_done:; if (__pyx_t_2) { /* "pyfuse3.pyx":682 * * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: # <<<<<<<<<<<<<< * ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) * if ret < 0: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":683 * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: * ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) # <<<<<<<<<<<<<< * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) */ __pyx_v_ret = getxattr_p(__pyx_v_cpath, __pyx_v_cname, NULL, 0, __pyx_v_cnamespace); } /* "pyfuse3.pyx":682 * * if ret < 0 and errno.errno == errno.ERANGE: * with nogil: # <<<<<<<<<<<<<< * ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) * if ret < 0: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L21; } __pyx_L21:; } } /* "pyfuse3.pyx":684 * with nogil: * ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret */ __pyx_t_2 = ((__pyx_v_ret < 0) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":685 * ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * bufsize = ret * stdlib.free(buf) */ __pyx_t_4 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 685, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __pyx_f_7pyfuse3_strerror(errno); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 685, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 685, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_3); __Pyx_INCREF(__pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_path); __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 685, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 685, __pyx_L11_error) /* "pyfuse3.pyx":684 * with nogil: * ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret */ } /* "pyfuse3.pyx":686 * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret # <<<<<<<<<<<<<< * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) */ __pyx_v_bufsize = ((size_t)__pyx_v_ret); /* "pyfuse3.pyx":687 * raise OSError(errno.errno, strerror(errno.errno), path) * bufsize = ret * stdlib.free(buf) # <<<<<<<<<<<<<< * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: */ free(__pyx_v_buf); /* "pyfuse3.pyx":688 * bufsize = ret * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) # <<<<<<<<<<<<<< * if buf is NULL: * cpython.exc.PyErr_NoMemory() */ __pyx_v_buf = ((char *)malloc((__pyx_v_bufsize * (sizeof(char))))); /* "pyfuse3.pyx":689 * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ __pyx_t_2 = ((__pyx_v_buf == NULL) != 0); if (__pyx_t_2) { /* "pyfuse3.pyx":690 * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: * cpython.exc.PyErr_NoMemory() # <<<<<<<<<<<<<< * * with nogil: */ __pyx_t_6 = PyErr_NoMemory(); if (unlikely(__pyx_t_6 == ((PyObject *)NULL))) __PYX_ERR(3, 690, __pyx_L11_error) /* "pyfuse3.pyx":689 * stdlib.free(buf) * buf = stdlib.malloc(bufsize * sizeof(char)) * if buf is NULL: # <<<<<<<<<<<<<< * cpython.exc.PyErr_NoMemory() * */ } /* "pyfuse3.pyx":692 * cpython.exc.PyErr_NoMemory() * * with nogil: # <<<<<<<<<<<<<< * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":693 * * with nogil: * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) # <<<<<<<<<<<<<< * * if ret < 0: */ __pyx_v_ret = getxattr_p(__pyx_v_cpath, __pyx_v_cname, __pyx_v_buf, __pyx_v_bufsize, __pyx_v_cnamespace); } /* "pyfuse3.pyx":692 * cpython.exc.PyErr_NoMemory() * * with nogil: # <<<<<<<<<<<<<< * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L26; } __pyx_L26:; } } /* "pyfuse3.pyx":681 * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) * * if ret < 0 and errno.errno == errno.ERANGE: # <<<<<<<<<<<<<< * with nogil: * ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) */ } /* "pyfuse3.pyx":695 * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) * * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ __pyx_t_2 = ((__pyx_v_ret < 0) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":696 * * if ret < 0: * raise OSError(errno.errno, strerror(errno.errno), path) # <<<<<<<<<<<<<< * * return PyBytes_FromStringAndSize(buf, ret) */ __pyx_t_3 = __Pyx_PyInt_From_int(errno); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 696, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_7 = __pyx_f_7pyfuse3_strerror(errno); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 696, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 696, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_7); __Pyx_INCREF(__pyx_v_path); __Pyx_GIVEREF(__pyx_v_path); PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_v_path); __pyx_t_3 = 0; __pyx_t_7 = 0; __pyx_t_7 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 696, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_7); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_7, 0, 0, 0); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; __PYX_ERR(3, 696, __pyx_L11_error) /* "pyfuse3.pyx":695 * ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) * * if ret < 0: # <<<<<<<<<<<<<< * raise OSError(errno.errno, strerror(errno.errno), path) * */ } /* "pyfuse3.pyx":698 * raise OSError(errno.errno, strerror(errno.errno), path) * * return PyBytes_FromStringAndSize(buf, ret) # <<<<<<<<<<<<<< * * finally: */ __Pyx_XDECREF(__pyx_r); __pyx_t_7 = PyBytes_FromStringAndSize(__pyx_v_buf, __pyx_v_ret); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 698, __pyx_L11_error) __Pyx_GOTREF(__pyx_t_7); __pyx_r = __pyx_t_7; __pyx_t_7 = 0; goto __pyx_L10_return; } /* "pyfuse3.pyx":701 * * finally: * stdlib.free(buf) # <<<<<<<<<<<<<< * * */ /*finally:*/ { __pyx_L11_error:; /*exception exit:*/{ __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_14, &__pyx_t_15, &__pyx_t_16); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13) < 0)) __Pyx_ErrFetch(&__pyx_t_11, &__pyx_t_12, &__pyx_t_13); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_12); __Pyx_XGOTREF(__pyx_t_13); __Pyx_XGOTREF(__pyx_t_14); __Pyx_XGOTREF(__pyx_t_15); __Pyx_XGOTREF(__pyx_t_16); __pyx_t_8 = __pyx_lineno; __pyx_t_9 = __pyx_clineno; __pyx_t_10 = __pyx_filename; { free(__pyx_v_buf); } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_14); __Pyx_XGIVEREF(__pyx_t_15); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_14, __pyx_t_15, __pyx_t_16); } __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_12); __Pyx_XGIVEREF(__pyx_t_13); __Pyx_ErrRestore(__pyx_t_11, __pyx_t_12, __pyx_t_13); __pyx_t_11 = 0; __pyx_t_12 = 0; __pyx_t_13 = 0; __pyx_t_14 = 0; __pyx_t_15 = 0; __pyx_t_16 = 0; __pyx_lineno = __pyx_t_8; __pyx_clineno = __pyx_t_9; __pyx_filename = __pyx_t_10; goto __pyx_L1_error; } __pyx_L10_return: { __pyx_t_16 = __pyx_r; __pyx_r = 0; free(__pyx_v_buf); __pyx_r = __pyx_t_16; __pyx_t_16 = 0; goto __pyx_L0; } } /* "pyfuse3.pyx":624 * * * def getxattr(path, name, size_t size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("pyfuse3.getxattr", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_path_b); __Pyx_XDECREF(__pyx_v_name_b); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":706 * default_options = frozenset(('default_permissions',)) * * def init(ops, mountpoint, options=default_options): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_104init(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_103init[] = "init(ops, mountpoint, options=default_options)\nInitialize and mount FUSE file system\n\n *ops* has to be an instance of the `Operations` class (or another\n class defining the same methods).\n\n *args* has to be a set of strings. `default_options` provides some\n reasonable defaults. It is recommended to use these options as a basis and\n add or remove options as necessary. For example::\n\n my_opts = set(pyfuse3.default_options)\n my_opts.add('allow_other')\n my_opts.discard('default_permissions')\n pyfuse3.init(ops, mountpoint, my_opts)\n\n Valid options are listed under ``struct\n fuse_opt fuse_mount_opts[]``\n (in `mount.c `_)\n and ``struct fuse_opt fuse_ll_opts[]``\n (in `fuse_lowlevel_c `_).\n "; static PyMethodDef __pyx_mdef_7pyfuse3_104init = {"init", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_104init, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_103init}; static PyObject *__pyx_pw_7pyfuse3_104init(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_ops = 0; PyObject *__pyx_v_mountpoint = 0; PyObject *__pyx_v_options = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("init (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_ops,&__pyx_n_s_mountpoint,&__pyx_n_s_options,0}; PyObject* values[3] = {0,0,0}; values[2] = __pyx_k__54; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ops)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mountpoint)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("init", 0, 2, 3, 1); __PYX_ERR(3, 706, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_options); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "init") < 0)) __PYX_ERR(3, 706, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_ops = values[0]; __pyx_v_mountpoint = values[1]; __pyx_v_options = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("init", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 706, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.init", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_103init(__pyx_self, __pyx_v_ops, __pyx_v_mountpoint, __pyx_v_options); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_103init(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_ops, PyObject *__pyx_v_mountpoint, PyObject *__pyx_v_options) { struct fuse_args __pyx_v_f_args; int __pyx_v_res; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; int __pyx_t_5; char *__pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("init", 0); /* "pyfuse3.pyx":728 * ''' * * log.debug('Initializing pyfuse3') # <<<<<<<<<<<<<< * cdef fuse_args f_args * cdef int res */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_log); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 728, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 728, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_kp_u_Initializing_pyfuse3) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Initializing_pyfuse3); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 728, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":732 * cdef int res * * if not isinstance(mountpoint, str): # <<<<<<<<<<<<<< * raise TypeError('*mountpoint_* argument must be of type str') * */ __pyx_t_4 = PyUnicode_Check(__pyx_v_mountpoint); __pyx_t_5 = ((!(__pyx_t_4 != 0)) != 0); if (unlikely(__pyx_t_5)) { /* "pyfuse3.pyx":733 * * if not isinstance(mountpoint, str): * raise TypeError('*mountpoint_* argument must be of type str') # <<<<<<<<<<<<<< * * global operations */ __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__55, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 733, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(3, 733, __pyx_L1_error) /* "pyfuse3.pyx":732 * cdef int res * * if not isinstance(mountpoint, str): # <<<<<<<<<<<<<< * raise TypeError('*mountpoint_* argument must be of type str') * */ } /* "pyfuse3.pyx":742 * global worker_data * * worker_data = _WorkerData() # <<<<<<<<<<<<<< * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) * operations = ops */ __pyx_t_1 = __Pyx_PyObject_CallNoArg(((PyObject *)__pyx_ptype_7pyfuse3__WorkerData)); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 742, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_XGOTREF(((PyObject *)__pyx_v_7pyfuse3_worker_data)); __Pyx_DECREF_SET(__pyx_v_7pyfuse3_worker_data, ((struct __pyx_obj_7pyfuse3__WorkerData *)__pyx_t_1)); __Pyx_GIVEREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":743 * * worker_data = _WorkerData() * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) # <<<<<<<<<<<<<< * operations = ops * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_os); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_path); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_abspath); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_v_mountpoint) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_v_mountpoint); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __pyx_f_7pyfuse3_str2bytes(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 743, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_v_7pyfuse3_mountpoint_b); __Pyx_DECREF_SET(__pyx_v_7pyfuse3_mountpoint_b, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":744 * worker_data = _WorkerData() * mountpoint_b = str2bytes(os.path.abspath(mountpoint)) * operations = ops # <<<<<<<<<<<<<< * * make_fuse_args(options, &f_args) */ __Pyx_INCREF(__pyx_v_ops); __Pyx_XGOTREF(__pyx_v_7pyfuse3_operations); __Pyx_DECREF_SET(__pyx_v_7pyfuse3_operations, __pyx_v_ops); __Pyx_GIVEREF(__pyx_v_ops); /* "pyfuse3.pyx":746 * operations = ops * * make_fuse_args(options, &f_args) # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_new') */ __pyx_t_3 = __pyx_f_7pyfuse3_make_fuse_args(__pyx_v_options, (&__pyx_v_f_args)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 746, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":748 * make_fuse_args(options, &f_args) * * log.debug('Calling fuse_session_new') # <<<<<<<<<<<<<< * init_fuse_ops() * session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_log); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_debug); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_1)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_1); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_1) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_1, __pyx_kp_u_Calling_fuse_session_new) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_Calling_fuse_session_new); __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 748, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":749 * * log.debug('Calling fuse_session_new') * init_fuse_ops() # <<<<<<<<<<<<<< * session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: */ __pyx_f_7pyfuse3_init_fuse_ops(); /* "pyfuse3.pyx":750 * log.debug('Calling fuse_session_new') * init_fuse_ops() * session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) # <<<<<<<<<<<<<< * if not session: * raise RuntimeError("fuse_session_new() failed") */ __pyx_v_7pyfuse3_session = fuse_session_new((&__pyx_v_f_args), (&__pyx_v_7pyfuse3_fuse_ops), (sizeof(__pyx_v_7pyfuse3_fuse_ops)), NULL); /* "pyfuse3.pyx":751 * init_fuse_ops() * session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: # <<<<<<<<<<<<<< * raise RuntimeError("fuse_session_new() failed") * */ __pyx_t_5 = ((!(__pyx_v_7pyfuse3_session != 0)) != 0); if (unlikely(__pyx_t_5)) { /* "pyfuse3.pyx":752 * session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: * raise RuntimeError("fuse_session_new() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_mount') */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__56, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 752, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 752, __pyx_L1_error) /* "pyfuse3.pyx":751 * init_fuse_ops() * session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: # <<<<<<<<<<<<<< * raise RuntimeError("fuse_session_new() failed") * */ } /* "pyfuse3.pyx":754 * raise RuntimeError("fuse_session_new() failed") * * log.debug('Calling fuse_session_mount') # <<<<<<<<<<<<<< * res = fuse_session_mount(session, mountpoint_b) * if res != 0: */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_log); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_debug); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_2)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_2); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_3 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_2, __pyx_kp_u_Calling_fuse_session_mount) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_kp_u_Calling_fuse_session_mount); __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 754, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":755 * * log.debug('Calling fuse_session_mount') * res = fuse_session_mount(session, mountpoint_b) # <<<<<<<<<<<<<< * if res != 0: * raise RuntimeError('fuse_session_mount failed') */ __pyx_t_6 = __Pyx_PyObject_AsWritableString(__pyx_v_7pyfuse3_mountpoint_b); if (unlikely((!__pyx_t_6) && PyErr_Occurred())) __PYX_ERR(3, 755, __pyx_L1_error) __pyx_v_res = fuse_session_mount(__pyx_v_7pyfuse3_session, ((char *)__pyx_t_6)); /* "pyfuse3.pyx":756 * log.debug('Calling fuse_session_mount') * res = fuse_session_mount(session, mountpoint_b) * if res != 0: # <<<<<<<<<<<<<< * raise RuntimeError('fuse_session_mount failed') * */ __pyx_t_5 = ((__pyx_v_res != 0) != 0); if (unlikely(__pyx_t_5)) { /* "pyfuse3.pyx":757 * res = fuse_session_mount(session, mountpoint_b) * if res != 0: * raise RuntimeError('fuse_session_mount failed') # <<<<<<<<<<<<<< * * session_fd = fuse_session_fd(session) */ __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__57, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 757, __pyx_L1_error) /* "pyfuse3.pyx":756 * log.debug('Calling fuse_session_mount') * res = fuse_session_mount(session, mountpoint_b) * if res != 0: # <<<<<<<<<<<<<< * raise RuntimeError('fuse_session_mount failed') * */ } /* "pyfuse3.pyx":759 * raise RuntimeError('fuse_session_mount failed') * * session_fd = fuse_session_fd(session) # <<<<<<<<<<<<<< * * */ __pyx_v_7pyfuse3_session_fd = fuse_session_fd(__pyx_v_7pyfuse3_session); /* "pyfuse3.pyx":706 * default_options = frozenset(('default_permissions',)) * * def init(ops, mountpoint, options=default_options): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_AddTraceback("pyfuse3.init", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_107generator31(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ /* "pyfuse3.pyx":763 * * @async_wrapper * async def main(int min_tasks=1, int max_tasks=99): # <<<<<<<<<<<<<< * '''Run FUSE main loop''' * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_106main(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_105main[] = "main(int min_tasks=1, int max_tasks=99)\nRun FUSE main loop"; static PyMethodDef __pyx_mdef_7pyfuse3_106main = {"main", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_106main, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_105main}; static PyObject *__pyx_pw_7pyfuse3_106main(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { int __pyx_v_min_tasks; int __pyx_v_max_tasks; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("main (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_min_tasks,&__pyx_n_s_max_tasks,0}; PyObject* values[2] = {0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_min_tasks); if (value) { values[0] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max_tasks); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "main") < 0)) __PYX_ERR(3, 763, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } if (values[0]) { __pyx_v_min_tasks = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_min_tasks == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 763, __pyx_L3_error) } else { __pyx_v_min_tasks = ((int)1); } if (values[1]) { __pyx_v_max_tasks = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_max_tasks == (int)-1) && PyErr_Occurred())) __PYX_ERR(3, 763, __pyx_L3_error) } else { __pyx_v_max_tasks = ((int)99); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("main", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 763, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.main", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_105main(__pyx_self, __pyx_v_min_tasks, __pyx_v_max_tasks); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_105main(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_min_tasks, int __pyx_v_max_tasks) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *__pyx_cur_scope; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("main", 0); __pyx_cur_scope = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *)__pyx_tp_new_7pyfuse3___pyx_scope_struct_31_main(__pyx_ptype_7pyfuse3___pyx_scope_struct_31_main, __pyx_empty_tuple, NULL); if (unlikely(!__pyx_cur_scope)) { __pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *)Py_None); __Pyx_INCREF(Py_None); __PYX_ERR(3, 763, __pyx_L1_error) } else { __Pyx_GOTREF(__pyx_cur_scope); } __pyx_cur_scope->__pyx_v_min_tasks = __pyx_v_min_tasks; __pyx_cur_scope->__pyx_v_max_tasks = __pyx_v_max_tasks; { __pyx_CoroutineObject *gen = __Pyx_Coroutine_New((__pyx_coroutine_body_t) __pyx_gb_7pyfuse3_107generator31, __pyx_codeobj__58, (PyObject *) __pyx_cur_scope, __pyx_n_s_main, __pyx_n_s_main, __pyx_n_s_pyfuse3); if (unlikely(!gen)) __PYX_ERR(3, 763, __pyx_L1_error) __Pyx_DECREF(__pyx_cur_scope); __Pyx_RefNannyFinishContext(); return (PyObject *) gen; } /* function exit code */ __pyx_L1_error:; __Pyx_AddTraceback("pyfuse3.main", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_DECREF(((PyObject *)__pyx_cur_scope)); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_gb_7pyfuse3_107generator31(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ { struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *__pyx_cur_scope = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *)__pyx_generator->closure); PyObject *__pyx_r = NULL; int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; int __pyx_t_12; int __pyx_t_13; int __pyx_t_14; char const *__pyx_t_15; PyObject *__pyx_t_16 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("main", 0); switch (__pyx_generator->resume_label) { case 0: goto __pyx_L3_first_run; case 1: goto __pyx_L9_resume_from_await; case 2: goto __pyx_L22_resume_from_await; case 3: goto __pyx_L23_resume_from_await; default: /* CPython raises the right error here */ __Pyx_RefNannyFinishContext(); return NULL; } __pyx_L3_first_run:; if (unlikely(!__pyx_sent_value)) __PYX_ERR(3, 763, __pyx_L1_error) /* "pyfuse3.pyx":766 * '''Run FUSE main loop''' * * if session == NULL: # <<<<<<<<<<<<<< * raise RuntimeError('Need to call init() before main()') * */ __pyx_t_1 = ((__pyx_v_7pyfuse3_session == NULL) != 0); if (unlikely(__pyx_t_1)) { /* "pyfuse3.pyx":767 * * if session == NULL: * raise RuntimeError('Need to call init() before main()') # <<<<<<<<<<<<<< * * global trio_token */ __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_RuntimeError, __pyx_tuple__59, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_Raise(__pyx_t_2, 0, 0, 0); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __PYX_ERR(3, 767, __pyx_L1_error) /* "pyfuse3.pyx":766 * '''Run FUSE main loop''' * * if session == NULL: # <<<<<<<<<<<<<< * raise RuntimeError('Need to call init() before main()') * */ } /* "pyfuse3.pyx":770 * * global trio_token * trio_token = trio.lowlevel.current_trio_token() # <<<<<<<<<<<<<< * * try: */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_trio); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 770, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_lowlevel); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 770, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_current_trio_token); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 770, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 770, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_trio_token, __pyx_t_2) < 0) __PYX_ERR(3, 770, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":772 * trio_token = trio.lowlevel.current_trio_token() * * try: # <<<<<<<<<<<<<< * async with trio.open_nursery() as nursery: * worker_data.task_count = 1 */ /*try:*/ { /* "pyfuse3.pyx":773 * * try: * async with trio.open_nursery() as nursery: # <<<<<<<<<<<<<< * worker_data.task_count = 1 * worker_data.task_serial = 1 */ /*with:*/ { __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_trio); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 773, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_open_nursery); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 773, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 773, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_5 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_aexit); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 773, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_2, __pyx_n_s_aenter); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 773, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_6) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 773, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_4); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_2); __pyx_cur_scope->__pyx_t_0 = __pyx_t_2; __Pyx_XGIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_t_1 = __pyx_t_5; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 1; return __pyx_r; __pyx_L9_resume_from_await:; __pyx_t_2 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_2); __pyx_t_5 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_sent_value)) __PYX_ERR(3, 773, __pyx_L8_error) __pyx_t_4 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_4); } else { __pyx_t_4 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_4) < 0) __PYX_ERR(3, 773, __pyx_L8_error) __Pyx_GOTREF(__pyx_t_4); } __pyx_t_3 = __pyx_t_4; __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /*try:*/ { { __Pyx_ExceptionSave(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_9); /*try:*/ { __Pyx_GIVEREF(__pyx_t_3); __pyx_cur_scope->__pyx_v_nursery = __pyx_t_3; __pyx_t_3 = 0; /* "pyfuse3.pyx":774 * try: * async with trio.open_nursery() as nursery: * worker_data.task_count = 1 # <<<<<<<<<<<<<< * worker_data.task_serial = 1 * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, */ __pyx_v_7pyfuse3_worker_data->task_count = 1; /* "pyfuse3.pyx":775 * async with trio.open_nursery() as nursery: * worker_data.task_count = 1 * worker_data.task_serial = 1 # <<<<<<<<<<<<<< * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, * name=worker_data.get_name()) */ __pyx_v_7pyfuse3_worker_data->task_serial = 1; /* "pyfuse3.pyx":776 * worker_data.task_count = 1 * worker_data.task_serial = 1 * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, # <<<<<<<<<<<<<< * name=worker_data.get_name()) * finally: */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_nursery, __pyx_n_s_start_soon); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 776, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_session_loop); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 776, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_min_tasks); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 776, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_cur_scope->__pyx_v_max_tasks); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 776, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_10 = PyTuple_New(4); if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 776, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_2); __Pyx_INCREF(__pyx_cur_scope->__pyx_v_nursery); __Pyx_GIVEREF(__pyx_cur_scope->__pyx_v_nursery); PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_cur_scope->__pyx_v_nursery); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_10, 2, __pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); PyTuple_SET_ITEM(__pyx_t_10, 3, __pyx_t_6); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_t_6 = 0; /* "pyfuse3.pyx":777 * worker_data.task_serial = 1 * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, * name=worker_data.get_name()) # <<<<<<<<<<<<<< * finally: * trio_token = None */ __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 777, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = ((struct __pyx_vtabstruct_7pyfuse3__WorkerData *)__pyx_v_7pyfuse3_worker_data->__pyx_vtab)->get_name(__pyx_v_7pyfuse3_worker_data); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 777, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_6, __pyx_n_s_name, __pyx_t_4) < 0) __PYX_ERR(3, 777, __pyx_L13_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyfuse3.pyx":776 * worker_data.task_count = 1 * worker_data.task_serial = 1 * nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, # <<<<<<<<<<<<<< * name=worker_data.get_name()) * finally: */ __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_10, __pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 776, __pyx_L13_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyfuse3.pyx":773 * * try: * async with trio.open_nursery() as nursery: # <<<<<<<<<<<<<< * worker_data.task_count = 1 * worker_data.task_serial = 1 */ } __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; goto __pyx_L18_try_end; __pyx_L13_error:; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; /*except:*/ { __Pyx_AddTraceback("pyfuse3.main", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_6, &__pyx_t_10) < 0) __PYX_ERR(3, 773, __pyx_L15_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_6); __Pyx_GOTREF(__pyx_t_10); __pyx_t_3 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_6, __pyx_t_10); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 773, __pyx_L15_except_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_11 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_3, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_11)) __PYX_ERR(3, 773, __pyx_L15_except_error) __Pyx_GOTREF(__pyx_t_11); __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_4); __pyx_cur_scope->__pyx_t_0 = __pyx_t_4; __Pyx_XGIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_t_1 = __pyx_t_5; __Pyx_XGIVEREF(__pyx_t_6); __pyx_cur_scope->__pyx_t_2 = __pyx_t_6; __Pyx_XGIVEREF(__pyx_t_7); __pyx_cur_scope->__pyx_t_3 = __pyx_t_7; __Pyx_XGIVEREF(__pyx_t_8); __pyx_cur_scope->__pyx_t_4 = __pyx_t_8; __Pyx_XGIVEREF(__pyx_t_9); __pyx_cur_scope->__pyx_t_5 = __pyx_t_9; __Pyx_XGIVEREF(__pyx_t_10); __pyx_cur_scope->__pyx_t_6 = __pyx_t_10; __Pyx_XGIVEREF(__pyx_t_11); __pyx_cur_scope->__pyx_t_7 = __pyx_t_11; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_SwapException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 2; return __pyx_r; __pyx_L22_resume_from_await:; __pyx_t_4 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_4); __pyx_t_5 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_5); __pyx_t_6 = __pyx_cur_scope->__pyx_t_2; __pyx_cur_scope->__pyx_t_2 = 0; __Pyx_XGOTREF(__pyx_t_6); __pyx_t_7 = __pyx_cur_scope->__pyx_t_3; __pyx_cur_scope->__pyx_t_3 = 0; __Pyx_XGOTREF(__pyx_t_7); __pyx_t_8 = __pyx_cur_scope->__pyx_t_4; __pyx_cur_scope->__pyx_t_4 = 0; __Pyx_XGOTREF(__pyx_t_8); __pyx_t_9 = __pyx_cur_scope->__pyx_t_5; __pyx_cur_scope->__pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_t_9); __pyx_t_10 = __pyx_cur_scope->__pyx_t_6; __pyx_cur_scope->__pyx_t_6 = 0; __Pyx_XGOTREF(__pyx_t_10); __pyx_t_11 = __pyx_cur_scope->__pyx_t_7; __pyx_cur_scope->__pyx_t_7 = 0; __Pyx_XGOTREF(__pyx_t_11); if (unlikely(!__pyx_sent_value)) __PYX_ERR(3, 773, __pyx_L15_except_error) __pyx_t_3 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_3); } else { __pyx_t_3 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_3) < 0) __PYX_ERR(3, 773, __pyx_L15_except_error) __Pyx_GOTREF(__pyx_t_3); } __pyx_t_11 = __pyx_t_3; __pyx_t_3 = 0; __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_11); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; if (__pyx_t_1 < 0) __PYX_ERR(3, 773, __pyx_L15_except_error) __pyx_t_12 = ((!(__pyx_t_1 != 0)) != 0); if (__pyx_t_12) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_10); __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_6, __pyx_t_10); __pyx_t_4 = 0; __pyx_t_6 = 0; __pyx_t_10 = 0; __PYX_ERR(3, 773, __pyx_L15_except_error) } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; goto __pyx_L14_exception_handled; } __pyx_L15_except_error:; __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); goto __pyx_L6_error; __pyx_L14_exception_handled:; __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_8, __pyx_t_9); __pyx_L18_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_5) { __pyx_t_9 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_tuple__38, NULL); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 773, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_9); __pyx_r = __Pyx_Coroutine_Yield_From(__pyx_generator, __pyx_t_9); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XGOTREF(__pyx_r); if (likely(__pyx_r)) { __Pyx_XGIVEREF(__pyx_t_5); __pyx_cur_scope->__pyx_t_0 = __pyx_t_5; __Pyx_XGIVEREF(__pyx_t_9); __pyx_cur_scope->__pyx_t_1 = __pyx_t_9; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); __Pyx_Coroutine_ResetAndClearException(__pyx_generator); /* return from generator, awaiting value */ __pyx_generator->resume_label = 3; return __pyx_r; __pyx_L23_resume_from_await:; __pyx_t_5 = __pyx_cur_scope->__pyx_t_0; __pyx_cur_scope->__pyx_t_0 = 0; __Pyx_XGOTREF(__pyx_t_5); __pyx_t_9 = __pyx_cur_scope->__pyx_t_1; __pyx_cur_scope->__pyx_t_1 = 0; __Pyx_XGOTREF(__pyx_t_9); if (unlikely(!__pyx_sent_value)) __PYX_ERR(3, 773, __pyx_L6_error) __pyx_t_10 = __pyx_sent_value; __Pyx_INCREF(__pyx_t_10); } else { __pyx_t_10 = NULL; if (__Pyx_PyGen_FetchStopIterationValue(&__pyx_t_10) < 0) __PYX_ERR(3, 773, __pyx_L6_error) __Pyx_GOTREF(__pyx_t_10); } __pyx_t_9 = __pyx_t_10; __pyx_t_10 = 0; __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; } goto __pyx_L12; } __pyx_L12:; } goto __pyx_L24; __pyx_L8_error:; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; goto __pyx_L6_error; __pyx_L24:; } } /* "pyfuse3.pyx":779 * name=worker_data.get_name()) * finally: * trio_token = None # <<<<<<<<<<<<<< * if _notify_queue is not None: * _notify_queue.put(None) */ /*finally:*/ { /*normal exit:*/{ if (PyDict_SetItem(__pyx_d, __pyx_n_s_trio_token, Py_None) < 0) __PYX_ERR(3, 779, __pyx_L1_error) /* "pyfuse3.pyx":780 * finally: * trio_token = None * if _notify_queue is not None: # <<<<<<<<<<<<<< * _notify_queue.put(None) * */ __pyx_t_12 = (__pyx_v_7pyfuse3__notify_queue != Py_None); __pyx_t_1 = (__pyx_t_12 != 0); if (__pyx_t_1) { /* "pyfuse3.pyx":781 * trio_token = None * if _notify_queue is not None: * _notify_queue.put(None) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3__notify_queue, __pyx_n_s_put); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_10 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_6, Py_None); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 781, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "pyfuse3.pyx":780 * finally: * trio_token = None * if _notify_queue is not None: # <<<<<<<<<<<<<< * _notify_queue.put(None) * */ } goto __pyx_L7; } __pyx_L6_error:; /*exception exit:*/{ __Pyx_PyThreadState_assign __pyx_t_5 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_7, &__pyx_t_11, &__pyx_t_16); if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_5, &__pyx_t_9, &__pyx_t_8) < 0)) __Pyx_ErrFetch(&__pyx_t_5, &__pyx_t_9, &__pyx_t_8); __Pyx_XGOTREF(__pyx_t_5); __Pyx_XGOTREF(__pyx_t_9); __Pyx_XGOTREF(__pyx_t_8); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_11); __Pyx_XGOTREF(__pyx_t_16); __pyx_t_13 = __pyx_lineno; __pyx_t_14 = __pyx_clineno; __pyx_t_15 = __pyx_filename; { /* "pyfuse3.pyx":779 * name=worker_data.get_name()) * finally: * trio_token = None # <<<<<<<<<<<<<< * if _notify_queue is not None: * _notify_queue.put(None) */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_trio_token, Py_None) < 0) __PYX_ERR(3, 779, __pyx_L27_error) /* "pyfuse3.pyx":780 * finally: * trio_token = None * if _notify_queue is not None: # <<<<<<<<<<<<<< * _notify_queue.put(None) * */ __pyx_t_1 = (__pyx_v_7pyfuse3__notify_queue != Py_None); __pyx_t_12 = (__pyx_t_1 != 0); if (__pyx_t_12) { /* "pyfuse3.pyx":781 * trio_token = None * if _notify_queue is not None: * _notify_queue.put(None) # <<<<<<<<<<<<<< * * */ __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3__notify_queue, __pyx_n_s_put); if (unlikely(!__pyx_t_6)) __PYX_ERR(3, 781, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_6); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_6, function); } } __pyx_t_10 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_6, __pyx_t_4, Py_None) : __Pyx_PyObject_CallOneArg(__pyx_t_6, Py_None); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 781, __pyx_L27_error) __Pyx_GOTREF(__pyx_t_10); __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; /* "pyfuse3.pyx":780 * finally: * trio_token = None * if _notify_queue is not None: # <<<<<<<<<<<<<< * _notify_queue.put(None) * */ } } if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_11, __pyx_t_16); } __Pyx_XGIVEREF(__pyx_t_5); __Pyx_XGIVEREF(__pyx_t_9); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ErrRestore(__pyx_t_5, __pyx_t_9, __pyx_t_8); __pyx_t_5 = 0; __pyx_t_9 = 0; __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; __pyx_lineno = __pyx_t_13; __pyx_clineno = __pyx_t_14; __pyx_filename = __pyx_t_15; goto __pyx_L1_error; __pyx_L27_error:; if (PY_MAJOR_VERSION >= 3) { __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_11); __Pyx_XGIVEREF(__pyx_t_16); __Pyx_ExceptionReset(__pyx_t_7, __pyx_t_11, __pyx_t_16); } __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_7 = 0; __pyx_t_11 = 0; __pyx_t_16 = 0; goto __pyx_L1_error; } __pyx_L7:; } CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); /* "pyfuse3.pyx":763 * * @async_wrapper * async def main(int min_tasks=1, int max_tasks=99): # <<<<<<<<<<<<<< * '''Run FUSE main loop''' * */ /* function exit code */ PyErr_SetNone(PyExc_StopIteration); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_10); __Pyx_AddTraceback("main", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_L0:; __Pyx_XDECREF(__pyx_r); __pyx_r = 0; #if !CYTHON_USE_EXC_INFO_STACK __Pyx_Coroutine_ResetAndClearException(__pyx_generator); #endif __pyx_generator->resume_label = -1; __Pyx_Coroutine_clear((PyObject*)__pyx_generator); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":784 * * * def terminate(): # <<<<<<<<<<<<<< * '''Terminate FUSE main loop. * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_109terminate(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused); /*proto*/ static char __pyx_doc_7pyfuse3_108terminate[] = "terminate()\nTerminate FUSE main loop.\n\n This function gracefully terminates the FUSE main loop (resulting in the call to\n main() to return).\n\n When called by a thread different from the one that runs the main loop, the call must\n be wrapped with `trio.from_thread.run_sync`. The necessary *trio_token* argument can\n (for convience) be retrieved from the `trio_token` module attribute.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_109terminate = {"terminate", (PyCFunction)__pyx_pw_7pyfuse3_109terminate, METH_NOARGS, __pyx_doc_7pyfuse3_108terminate}; static PyObject *__pyx_pw_7pyfuse3_109terminate(PyObject *__pyx_self, CYTHON_UNUSED PyObject *unused) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("terminate (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_108terminate(__pyx_self); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_108terminate(CYTHON_UNUSED PyObject *__pyx_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("terminate", 0); /* "pyfuse3.pyx":795 * ''' * * fuse_session_exit(session) # <<<<<<<<<<<<<< * trio.lowlevel.notify_closing(session_fd) * */ fuse_session_exit(__pyx_v_7pyfuse3_session); /* "pyfuse3.pyx":796 * * fuse_session_exit(session) * trio.lowlevel.notify_closing(session_fd) # <<<<<<<<<<<<<< * * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_trio); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_lowlevel); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_notify_closing); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_7pyfuse3_session_fd); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 796, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":784 * * * def terminate(): # <<<<<<<<<<<<<< * '''Terminate FUSE main loop. * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyfuse3.terminate", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":799 * * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Clean up and ensure filesystem is unmounted * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_111close(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_110close[] = "close(unmount=True)\nClean up and ensure filesystem is unmounted\n\n If *unmount* is False, only clean up operations are peformed, but the file\n system is not explicitly unmounted.\n\n Normally, the filesystem is unmounted by the user calling umount(8) or\n fusermount(1), which then terminates the FUSE main loop. However, the loop\n may also terminate as a result of an exception or a signal. In this case the\n filesystem remains mounted, but any attempt to access it will block (while\n the filesystem process is still running) or (after the filesystem process\n has terminated) return an error. If *unmount* is True, this function will\n ensure that the filesystem is properly unmounted.\n\n Note: if the connection to the kernel is terminated via the\n ``/sys/fs/fuse/connections/`` interface, this function will *not* unmount\n the filesystem even if *unmount* is True.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_111close = {"close", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_111close, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_110close}; static PyObject *__pyx_pw_7pyfuse3_111close(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_unmount = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_unmount,0}; PyObject* values[1] = {0}; values[0] = ((PyObject *)Py_True); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_unmount); if (value) { values[0] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "close") < 0)) __PYX_ERR(3, 799, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_unmount = values[0]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("close", 0, 0, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 799, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_110close(__pyx_self, __pyx_v_unmount); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_110close(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_unmount) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("close", 0); /* "pyfuse3.pyx":821 * global session * * if unmount: # <<<<<<<<<<<<<< * log.debug('Calling fuse_session_unmount') * fuse_session_unmount(session) */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_unmount); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 821, __pyx_L1_error) if (__pyx_t_1) { /* "pyfuse3.pyx":822 * * if unmount: * log.debug('Calling fuse_session_unmount') # <<<<<<<<<<<<<< * fuse_session_unmount(session) * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_log); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_debug); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_3)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_3); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_3) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_3, __pyx_kp_u_Calling_fuse_session_unmount) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_kp_u_Calling_fuse_session_unmount); __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 822, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":823 * if unmount: * log.debug('Calling fuse_session_unmount') * fuse_session_unmount(session) # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_destroy') */ fuse_session_unmount(__pyx_v_7pyfuse3_session); /* "pyfuse3.pyx":821 * global session * * if unmount: # <<<<<<<<<<<<<< * log.debug('Calling fuse_session_unmount') * fuse_session_unmount(session) */ } /* "pyfuse3.pyx":825 * fuse_session_unmount(session) * * log.debug('Calling fuse_session_destroy') # <<<<<<<<<<<<<< * fuse_session_destroy(session) * */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_debug); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_4, __pyx_kp_u_Calling_fuse_session_destroy) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_kp_u_Calling_fuse_session_destroy); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 825, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":826 * * log.debug('Calling fuse_session_destroy') * fuse_session_destroy(session) # <<<<<<<<<<<<<< * * mountpoint_b = None */ fuse_session_destroy(__pyx_v_7pyfuse3_session); /* "pyfuse3.pyx":828 * fuse_session_destroy(session) * * mountpoint_b = None # <<<<<<<<<<<<<< * session = NULL * */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_7pyfuse3_mountpoint_b); __Pyx_DECREF_SET(__pyx_v_7pyfuse3_mountpoint_b, Py_None); __Pyx_GIVEREF(Py_None); /* "pyfuse3.pyx":829 * * mountpoint_b = None * session = NULL # <<<<<<<<<<<<<< * * def invalidate_inode(fuse_ino_t inode, attr_only=False): */ __pyx_v_7pyfuse3_session = NULL; /* "pyfuse3.pyx":799 * * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Clean up and ensure filesystem is unmounted * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyfuse3.close", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":831 * session = NULL * * def invalidate_inode(fuse_ino_t inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_113invalidate_inode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_112invalidate_inode[] = "invalidate_inode(fuse_ino_t inode, attr_only=False)\nInvalidate cache for *inode*\n\n Instructs the FUSE kernel module to forgot cached attributes and\n data (unless *attr_only* is True) for *inode*.\n\n **This operation may block** if writeback caching is active and there is\n dirty data for the inode that is to be invalidated. Unfortunately there is\n no way to return control to the event loop until writeback is complete\n (leading to a deadlock if the necessary write() requests cannot be processed\n by the filesystem). Unless writeback caching is disabled, this function\n should therefore be called from a separate thread.\n\n If the operation is not supported by the kernel, raises `OSError`\n with errno ENOSYS.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_113invalidate_inode = {"invalidate_inode", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_113invalidate_inode, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_112invalidate_inode}; static PyObject *__pyx_pw_7pyfuse3_113invalidate_inode(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { fuse_ino_t __pyx_v_inode; PyObject *__pyx_v_attr_only = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_inode (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode,&__pyx_n_s_attr_only,0}; PyObject* values[2] = {0,0}; values[1] = ((PyObject *)Py_False); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inode)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_attr_only); if (value) { values[1] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_inode") < 0)) __PYX_ERR(3, 831, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_inode = __Pyx_PyInt_As_fuse_ino_t(values[0]); if (unlikely((__pyx_v_inode == ((fuse_ino_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 831, __pyx_L3_error) __pyx_v_attr_only = values[1]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_inode", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 831, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.invalidate_inode", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_112invalidate_inode(__pyx_self, __pyx_v_inode, __pyx_v_attr_only); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_112invalidate_inode(CYTHON_UNUSED PyObject *__pyx_self, fuse_ino_t __pyx_v_inode, PyObject *__pyx_v_attr_only) { int __pyx_v_ret; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_inode", 0); /* "pyfuse3.pyx":849 * * cdef int ret * if attr_only: # <<<<<<<<<<<<<< * with nogil: * ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0) */ __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_attr_only); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 849, __pyx_L1_error) if (__pyx_t_1) { /* "pyfuse3.pyx":850 * cdef int ret * if attr_only: * with nogil: # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0) * else: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":851 * if attr_only: * with nogil: * ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0) # <<<<<<<<<<<<<< * else: * with nogil: */ __pyx_v_ret = fuse_lowlevel_notify_inval_inode(__pyx_v_7pyfuse3_session, __pyx_v_inode, -1L, 0); } /* "pyfuse3.pyx":850 * cdef int ret * if attr_only: * with nogil: # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0) * else: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "pyfuse3.pyx":849 * * cdef int ret * if attr_only: # <<<<<<<<<<<<<< * with nogil: * ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0) */ goto __pyx_L3; } /* "pyfuse3.pyx":853 * ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0) * else: * with nogil: # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_inval_inode(session, inode, 0, 0) * */ /*else*/ { { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":854 * else: * with nogil: * ret = fuse_lowlevel_notify_inval_inode(session, inode, 0, 0) # <<<<<<<<<<<<<< * * if ret != 0: */ __pyx_v_ret = fuse_lowlevel_notify_inval_inode(__pyx_v_7pyfuse3_session, __pyx_v_inode, 0, 0); } /* "pyfuse3.pyx":853 * ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0) * else: * with nogil: # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_inval_inode(session, inode, 0, 0) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L9; } __pyx_L9:; } } } __pyx_L3:; /* "pyfuse3.pyx":856 * ret = fuse_lowlevel_notify_inval_inode(session, inode, 0, 0) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(-ret, 'fuse_lowlevel_notify_inval_inode returned: ' + strerror(-ret)) * */ __pyx_t_1 = ((__pyx_v_ret != 0) != 0); if (unlikely(__pyx_t_1)) { /* "pyfuse3.pyx":857 * * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_inval_inode returned: ' + strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_2 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = __pyx_f_7pyfuse3_strerror((-__pyx_v_ret)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = PyNumber_Add(__pyx_kp_u_fuse_lowlevel_notify_inval_inode, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_2); PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4); __pyx_t_2 = 0; __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_3, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 857, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_Raise(__pyx_t_4, 0, 0, 0); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(3, 857, __pyx_L1_error) /* "pyfuse3.pyx":856 * ret = fuse_lowlevel_notify_inval_inode(session, inode, 0, 0) * * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(-ret, 'fuse_lowlevel_notify_inval_inode returned: ' + strerror(-ret)) * */ } /* "pyfuse3.pyx":831 * session = NULL * * def invalidate_inode(fuse_ino_t inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_AddTraceback("pyfuse3.invalidate_inode", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":860 * * * def invalidate_entry(fuse_ino_t inode_p, bytes name, fuse_ino_t deleted=0): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_115invalidate_entry(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_114invalidate_entry[] = "invalidate_entry(fuse_ino_t inode_p, bytes name, fuse_ino_t deleted=0)\nInvalidate directory entry\n\n Instructs the FUSE kernel module to forget about the directory entry *name*\n in the directory with inode *inode_p*.\n\n If the inode passed as *deleted* matches the inode that is currently\n associated with *name* by the kernel, any inotify watchers of this inode are\n informed that the entry has been deleted.\n\n If there is a pending filesystem operation that is related to the parent\n directory or directory entry, this function will block until that operation\n has completed. Therefore, to avoid a deadlock this function must not be\n called while handling a related request, nor while holding a lock that could\n be needed for handling such a request.\n\n As for kernel 4.18, a \"related operation\" is a `~Operations.lookup`,\n `~Operations.symlink`, `~Operations.mknod`, `~Operations.mkdir`,\n `~Operations.unlink`, `~Operations.rename`, `~Operations.link` or\n `~Operations.create` request for the parent, and a `~Operations.setattr`,\n `~Operations.unlink`, `~Operations.rmdir`, `~Operations.rename`,\n `~Operations.setxattr`, `~Operations.removexattr` or `~Operations.readdir`\n request for the inode itself.\n\n For technical reasons, this function can also not return control to the main\n event loop but will actually block. To return control to the event loop\n while this function is running, call it in a separate thread using\n `trio.run_sync_in_worker_thread\n `_.\n A less complicated alternative is to use the `invalidate_entry_async` function\n instead.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_115invalidate_entry = {"invalidate_entry", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_115invalidate_entry, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_114invalidate_entry}; static PyObject *__pyx_pw_7pyfuse3_115invalidate_entry(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { fuse_ino_t __pyx_v_inode_p; PyObject *__pyx_v_name = 0; fuse_ino_t __pyx_v_deleted; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_entry (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode_p,&__pyx_n_s_name,&__pyx_n_s_deleted,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inode_p)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("invalidate_entry", 0, 2, 3, 1); __PYX_ERR(3, 860, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deleted); if (value) { values[2] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_entry") < 0)) __PYX_ERR(3, 860, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_inode_p = __Pyx_PyInt_As_fuse_ino_t(values[0]); if (unlikely((__pyx_v_inode_p == ((fuse_ino_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 860, __pyx_L3_error) __pyx_v_name = ((PyObject*)values[1]); if (values[2]) { __pyx_v_deleted = __Pyx_PyInt_As_fuse_ino_t(values[2]); if (unlikely((__pyx_v_deleted == ((fuse_ino_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 860, __pyx_L3_error) } else { __pyx_v_deleted = ((fuse_ino_t)0); } } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_entry", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 860, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.invalidate_entry", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyBytes_Type), 1, "name", 1))) __PYX_ERR(3, 860, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_114invalidate_entry(__pyx_self, __pyx_v_inode_p, __pyx_v_name, __pyx_v_deleted); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_114invalidate_entry(CYTHON_UNUSED PyObject *__pyx_self, fuse_ino_t __pyx_v_inode_p, PyObject *__pyx_v_name, fuse_ino_t __pyx_v_deleted) { char *__pyx_v_cname; Py_ssize_t __pyx_v_slen; size_t __pyx_v_len_; int __pyx_v_ret; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_entry", 0); /* "pyfuse3.pyx":898 * cdef int ret * * PyBytes_AsStringAndSize(name, &cname, &slen) # <<<<<<<<<<<<<< * # len_ is guaranteed positive * len_ = slen */ __pyx_t_1 = PyBytes_AsStringAndSize(__pyx_v_name, (&__pyx_v_cname), ((Py_ssize_t *)(&__pyx_v_slen))); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(3, 898, __pyx_L1_error) /* "pyfuse3.pyx":900 * PyBytes_AsStringAndSize(name, &cname, &slen) * # len_ is guaranteed positive * len_ = slen # <<<<<<<<<<<<<< * * if deleted: */ __pyx_v_len_ = ((size_t)__pyx_v_slen); /* "pyfuse3.pyx":902 * len_ = slen * * if deleted: # <<<<<<<<<<<<<< * with nogil: # might block! * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) */ __pyx_t_2 = (__pyx_v_deleted != 0); if (__pyx_t_2) { /* "pyfuse3.pyx":903 * * if deleted: * with nogil: # might block! # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) * if ret != 0: */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":904 * if deleted: * with nogil: # might block! * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) # <<<<<<<<<<<<<< * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_delete returned: ' */ __pyx_v_ret = fuse_lowlevel_notify_delete(__pyx_v_7pyfuse3_session, __pyx_v_inode_p, __pyx_v_deleted, __pyx_v_cname, __pyx_v_len_); } /* "pyfuse3.pyx":903 * * if deleted: * with nogil: # might block! # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) * if ret != 0: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L6; } __pyx_L6:; } } /* "pyfuse3.pyx":905 * with nogil: # might block! * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(-ret, 'fuse_lowlevel_notify_delete returned: ' * + strerror(-ret)) */ __pyx_t_2 = ((__pyx_v_ret != 0) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":906 * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_delete returned: ' # <<<<<<<<<<<<<< * + strerror(-ret)) * else: */ __pyx_t_3 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 906, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "pyfuse3.pyx":907 * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_delete returned: ' * + strerror(-ret)) # <<<<<<<<<<<<<< * else: * with nogil: # might block! */ __pyx_t_4 = __pyx_f_7pyfuse3_strerror((-__pyx_v_ret)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyNumber_Add(__pyx_kp_u_fuse_lowlevel_notify_delete_retu, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 907, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyfuse3.pyx":906 * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_delete returned: ' # <<<<<<<<<<<<<< * + strerror(-ret)) * else: */ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 906, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5); __pyx_t_3 = 0; __pyx_t_5 = 0; __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 906, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_5, 0, 0, 0); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __PYX_ERR(3, 906, __pyx_L1_error) /* "pyfuse3.pyx":905 * with nogil: # might block! * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(-ret, 'fuse_lowlevel_notify_delete returned: ' * + strerror(-ret)) */ } /* "pyfuse3.pyx":902 * len_ = slen * * if deleted: # <<<<<<<<<<<<<< * with nogil: # might block! * ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) */ goto __pyx_L3; } /* "pyfuse3.pyx":909 * + strerror(-ret)) * else: * with nogil: # might block! # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_) * if ret != 0: */ /*else*/ { { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":910 * else: * with nogil: # might block! * ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_) # <<<<<<<<<<<<<< * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_inval_entry returned: ' */ __pyx_v_ret = fuse_lowlevel_notify_inval_entry(__pyx_v_7pyfuse3_session, __pyx_v_inode_p, __pyx_v_cname, __pyx_v_len_); } /* "pyfuse3.pyx":909 * + strerror(-ret)) * else: * with nogil: # might block! # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_) * if ret != 0: */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L10; } __pyx_L10:; } } /* "pyfuse3.pyx":911 * with nogil: # might block! * ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_) * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(-ret, 'fuse_lowlevel_notify_inval_entry returned: ' * + strerror(-ret)) */ __pyx_t_2 = ((__pyx_v_ret != 0) != 0); if (unlikely(__pyx_t_2)) { /* "pyfuse3.pyx":912 * ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_) * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_inval_entry returned: ' # <<<<<<<<<<<<<< * + strerror(-ret)) * */ __pyx_t_5 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 912, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); /* "pyfuse3.pyx":913 * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_inval_entry returned: ' * + strerror(-ret)) # <<<<<<<<<<<<<< * * */ __pyx_t_4 = __pyx_f_7pyfuse3_strerror((-__pyx_v_ret)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_3 = PyNumber_Add(__pyx_kp_u_fuse_lowlevel_notify_inval_entry, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 913, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyfuse3.pyx":912 * ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_) * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_inval_entry returned: ' # <<<<<<<<<<<<<< * + strerror(-ret)) * */ __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 912, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); __Pyx_GIVEREF(__pyx_t_3); PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_3); __pyx_t_5 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_4, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 912, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(3, 912, __pyx_L1_error) /* "pyfuse3.pyx":911 * with nogil: # might block! * ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_) * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(-ret, 'fuse_lowlevel_notify_inval_entry returned: ' * + strerror(-ret)) */ } } __pyx_L3:; /* "pyfuse3.pyx":860 * * * def invalidate_entry(fuse_ino_t inode_p, bytes name, fuse_ino_t deleted=0): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyfuse3.invalidate_entry", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":916 * * * def invalidate_entry_async(inode_p, name, deleted=0, ignore_enoent=False): # <<<<<<<<<<<<<< * '''Asynchronously invalidate directory entry * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_117invalidate_entry_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_116invalidate_entry_async[] = "invalidate_entry_async(inode_p, name, deleted=0, ignore_enoent=False)\nAsynchronously invalidate directory entry\n\n This function performs the same operation as `invalidate_entry`, but does so\n asynchronously in a separate thread. This avoids the deadlocks that may\n occur when using `invalidate_entry` from within a request handler, but means\n that the function generally returns before the kernel has actually\n invalidated the entry, and that no errors can be reported (they will be\n logged though).\n\n The directory entries that are to be invalidated are put in an unbounded\n queue which is processed by a single thread. This means that if the entry at\n the beginning of the queue cannot be invalidated yet because a related file\n system operation is still in progress, none of the other entries will be\n processed and repeated calls to this function will result in continued\n growth of the queue.\n\n If there are errors, an exception is logged using the `logging` module.\n\n If *ignore_enoent* is True, ignore ENOENT errors (which occur if the\n kernel doesn't actually have knowledge of the entry that is to be\n removed).\n "; static PyMethodDef __pyx_mdef_7pyfuse3_117invalidate_entry_async = {"invalidate_entry_async", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_117invalidate_entry_async, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_116invalidate_entry_async}; static PyObject *__pyx_pw_7pyfuse3_117invalidate_entry_async(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_inode_p = 0; PyObject *__pyx_v_name = 0; PyObject *__pyx_v_deleted = 0; PyObject *__pyx_v_ignore_enoent = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("invalidate_entry_async (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode_p,&__pyx_n_s_name,&__pyx_n_s_deleted,&__pyx_n_s_ignore_enoent,0}; PyObject* values[4] = {0,0,0,0}; values[2] = ((PyObject *)__pyx_int_0); values[3] = ((PyObject *)Py_False); if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inode_p)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("invalidate_entry_async", 0, 2, 4, 1); __PYX_ERR(3, 916, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_deleted); if (value) { values[2] = value; kw_args--; } } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ignore_enoent); if (value) { values[3] = value; kw_args--; } } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "invalidate_entry_async") < 0)) __PYX_ERR(3, 916, __pyx_L3_error) } } else { switch (PyTuple_GET_SIZE(__pyx_args)) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[0] = PyTuple_GET_ITEM(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } } __pyx_v_inode_p = values[0]; __pyx_v_name = values[1]; __pyx_v_deleted = values[2]; __pyx_v_ignore_enoent = values[3]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("invalidate_entry_async", 0, 2, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 916, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.invalidate_entry_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_116invalidate_entry_async(__pyx_self, __pyx_v_inode_p, __pyx_v_name, __pyx_v_deleted, __pyx_v_ignore_enoent); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_116invalidate_entry_async(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_inode_p, PyObject *__pyx_v_name, PyObject *__pyx_v_deleted, PyObject *__pyx_v_ignore_enoent) { PyObject *__pyx_v_t = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("invalidate_entry_async", 0); /* "pyfuse3.pyx":942 * global _notify_queue * * if _notify_queue is None: # <<<<<<<<<<<<<< * log.debug('Starting notify worker.') * _notify_queue = Queue() */ __pyx_t_1 = (__pyx_v_7pyfuse3__notify_queue == Py_None); __pyx_t_2 = (__pyx_t_1 != 0); if (__pyx_t_2) { /* "pyfuse3.pyx":943 * * if _notify_queue is None: * log.debug('Starting notify worker.') # <<<<<<<<<<<<<< * _notify_queue = Queue() * t = threading.Thread(target=_notify_loop) */ __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_log); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 943, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_n_s_debug); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 943, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_4, __pyx_kp_u_Starting_notify_worker) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_kp_u_Starting_notify_worker); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 943, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":944 * if _notify_queue is None: * log.debug('Starting notify worker.') * _notify_queue = Queue() # <<<<<<<<<<<<<< * t = threading.Thread(target=_notify_loop) * t.daemon = True */ __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_Queue); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 944, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_5))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_5, function); } } __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_5); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 944, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_XGOTREF(__pyx_v_7pyfuse3__notify_queue); __Pyx_DECREF_SET(__pyx_v_7pyfuse3__notify_queue, __pyx_t_3); __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":945 * log.debug('Starting notify worker.') * _notify_queue = Queue() * t = threading.Thread(target=_notify_loop) # <<<<<<<<<<<<<< * t.daemon = True * t.start() */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_threading); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_n_s_Thread); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_notify_loop); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_target, __pyx_t_4) < 0) __PYX_ERR(3, 945, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_v_t = __pyx_t_4; __pyx_t_4 = 0; /* "pyfuse3.pyx":946 * _notify_queue = Queue() * t = threading.Thread(target=_notify_loop) * t.daemon = True # <<<<<<<<<<<<<< * t.start() * */ if (__Pyx_PyObject_SetAttrStr(__pyx_v_t, __pyx_n_s_daemon, Py_True) < 0) __PYX_ERR(3, 946, __pyx_L1_error) /* "pyfuse3.pyx":947 * t = threading.Thread(target=_notify_loop) * t.daemon = True * t.start() # <<<<<<<<<<<<<< * * _notify_queue.put((inode_p, name, deleted, ignore_enoent)) */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t, __pyx_n_s_start); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 947, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_3); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 947, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyfuse3.pyx":942 * global _notify_queue * * if _notify_queue is None: # <<<<<<<<<<<<<< * log.debug('Starting notify worker.') * _notify_queue = Queue() */ } /* "pyfuse3.pyx":949 * t.start() * * _notify_queue.put((inode_p, name, deleted, ignore_enoent)) # <<<<<<<<<<<<<< * * */ __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_7pyfuse3__notify_queue, __pyx_n_s_put); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __Pyx_INCREF(__pyx_v_inode_p); __Pyx_GIVEREF(__pyx_v_inode_p); PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_inode_p); __Pyx_INCREF(__pyx_v_name); __Pyx_GIVEREF(__pyx_v_name); PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_name); __Pyx_INCREF(__pyx_v_deleted); __Pyx_GIVEREF(__pyx_v_deleted); PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_deleted); __Pyx_INCREF(__pyx_v_ignore_enoent); __Pyx_GIVEREF(__pyx_v_ignore_enoent); PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_v_ignore_enoent); __pyx_t_6 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); if (likely(__pyx_t_6)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); __Pyx_INCREF(__pyx_t_6); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_3, function); } } __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 949, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyfuse3.pyx":916 * * * def invalidate_entry_async(inode_p, name, deleted=0, ignore_enoent=False): # <<<<<<<<<<<<<< * '''Asynchronously invalidate directory entry * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("pyfuse3.invalidate_entry_async", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_t); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":952 * * * def notify_store(inode, offset, data): # <<<<<<<<<<<<<< * '''Store data in kernel page cache * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_119notify_store(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_118notify_store[] = "notify_store(inode, offset, data)\nStore data in kernel page cache\n\n Sends *data* for the kernel to store it in the page cache for *inode* at\n *offset*. If this provides data beyond the current file size, the file is\n automatically extended.\n\n If this function raises an exception, the store may still have completed\n partially.\n\n If the operation is not supported by the kernel, raises `OSError`\n with errno ENOSYS.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_119notify_store = {"notify_store", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_119notify_store, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_118notify_store}; static PyObject *__pyx_pw_7pyfuse3_119notify_store(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_inode = 0; PyObject *__pyx_v_offset = 0; PyObject *__pyx_v_data = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("notify_store (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_inode,&__pyx_n_s_offset,&__pyx_n_s_data,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_inode)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_offset)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("notify_store", 1, 3, 3, 1); __PYX_ERR(3, 952, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_data)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("notify_store", 1, 3, 3, 2); __PYX_ERR(3, 952, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "notify_store") < 0)) __PYX_ERR(3, 952, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v_inode = values[0]; __pyx_v_offset = values[1]; __pyx_v_data = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("notify_store", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 952, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.notify_store", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_118notify_store(__pyx_self, __pyx_v_inode, __pyx_v_offset, __pyx_v_data); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_118notify_store(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_inode, PyObject *__pyx_v_offset, PyObject *__pyx_v_data) { int __pyx_v_ret; fuse_ino_t __pyx_v_ino; off_t __pyx_v_off; Py_buffer __pyx_v_pybuf; struct fuse_bufvec __pyx_v_bufvec; struct fuse_buf *__pyx_v_buf; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; struct fuse_buf *__pyx_t_2; void *__pyx_t_3; fuse_ino_t __pyx_t_4; off_t __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("notify_store", 0); /* "pyfuse3.pyx":976 * cdef fuse_buf *buf * * PyObject_GetBuffer(data, &pybuf, PyBUF_CONTIG_RO) # <<<<<<<<<<<<<< * bufvec.count = 1 * bufvec.idx = 0 */ __pyx_t_1 = PyObject_GetBuffer(__pyx_v_data, (&__pyx_v_pybuf), PyBUF_CONTIG_RO); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(3, 976, __pyx_L1_error) /* "pyfuse3.pyx":977 * * PyObject_GetBuffer(data, &pybuf, PyBUF_CONTIG_RO) * bufvec.count = 1 # <<<<<<<<<<<<<< * bufvec.idx = 0 * bufvec.off = 0 */ __pyx_v_bufvec.count = 1; /* "pyfuse3.pyx":978 * PyObject_GetBuffer(data, &pybuf, PyBUF_CONTIG_RO) * bufvec.count = 1 * bufvec.idx = 0 # <<<<<<<<<<<<<< * bufvec.off = 0 * */ __pyx_v_bufvec.idx = 0; /* "pyfuse3.pyx":979 * bufvec.count = 1 * bufvec.idx = 0 * bufvec.off = 0 # <<<<<<<<<<<<<< * * buf = bufvec.buf */ __pyx_v_bufvec.off = 0; /* "pyfuse3.pyx":981 * bufvec.off = 0 * * buf = bufvec.buf # <<<<<<<<<<<<<< * buf[0].flags = 0 * buf[0].mem = pybuf.buf */ __pyx_t_2 = __pyx_v_bufvec.buf; __pyx_v_buf = __pyx_t_2; /* "pyfuse3.pyx":982 * * buf = bufvec.buf * buf[0].flags = 0 # <<<<<<<<<<<<<< * buf[0].mem = pybuf.buf * buf[0].size = pybuf.len # guaranteed positive */ (__pyx_v_buf[0]).flags = 0; /* "pyfuse3.pyx":983 * buf = bufvec.buf * buf[0].flags = 0 * buf[0].mem = pybuf.buf # <<<<<<<<<<<<<< * buf[0].size = pybuf.len # guaranteed positive * */ __pyx_t_3 = __pyx_v_pybuf.buf; (__pyx_v_buf[0]).mem = __pyx_t_3; /* "pyfuse3.pyx":984 * buf[0].flags = 0 * buf[0].mem = pybuf.buf * buf[0].size = pybuf.len # guaranteed positive # <<<<<<<<<<<<<< * * ino = inode */ (__pyx_v_buf[0]).size = ((size_t)__pyx_v_pybuf.len); /* "pyfuse3.pyx":986 * buf[0].size = pybuf.len # guaranteed positive * * ino = inode # <<<<<<<<<<<<<< * off = offset * with nogil: */ __pyx_t_4 = __Pyx_PyInt_As_fuse_ino_t(__pyx_v_inode); if (unlikely((__pyx_t_4 == ((fuse_ino_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 986, __pyx_L1_error) __pyx_v_ino = __pyx_t_4; /* "pyfuse3.pyx":987 * * ino = inode * off = offset # <<<<<<<<<<<<<< * with nogil: * ret = fuse_lowlevel_notify_store(session, ino, off, &bufvec, 0) */ __pyx_t_5 = __Pyx_PyInt_As_off_t(__pyx_v_offset); if (unlikely((__pyx_t_5 == ((off_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 987, __pyx_L1_error) __pyx_v_off = __pyx_t_5; /* "pyfuse3.pyx":988 * ino = inode * off = offset * with nogil: # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_store(session, ino, off, &bufvec, 0) * */ { #ifdef WITH_THREAD PyThreadState *_save; Py_UNBLOCK_THREADS __Pyx_FastGIL_Remember(); #endif /*try:*/ { /* "pyfuse3.pyx":989 * off = offset * with nogil: * ret = fuse_lowlevel_notify_store(session, ino, off, &bufvec, 0) # <<<<<<<<<<<<<< * * PyBuffer_Release(&pybuf) */ __pyx_v_ret = fuse_lowlevel_notify_store(__pyx_v_7pyfuse3_session, __pyx_v_ino, __pyx_v_off, (&__pyx_v_bufvec), 0); } /* "pyfuse3.pyx":988 * ino = inode * off = offset * with nogil: # <<<<<<<<<<<<<< * ret = fuse_lowlevel_notify_store(session, ino, off, &bufvec, 0) * */ /*finally:*/ { /*normal exit:*/{ #ifdef WITH_THREAD __Pyx_FastGIL_Forget(); Py_BLOCK_THREADS #endif goto __pyx_L5; } __pyx_L5:; } } /* "pyfuse3.pyx":991 * ret = fuse_lowlevel_notify_store(session, ino, off, &bufvec, 0) * * PyBuffer_Release(&pybuf) # <<<<<<<<<<<<<< * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) */ PyBuffer_Release((&__pyx_v_pybuf)); /* "pyfuse3.pyx":992 * * PyBuffer_Release(&pybuf) * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) * */ __pyx_t_6 = ((__pyx_v_ret != 0) != 0); if (unlikely(__pyx_t_6)) { /* "pyfuse3.pyx":993 * PyBuffer_Release(&pybuf) * if ret != 0: * raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) # <<<<<<<<<<<<<< * * def get_sup_groups(pid): */ __pyx_t_7 = __Pyx_PyInt_From_int((-__pyx_v_ret)); if (unlikely(!__pyx_t_7)) __PYX_ERR(3, 993, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __pyx_f_7pyfuse3_strerror((-__pyx_v_ret)); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 993, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __pyx_t_9 = PyNumber_Add(__pyx_kp_u_fuse_lowlevel_notify_store_retur, __pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 993, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 993, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7); __Pyx_GIVEREF(__pyx_t_9); PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_9); __pyx_t_7 = 0; __pyx_t_9 = 0; __pyx_t_9 = __Pyx_PyObject_Call(__pyx_builtin_OSError, __pyx_t_8, NULL); if (unlikely(!__pyx_t_9)) __PYX_ERR(3, 993, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_9); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_Raise(__pyx_t_9, 0, 0, 0); __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; __PYX_ERR(3, 993, __pyx_L1_error) /* "pyfuse3.pyx":992 * * PyBuffer_Release(&pybuf) * if ret != 0: # <<<<<<<<<<<<<< * raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) * */ } /* "pyfuse3.pyx":952 * * * def notify_store(inode, offset, data): # <<<<<<<<<<<<<< * '''Store data in kernel page cache * */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("pyfuse3.notify_store", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":995 * raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) * * def get_sup_groups(pid): # <<<<<<<<<<<<<< * '''Return supplementary group ids of *pid* * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_121get_sup_groups(PyObject *__pyx_self, PyObject *__pyx_v_pid); /*proto*/ static char __pyx_doc_7pyfuse3_120get_sup_groups[] = "get_sup_groups(pid)\nReturn supplementary group ids of *pid*\n\n This function is relatively expensive because it has to read the group ids\n from ``/proc/[pid]/status``. For the same reason, it will also not work on\n systems that do not provide a ``/proc`` file system.\n\n Returns a set.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_121get_sup_groups = {"get_sup_groups", (PyCFunction)__pyx_pw_7pyfuse3_121get_sup_groups, METH_O, __pyx_doc_7pyfuse3_120get_sup_groups}; static PyObject *__pyx_pw_7pyfuse3_121get_sup_groups(PyObject *__pyx_self, PyObject *__pyx_v_pid) { PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_sup_groups (wrapper)", 0); __pyx_r = __pyx_pf_7pyfuse3_120get_sup_groups(__pyx_self, ((PyObject *)__pyx_v_pid)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_120get_sup_groups(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pid) { PyObject *__pyx_v_fh = NULL; PyObject *__pyx_v_line = NULL; PyObject *__pyx_v_gids = NULL; PyObject *__pyx_v_x = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; Py_ssize_t __pyx_t_9; PyObject *(*__pyx_t_10)(PyObject *); int __pyx_t_11; PyObject *__pyx_t_12 = NULL; int __pyx_t_13; int __pyx_t_14; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("get_sup_groups", 0); /* "pyfuse3.pyx":1005 * ''' * * with open('/proc/%d/status' % pid, 'r') as fh: # <<<<<<<<<<<<<< * for line in fh: * if line.startswith('Groups:'): */ /*with:*/ { __pyx_t_1 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_proc_d_status, __pyx_v_pid); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); __Pyx_INCREF(__pyx_n_u_r); __Pyx_GIVEREF(__pyx_n_u_r); PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_n_u_r); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_open, __pyx_t_2, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_3 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_n_s_exit); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 1005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = __Pyx_PyObject_LookupSpecial(__pyx_t_1, __pyx_n_s_enter); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1005, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_4))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_4, function); } } __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_5) : __Pyx_PyObject_CallNoArg(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1005, __pyx_L3_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_4 = __pyx_t_2; __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /*try:*/ { { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ExceptionSave(&__pyx_t_6, &__pyx_t_7, &__pyx_t_8); __Pyx_XGOTREF(__pyx_t_6); __Pyx_XGOTREF(__pyx_t_7); __Pyx_XGOTREF(__pyx_t_8); /*try:*/ { __pyx_v_fh = __pyx_t_4; __pyx_t_4 = 0; /* "pyfuse3.pyx":1006 * * with open('/proc/%d/status' % pid, 'r') as fh: * for line in fh: # <<<<<<<<<<<<<< * if line.startswith('Groups:'): * break */ if (likely(PyList_CheckExact(__pyx_v_fh)) || PyTuple_CheckExact(__pyx_v_fh)) { __pyx_t_4 = __pyx_v_fh; __Pyx_INCREF(__pyx_t_4); __pyx_t_9 = 0; __pyx_t_10 = NULL; } else { __pyx_t_9 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_fh); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1006, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_10 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1006, __pyx_L7_error) } for (;;) { if (likely(!__pyx_t_10)) { if (likely(PyList_CheckExact(__pyx_t_4))) { if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(3, 1006, __pyx_L7_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1006, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_4)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(3, 1006, __pyx_L7_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_4, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1006, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); #endif } } else { __pyx_t_1 = __pyx_t_10(__pyx_t_4); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(3, 1006, __pyx_L7_error) } break; } __Pyx_GOTREF(__pyx_t_1); } __Pyx_XDECREF_SET(__pyx_v_line, __pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":1007 * with open('/proc/%d/status' % pid, 'r') as fh: * for line in fh: * if line.startswith('Groups:'): # <<<<<<<<<<<<<< * break * else: */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_line, __pyx_n_s_startswith); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1007, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_1 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_kp_u_Groups) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_kp_u_Groups); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1007, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_11 < 0)) __PYX_ERR(3, 1007, __pyx_L7_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_11) { /* "pyfuse3.pyx":1008 * for line in fh: * if line.startswith('Groups:'): * break # <<<<<<<<<<<<<< * else: * raise RuntimeError("Unable to parse %s" % fh.name) */ goto __pyx_L14_break; /* "pyfuse3.pyx":1007 * with open('/proc/%d/status' % pid, 'r') as fh: * for line in fh: * if line.startswith('Groups:'): # <<<<<<<<<<<<<< * break * else: */ } /* "pyfuse3.pyx":1006 * * with open('/proc/%d/status' % pid, 'r') as fh: * for line in fh: # <<<<<<<<<<<<<< * if line.startswith('Groups:'): * break */ } /*else*/ { /* "pyfuse3.pyx":1010 * break * else: * raise RuntimeError("Unable to parse %s" % fh.name) # <<<<<<<<<<<<<< * gids = set() * for x in line.split()[1:]: */ __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_fh, __pyx_n_s_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1010, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_kp_u_Unable_to_parse_s, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1010, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_RuntimeError, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1010, __pyx_L7_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_1, 0, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __PYX_ERR(3, 1010, __pyx_L7_error) } /* "pyfuse3.pyx":1006 * * with open('/proc/%d/status' % pid, 'r') as fh: * for line in fh: # <<<<<<<<<<<<<< * if line.startswith('Groups:'): * break */ __pyx_L14_break:; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "pyfuse3.pyx":1005 * ''' * * with open('/proc/%d/status' % pid, 'r') as fh: # <<<<<<<<<<<<<< * for line in fh: * if line.startswith('Groups:'): */ } __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; goto __pyx_L12_try_end; __pyx_L7_error:; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; /*except:*/ { __Pyx_AddTraceback("pyfuse3.get_sup_groups", __pyx_clineno, __pyx_lineno, __pyx_filename); if (__Pyx_GetException(&__pyx_t_4, &__pyx_t_1, &__pyx_t_2) < 0) __PYX_ERR(3, 1005, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GOTREF(__pyx_t_1); __Pyx_GOTREF(__pyx_t_2); __pyx_t_5 = PyTuple_Pack(3, __pyx_t_4, __pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1005, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_12 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_t_5, NULL); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (unlikely(!__pyx_t_12)) __PYX_ERR(3, 1005, __pyx_L9_except_error) __Pyx_GOTREF(__pyx_t_12); __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_12); __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; if (__pyx_t_11 < 0) __PYX_ERR(3, 1005, __pyx_L9_except_error) __pyx_t_13 = ((!(__pyx_t_11 != 0)) != 0); if (__pyx_t_13) { __Pyx_GIVEREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_1); __Pyx_XGIVEREF(__pyx_t_2); __Pyx_ErrRestoreWithState(__pyx_t_4, __pyx_t_1, __pyx_t_2); __pyx_t_4 = 0; __pyx_t_1 = 0; __pyx_t_2 = 0; __PYX_ERR(3, 1005, __pyx_L9_except_error) } __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; goto __pyx_L8_exception_handled; } __pyx_L9_except_error:; __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); goto __pyx_L1_error; __pyx_L8_exception_handled:; __Pyx_XGIVEREF(__pyx_t_6); __Pyx_XGIVEREF(__pyx_t_7); __Pyx_XGIVEREF(__pyx_t_8); __Pyx_ExceptionReset(__pyx_t_6, __pyx_t_7, __pyx_t_8); __pyx_L12_try_end:; } } /*finally:*/ { /*normal exit:*/{ if (__pyx_t_3) { __pyx_t_8 = __Pyx_PyObject_Call(__pyx_t_3, __pyx_tuple__38, NULL); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(!__pyx_t_8)) __PYX_ERR(3, 1005, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; } goto __pyx_L6; } __pyx_L6:; } goto __pyx_L20; __pyx_L3_error:; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; goto __pyx_L1_error; __pyx_L20:; } /* "pyfuse3.pyx":1011 * else: * raise RuntimeError("Unable to parse %s" % fh.name) * gids = set() # <<<<<<<<<<<<<< * for x in line.split()[1:]: * gids.add(int(x)) */ __pyx_t_2 = PySet_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1011, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_v_gids = ((PyObject*)__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":1012 * raise RuntimeError("Unable to parse %s" % fh.name) * gids = set() * for x in line.split()[1:]: # <<<<<<<<<<<<<< * gids.add(int(x)) * */ if (unlikely(!__pyx_v_line)) { __Pyx_RaiseUnboundLocalError("line"); __PYX_ERR(3, 1012, __pyx_L1_error) } __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_line, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_1); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_1, function); } } __pyx_t_2 = (__pyx_t_4) ? __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_4) : __Pyx_PyObject_CallNoArg(__pyx_t_1); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_PyObject_GetSlice(__pyx_t_2, 1, 0, NULL, NULL, &__pyx_slice__60, 1, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { __pyx_t_2 = __pyx_t_1; __Pyx_INCREF(__pyx_t_2); __pyx_t_9 = 0; __pyx_t_10 = NULL; } else { __pyx_t_9 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_10 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_10)) __PYX_ERR(3, 1012, __pyx_L1_error) } __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; for (;;) { if (likely(!__pyx_t_10)) { if (likely(PyList_CheckExact(__pyx_t_2))) { if (__pyx_t_9 >= PyList_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(3, 1012, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } else { if (__pyx_t_9 >= PyTuple_GET_SIZE(__pyx_t_2)) break; #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS __pyx_t_1 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_9); __Pyx_INCREF(__pyx_t_1); __pyx_t_9++; if (unlikely(0 < 0)) __PYX_ERR(3, 1012, __pyx_L1_error) #else __pyx_t_1 = PySequence_ITEM(__pyx_t_2, __pyx_t_9); __pyx_t_9++; if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1012, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); #endif } } else { __pyx_t_1 = __pyx_t_10(__pyx_t_2); if (unlikely(!__pyx_t_1)) { PyObject* exc_type = PyErr_Occurred(); if (exc_type) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); else __PYX_ERR(3, 1012, __pyx_L1_error) } break; } __Pyx_GOTREF(__pyx_t_1); } __Pyx_XDECREF_SET(__pyx_v_x, __pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":1013 * gids = set() * for x in line.split()[1:]: * gids.add(int(x)) # <<<<<<<<<<<<<< * * return gids */ __pyx_t_1 = __Pyx_PyNumber_Int(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 1013, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_14 = PySet_Add(__pyx_v_gids, __pyx_t_1); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(3, 1013, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":1012 * raise RuntimeError("Unable to parse %s" % fh.name) * gids = set() * for x in line.split()[1:]: # <<<<<<<<<<<<<< * gids.add(int(x)) * */ } __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":1015 * gids.add(int(x)) * * return gids # <<<<<<<<<<<<<< * * */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v_gids); __pyx_r = __pyx_v_gids; goto __pyx_L0; /* "pyfuse3.pyx":995 * raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) * * def get_sup_groups(pid): # <<<<<<<<<<<<<< * '''Return supplementary group ids of *pid* * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyfuse3.get_sup_groups", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_fh); __Pyx_XDECREF(__pyx_v_line); __Pyx_XDECREF(__pyx_v_gids); __Pyx_XDECREF(__pyx_v_x); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "pyfuse3.pyx":1018 * * * def readdir_reply(ReaddirToken token, name, EntryAttributes attr, off_t next_id): # <<<<<<<<<<<<<< * '''Report a directory entry in response to a `~Operations.readdir` request. * */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_123readdir_reply(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_122readdir_reply[] = "readdir_reply(ReaddirToken token, name, EntryAttributes attr, off_t next_id)\nReport a directory entry in response to a `~Operations.readdir` request.\n\n This function should be called by the `~Operations.readdir` handler to\n provide the list of directory entries. The function should be called\n once for each directory entry, until it returns False.\n\n *token* must be the token received by the `~Operations.readdir` handler.\n\n *name* and must be the name of the directory entry and *attr* an\n `EntryAttributes` instance holding its attributes.\n\n *next_id* must be a 64-bit integer value that uniquely identifies the\n current position in the list of directory entries. It may be passed back\n to a later `~Operations.readdir` call to start another listing at the\n right position. This value should be robust in the presence of file\n removals and creations, i.e. if files are created or removed after a\n call to `~Operations.readdir` and `~Operations.readdir` is called again\n with *start_id* set to any previously supplied *next_id* values, under\n no circumstances must any file be reported twice or skipped over.\n "; static PyMethodDef __pyx_mdef_7pyfuse3_123readdir_reply = {"readdir_reply", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_123readdir_reply, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_122readdir_reply}; static PyObject *__pyx_pw_7pyfuse3_123readdir_reply(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_v_token = 0; PyObject *__pyx_v_name = 0; struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_attr = 0; off_t __pyx_v_next_id; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("readdir_reply (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_token,&__pyx_n_s_name,&__pyx_n_s_attr,&__pyx_n_s_next_id,0}; PyObject* values[4] = {0,0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); CYTHON_FALLTHROUGH; case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_token)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("readdir_reply", 1, 4, 4, 1); __PYX_ERR(3, 1018, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_attr)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("readdir_reply", 1, 4, 4, 2); __PYX_ERR(3, 1018, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_next_id)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("readdir_reply", 1, 4, 4, 3); __PYX_ERR(3, 1018, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "readdir_reply") < 0)) __PYX_ERR(3, 1018, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 4) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); values[3] = PyTuple_GET_ITEM(__pyx_args, 3); } __pyx_v_token = ((struct __pyx_obj_7pyfuse3_ReaddirToken *)values[0]); __pyx_v_name = values[1]; __pyx_v_attr = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)values[2]); __pyx_v_next_id = __Pyx_PyInt_As_off_t(values[3]); if (unlikely((__pyx_v_next_id == ((off_t)-1)) && PyErr_Occurred())) __PYX_ERR(3, 1018, __pyx_L3_error) } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("readdir_reply", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(3, 1018, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.readdir_reply", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_token), __pyx_ptype_7pyfuse3_ReaddirToken, 1, "token", 0))) __PYX_ERR(3, 1018, __pyx_L1_error) if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_attr), __pyx_ptype_7pyfuse3_EntryAttributes, 1, "attr", 0))) __PYX_ERR(3, 1018, __pyx_L1_error) __pyx_r = __pyx_pf_7pyfuse3_122readdir_reply(__pyx_self, __pyx_v_token, __pyx_v_name, __pyx_v_attr, __pyx_v_next_id); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_122readdir_reply(CYTHON_UNUSED PyObject *__pyx_self, struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_v_token, PyObject *__pyx_v_name, struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_v_attr, off_t __pyx_v_next_id) { char *__pyx_v_cname; PyObject *__pyx_v_len_ = NULL; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; void *__pyx_t_2; char *__pyx_t_3; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; size_t __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("readdir_reply", 0); /* "pyfuse3.pyx":1042 * cdef char *cname * * if token.buf_start == NULL: # <<<<<<<<<<<<<< * token.buf_start = calloc_or_raise(token.size, sizeof(char)) * token.buf = token.buf_start */ __pyx_t_1 = ((__pyx_v_token->buf_start == NULL) != 0); if (__pyx_t_1) { /* "pyfuse3.pyx":1043 * * if token.buf_start == NULL: * token.buf_start = calloc_or_raise(token.size, sizeof(char)) # <<<<<<<<<<<<<< * token.buf = token.buf_start * */ __pyx_t_2 = __pyx_f_7pyfuse3_calloc_or_raise(__pyx_v_token->size, (sizeof(char))); if (unlikely(__pyx_t_2 == ((void *)NULL))) __PYX_ERR(3, 1043, __pyx_L1_error) __pyx_v_token->buf_start = ((char *)__pyx_t_2); /* "pyfuse3.pyx":1044 * if token.buf_start == NULL: * token.buf_start = calloc_or_raise(token.size, sizeof(char)) * token.buf = token.buf_start # <<<<<<<<<<<<<< * * cname = PyBytes_AsString(name) */ __pyx_t_3 = __pyx_v_token->buf_start; __pyx_v_token->buf = __pyx_t_3; /* "pyfuse3.pyx":1042 * cdef char *cname * * if token.buf_start == NULL: # <<<<<<<<<<<<<< * token.buf_start = calloc_or_raise(token.size, sizeof(char)) * token.buf = token.buf_start */ } /* "pyfuse3.pyx":1046 * token.buf = token.buf_start * * cname = PyBytes_AsString(name) # <<<<<<<<<<<<<< * len_ = fuse_add_direntry_plus(token.req, token.buf, token.size, * cname, &attr.fuse_param, next_id) */ __pyx_t_3 = PyBytes_AsString(__pyx_v_name); if (unlikely(__pyx_t_3 == ((char *)NULL))) __PYX_ERR(3, 1046, __pyx_L1_error) __pyx_v_cname = __pyx_t_3; /* "pyfuse3.pyx":1047 * * cname = PyBytes_AsString(name) * len_ = fuse_add_direntry_plus(token.req, token.buf, token.size, # <<<<<<<<<<<<<< * cname, &attr.fuse_param, next_id) * if len_ > token.size: */ __pyx_t_4 = __Pyx_PyInt_FromSize_t(fuse_add_direntry_plus(__pyx_v_token->req, __pyx_v_token->buf, __pyx_v_token->size, __pyx_v_cname, (&__pyx_v_attr->fuse_param), __pyx_v_next_id)); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1047, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_v_len_ = __pyx_t_4; __pyx_t_4 = 0; /* "pyfuse3.pyx":1049 * len_ = fuse_add_direntry_plus(token.req, token.buf, token.size, * cname, &attr.fuse_param, next_id) * if len_ > token.size: # <<<<<<<<<<<<<< * return False * */ __pyx_t_4 = __Pyx_PyInt_FromSize_t(__pyx_v_token->size); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1049, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __pyx_t_5 = PyObject_RichCompare(__pyx_v_len_, __pyx_t_4, Py_GT); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1049, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(3, 1049, __pyx_L1_error) __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; if (__pyx_t_1) { /* "pyfuse3.pyx":1050 * cname, &attr.fuse_param, next_id) * if len_ > token.size: * return False # <<<<<<<<<<<<<< * * token.size -= len_ */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_False); __pyx_r = Py_False; goto __pyx_L0; /* "pyfuse3.pyx":1049 * len_ = fuse_add_direntry_plus(token.req, token.buf, token.size, * cname, &attr.fuse_param, next_id) * if len_ > token.size: # <<<<<<<<<<<<<< * return False * */ } /* "pyfuse3.pyx":1052 * return False * * token.size -= len_ # <<<<<<<<<<<<<< * token.buf = &token.buf[len_] * return True */ __pyx_t_5 = __Pyx_PyInt_FromSize_t(__pyx_v_token->size); if (unlikely(!__pyx_t_5)) __PYX_ERR(3, 1052, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_5); __pyx_t_4 = PyNumber_InPlaceSubtract(__pyx_t_5, __pyx_v_len_); if (unlikely(!__pyx_t_4)) __PYX_ERR(3, 1052, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_6 = __Pyx_PyInt_As_size_t(__pyx_t_4); if (unlikely((__pyx_t_6 == (size_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 1052, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __pyx_v_token->size = __pyx_t_6; /* "pyfuse3.pyx":1053 * * token.size -= len_ * token.buf = &token.buf[len_] # <<<<<<<<<<<<<< * return True */ __pyx_t_7 = __Pyx_PyIndex_AsSsize_t(__pyx_v_len_); if (unlikely((__pyx_t_7 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(3, 1053, __pyx_L1_error) __pyx_v_token->buf = (&(__pyx_v_token->buf[__pyx_t_7])); /* "pyfuse3.pyx":1054 * token.size -= len_ * token.buf = &token.buf[len_] * return True # <<<<<<<<<<<<<< */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(Py_True); __pyx_r = Py_True; goto __pyx_L0; /* "pyfuse3.pyx":1018 * * * def readdir_reply(ReaddirToken token, name, EntryAttributes attr, off_t next_id): # <<<<<<<<<<<<<< * '''Report a directory entry in response to a `~Operations.readdir` request. * */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyfuse3.readdir_reply", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v_len_); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle__WorkerData(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_125__pyx_unpickle__WorkerData(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_124__pyx_unpickle__WorkerData[] = "__pyx_unpickle__WorkerData(__pyx_type, long __pyx_checksum, __pyx_state)"; static PyMethodDef __pyx_mdef_7pyfuse3_125__pyx_unpickle__WorkerData = {"__pyx_unpickle__WorkerData", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_125__pyx_unpickle__WorkerData, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_124__pyx_unpickle__WorkerData}; static PyObject *__pyx_pw_7pyfuse3_125__pyx_unpickle__WorkerData(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle__WorkerData (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__WorkerData", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__WorkerData", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle__WorkerData") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle__WorkerData", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.__pyx_unpickle__WorkerData", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_124__pyx_unpickle__WorkerData(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_124__pyx_unpickle__WorkerData(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle__WorkerData", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum != 0xe8d9c4e: # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0xe8d9c4e = (active_readers, read_lock, task_count, task_serial))" % __pyx_checksum) */ __pyx_t_1 = ((__pyx_v___pyx_checksum != 0xe8d9c4e) != 0); if (__pyx_t_1) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum != 0xe8d9c4e: * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (%s vs 0xe8d9c4e = (active_readers, read_lock, task_count, task_serial))" % __pyx_checksum) * __pyx_result = _WorkerData.__new__(__pyx_type) */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_2); __pyx_v___pyx_PickleError = __pyx_t_2; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * if __pyx_checksum != 0xe8d9c4e: * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0xe8d9c4e = (active_readers, read_lock, task_count, task_serial))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = _WorkerData.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0xe8, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum != 0xe8d9c4e: # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0xe8d9c4e = (active_readers, read_lock, task_count, task_serial))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0xe8d9c4e = (active_readers, read_lock, task_count, task_serial))" % __pyx_checksum) * __pyx_result = _WorkerData.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle__WorkerData__set_state(<_WorkerData> __pyx_result, __pyx_state) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7pyfuse3__WorkerData), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v___pyx_result = __pyx_t_3; __pyx_t_3 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (%s vs 0xe8d9c4e = (active_readers, read_lock, task_count, task_serial))" % __pyx_checksum) * __pyx_result = _WorkerData.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle__WorkerData__set_state(<_WorkerData> __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_1 = (__pyx_v___pyx_state != Py_None); __pyx_t_6 = (__pyx_t_1 != 0); if (__pyx_t_6) { /* "(tree fragment)":9 * __pyx_result = _WorkerData.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle__WorkerData__set_state(<_WorkerData> __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle__WorkerData__set_state(_WorkerData __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(0, 9, __pyx_L1_error) __pyx_t_3 = __pyx_f_7pyfuse3___pyx_unpickle__WorkerData__set_state(((struct __pyx_obj_7pyfuse3__WorkerData *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (%s vs 0xe8d9c4e = (active_readers, read_lock, task_count, task_serial))" % __pyx_checksum) * __pyx_result = _WorkerData.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle__WorkerData__set_state(<_WorkerData> __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle__WorkerData__set_state(<_WorkerData> __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle__WorkerData__set_state(_WorkerData __pyx_result, tuple __pyx_state): * __pyx_result.active_readers = __pyx_state[0]; __pyx_result.read_lock = __pyx_state[1]; __pyx_result.task_count = __pyx_state[2]; __pyx_result.task_serial = __pyx_state[3] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle__WorkerData(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyfuse3.__pyx_unpickle__WorkerData", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle__WorkerData__set_state(<_WorkerData> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle__WorkerData__set_state(_WorkerData __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.active_readers = __pyx_state[0]; __pyx_result.read_lock = __pyx_state[1]; __pyx_result.task_count = __pyx_state[2]; __pyx_result.task_serial = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_7pyfuse3___pyx_unpickle__WorkerData__set_state(struct __pyx_obj_7pyfuse3__WorkerData *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; int __pyx_t_3; Py_ssize_t __pyx_t_4; int __pyx_t_5; int __pyx_t_6; PyObject *__pyx_t_7 = NULL; PyObject *__pyx_t_8 = NULL; PyObject *__pyx_t_9 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle__WorkerData__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle__WorkerData__set_state(_WorkerData __pyx_result, tuple __pyx_state): * __pyx_result.active_readers = __pyx_state[0]; __pyx_result.read_lock = __pyx_state[1]; __pyx_result.task_count = __pyx_state[2]; __pyx_result.task_serial = __pyx_state[3] # <<<<<<<<<<<<<< * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[4]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->active_readers = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_1); __Pyx_GOTREF(__pyx_v___pyx_result->read_lock); __Pyx_DECREF(__pyx_v___pyx_result->read_lock); __pyx_v___pyx_result->read_lock = __pyx_t_1; __pyx_t_1 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->task_count = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->task_serial = __pyx_t_2; /* "(tree fragment)":13 * cdef __pyx_unpickle__WorkerData__set_state(_WorkerData __pyx_result, tuple __pyx_state): * __pyx_result.active_readers = __pyx_state[0]; __pyx_result.read_lock = __pyx_state[1]; __pyx_result.task_count = __pyx_state[2]; __pyx_result.task_serial = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[4]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 13, __pyx_L1_error) } __pyx_t_4 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 13, __pyx_L1_error) __pyx_t_5 = ((__pyx_t_4 > 4) != 0); if (__pyx_t_5) { } else { __pyx_t_3 = __pyx_t_5; goto __pyx_L4_bool_binop_done; } __pyx_t_5 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 13, __pyx_L1_error) __pyx_t_6 = (__pyx_t_5 != 0); __pyx_t_3 = __pyx_t_6; __pyx_L4_bool_binop_done:; if (__pyx_t_3) { /* "(tree fragment)":14 * __pyx_result.active_readers = __pyx_state[0]; __pyx_result.read_lock = __pyx_state[1]; __pyx_result.task_count = __pyx_state[2]; __pyx_result.task_serial = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[4]) # <<<<<<<<<<<<<< */ __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_n_s_update); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 14, __pyx_L1_error) } __pyx_t_7 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_7); __pyx_t_9 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_8); if (likely(__pyx_t_9)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); __Pyx_INCREF(__pyx_t_9); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_8, function); } } __pyx_t_1 = (__pyx_t_9) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_9, __pyx_t_7) : __Pyx_PyObject_CallOneArg(__pyx_t_8, __pyx_t_7); __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle__WorkerData__set_state(_WorkerData __pyx_result, tuple __pyx_state): * __pyx_result.active_readers = __pyx_state[0]; __pyx_result.read_lock = __pyx_state[1]; __pyx_result.task_count = __pyx_state[2]; __pyx_result.task_serial = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[4]) */ } /* "(tree fragment)":11 * __pyx_unpickle__WorkerData__set_state(<_WorkerData> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle__WorkerData__set_state(_WorkerData __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.active_readers = __pyx_state[0]; __pyx_result.read_lock = __pyx_state[1]; __pyx_result.task_count = __pyx_state[2]; __pyx_result.task_serial = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_7); __Pyx_XDECREF(__pyx_t_8); __Pyx_XDECREF(__pyx_t_9); __Pyx_AddTraceback("pyfuse3.__pyx_unpickle__WorkerData__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":1 * def __pyx_unpickle_RequestContext(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* Python wrapper */ static PyObject *__pyx_pw_7pyfuse3_127__pyx_unpickle_RequestContext(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static char __pyx_doc_7pyfuse3_126__pyx_unpickle_RequestContext[] = "__pyx_unpickle_RequestContext(__pyx_type, long __pyx_checksum, __pyx_state)"; static PyMethodDef __pyx_mdef_7pyfuse3_127__pyx_unpickle_RequestContext = {"__pyx_unpickle_RequestContext", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_7pyfuse3_127__pyx_unpickle_RequestContext, METH_VARARGS|METH_KEYWORDS, __pyx_doc_7pyfuse3_126__pyx_unpickle_RequestContext}; static PyObject *__pyx_pw_7pyfuse3_127__pyx_unpickle_RequestContext(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle_RequestContext (wrapper)", 0); { static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; PyObject* values[3] = {0,0,0}; if (unlikely(__pyx_kwds)) { Py_ssize_t kw_args; const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); switch (pos_args) { case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); CYTHON_FALLTHROUGH; case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); CYTHON_FALLTHROUGH; case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } kw_args = PyDict_Size(__pyx_kwds); switch (pos_args) { case 0: if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_RequestContext", 1, 3, 3, 1); __PYX_ERR(0, 1, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_RequestContext", 1, 3, 3, 2); __PYX_ERR(0, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_RequestContext") < 0)) __PYX_ERR(0, 1, __pyx_L3_error) } } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { goto __pyx_L5_argtuple_error; } else { values[0] = PyTuple_GET_ITEM(__pyx_args, 0); values[1] = PyTuple_GET_ITEM(__pyx_args, 1); values[2] = PyTuple_GET_ITEM(__pyx_args, 2); } __pyx_v___pyx_type = values[0]; __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } goto __pyx_L4_argument_unpacking_done; __pyx_L5_argtuple_error:; __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_RequestContext", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1, __pyx_L3_error) __pyx_L3_error:; __Pyx_AddTraceback("pyfuse3.__pyx_unpickle_RequestContext", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; __pyx_r = __pyx_pf_7pyfuse3_126__pyx_unpickle_RequestContext(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } static PyObject *__pyx_pf_7pyfuse3_126__pyx_unpickle_RequestContext(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_v___pyx_PickleError = 0; PyObject *__pyx_v___pyx_result = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations int __pyx_t_1; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; PyObject *__pyx_t_5 = NULL; int __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_RequestContext", 0); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum != 0x223b7a8: # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x223b7a8 = (gid, pid, uid, umask))" % __pyx_checksum) */ __pyx_t_1 = ((__pyx_v___pyx_checksum != 0x223b7a8) != 0); if (__pyx_t_1) { /* "(tree fragment)":5 * cdef object __pyx_result * if __pyx_checksum != 0x223b7a8: * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< * raise __pyx_PickleError("Incompatible checksums (%s vs 0x223b7a8 = (gid, pid, uid, umask))" % __pyx_checksum) * __pyx_result = RequestContext.__new__(__pyx_type) */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_PickleError); __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_2, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_t_2); __pyx_v___pyx_PickleError = __pyx_t_2; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 * if __pyx_checksum != 0x223b7a8: * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x223b7a8 = (gid, pid, uid, umask))" % __pyx_checksum) # <<<<<<<<<<<<<< * __pyx_result = RequestContext.__new__(__pyx_type) * if __pyx_state is not None: */ __pyx_t_2 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_s_vs_0x22, __pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_INCREF(__pyx_v___pyx_PickleError); __pyx_t_2 = __pyx_v___pyx_PickleError; __pyx_t_5 = NULL; if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_5)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_5); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_5, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_Raise(__pyx_t_3, 0, 0, 0); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __PYX_ERR(0, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result * if __pyx_checksum != 0x223b7a8: # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x223b7a8 = (gid, pid, uid, umask))" % __pyx_checksum) */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError * raise __pyx_PickleError("Incompatible checksums (%s vs 0x223b7a8 = (gid, pid, uid, umask))" % __pyx_checksum) * __pyx_result = RequestContext.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle_RequestContext__set_state( __pyx_result, __pyx_state) */ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_7pyfuse3_RequestContext), __pyx_n_s_new); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_4 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); if (likely(__pyx_t_4)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_2); __Pyx_INCREF(__pyx_t_4); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_2, function); } } __pyx_t_3 = (__pyx_t_4) ? __Pyx_PyObject_Call2Args(__pyx_t_2, __pyx_t_4, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_v___pyx_type); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 7, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v___pyx_result = __pyx_t_3; __pyx_t_3 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (%s vs 0x223b7a8 = (gid, pid, uid, umask))" % __pyx_checksum) * __pyx_result = RequestContext.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_RequestContext__set_state( __pyx_result, __pyx_state) * return __pyx_result */ __pyx_t_1 = (__pyx_v___pyx_state != Py_None); __pyx_t_6 = (__pyx_t_1 != 0); if (__pyx_t_6) { /* "(tree fragment)":9 * __pyx_result = RequestContext.__new__(__pyx_type) * if __pyx_state is not None: * __pyx_unpickle_RequestContext__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< * return __pyx_result * cdef __pyx_unpickle_RequestContext__set_state(RequestContext __pyx_result, tuple __pyx_state): */ if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||(PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(0, 9, __pyx_L1_error) __pyx_t_3 = __pyx_f_7pyfuse3___pyx_unpickle_RequestContext__set_state(((struct __pyx_obj_7pyfuse3_RequestContext *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":8 * raise __pyx_PickleError("Incompatible checksums (%s vs 0x223b7a8 = (gid, pid, uid, umask))" % __pyx_checksum) * __pyx_result = RequestContext.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle_RequestContext__set_state( __pyx_result, __pyx_state) * return __pyx_result */ } /* "(tree fragment)":10 * if __pyx_state is not None: * __pyx_unpickle_RequestContext__set_state( __pyx_result, __pyx_state) * return __pyx_result # <<<<<<<<<<<<<< * cdef __pyx_unpickle_RequestContext__set_state(RequestContext __pyx_result, tuple __pyx_state): * __pyx_result.gid = __pyx_state[0]; __pyx_result.pid = __pyx_state[1]; __pyx_result.uid = __pyx_state[2]; __pyx_result.umask = __pyx_state[3] */ __Pyx_XDECREF(__pyx_r); __Pyx_INCREF(__pyx_v___pyx_result); __pyx_r = __pyx_v___pyx_result; goto __pyx_L0; /* "(tree fragment)":1 * def __pyx_unpickle_RequestContext(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); __Pyx_XDECREF(__pyx_t_5); __Pyx_AddTraceback("pyfuse3.__pyx_unpickle_RequestContext", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF(__pyx_v___pyx_PickleError); __Pyx_XDECREF(__pyx_v___pyx_result); __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } /* "(tree fragment)":11 * __pyx_unpickle_RequestContext__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_RequestContext__set_state(RequestContext __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.gid = __pyx_state[0]; __pyx_result.pid = __pyx_state[1]; __pyx_result.uid = __pyx_state[2]; __pyx_result.umask = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ static PyObject *__pyx_f_7pyfuse3___pyx_unpickle_RequestContext__set_state(struct __pyx_obj_7pyfuse3_RequestContext *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; gid_t __pyx_t_2; pid_t __pyx_t_3; uid_t __pyx_t_4; mode_t __pyx_t_5; int __pyx_t_6; Py_ssize_t __pyx_t_7; int __pyx_t_8; int __pyx_t_9; PyObject *__pyx_t_10 = NULL; PyObject *__pyx_t_11 = NULL; PyObject *__pyx_t_12 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__pyx_unpickle_RequestContext__set_state", 0); /* "(tree fragment)":12 * return __pyx_result * cdef __pyx_unpickle_RequestContext__set_state(RequestContext __pyx_result, tuple __pyx_state): * __pyx_result.gid = __pyx_state[0]; __pyx_result.pid = __pyx_state[1]; __pyx_result.uid = __pyx_state[2]; __pyx_result.umask = __pyx_state[3] # <<<<<<<<<<<<<< * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[4]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_2 = __Pyx_PyInt_As_gid_t(__pyx_t_1); if (unlikely((__pyx_t_2 == ((gid_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->gid = __pyx_t_2; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_3 = __Pyx_PyInt_As_pid_t(__pyx_t_1); if (unlikely((__pyx_t_3 == ((pid_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->pid = __pyx_t_3; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_4 = __Pyx_PyInt_As_uid_t(__pyx_t_1); if (unlikely((__pyx_t_4 == ((uid_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->uid = __pyx_t_4; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 12, __pyx_L1_error) } __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_t_5 = __Pyx_PyInt_As_mode_t(__pyx_t_1); if (unlikely((__pyx_t_5 == ((mode_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 12, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_v___pyx_result->umask = __pyx_t_5; /* "(tree fragment)":13 * cdef __pyx_unpickle_RequestContext__set_state(RequestContext __pyx_result, tuple __pyx_state): * __pyx_result.gid = __pyx_state[0]; __pyx_result.pid = __pyx_state[1]; __pyx_result.uid = __pyx_state[2]; __pyx_result.umask = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[4]) */ if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(0, 13, __pyx_L1_error) } __pyx_t_7 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 13, __pyx_L1_error) __pyx_t_8 = ((__pyx_t_7 > 4) != 0); if (__pyx_t_8) { } else { __pyx_t_6 = __pyx_t_8; goto __pyx_L4_bool_binop_done; } __pyx_t_8 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 13, __pyx_L1_error) __pyx_t_9 = (__pyx_t_8 != 0); __pyx_t_6 = __pyx_t_9; __pyx_L4_bool_binop_done:; if (__pyx_t_6) { /* "(tree fragment)":14 * __pyx_result.gid = __pyx_state[0]; __pyx_result.pid = __pyx_state[1]; __pyx_result.uid = __pyx_state[2]; __pyx_result.umask = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[4]) # <<<<<<<<<<<<<< */ __pyx_t_10 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_update); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_11); __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(0, 14, __pyx_L1_error) } __pyx_t_10 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_10); __pyx_t_12 = NULL; if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_11))) { __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_11); if (likely(__pyx_t_12)) { PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_11); __Pyx_INCREF(__pyx_t_12); __Pyx_INCREF(function); __Pyx_DECREF_SET(__pyx_t_11, function); } } __pyx_t_1 = (__pyx_t_12) ? __Pyx_PyObject_Call2Args(__pyx_t_11, __pyx_t_12, __pyx_t_10) : __Pyx_PyObject_CallOneArg(__pyx_t_11, __pyx_t_10); __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 14, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle_RequestContext__set_state(RequestContext __pyx_result, tuple __pyx_state): * __pyx_result.gid = __pyx_state[0]; __pyx_result.pid = __pyx_state[1]; __pyx_result.uid = __pyx_state[2]; __pyx_result.umask = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< * __pyx_result.__dict__.update(__pyx_state[4]) */ } /* "(tree fragment)":11 * __pyx_unpickle_RequestContext__set_state( __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle_RequestContext__set_state(RequestContext __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.gid = __pyx_state[0]; __pyx_result.pid = __pyx_state[1]; __pyx_result.uid = __pyx_state[2]; __pyx_result.umask = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ /* function exit code */ __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_10); __Pyx_XDECREF(__pyx_t_11); __Pyx_XDECREF(__pyx_t_12); __Pyx_AddTraceback("pyfuse3.__pyx_unpickle_RequestContext__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); __Pyx_RefNannyFinishContext(); return __pyx_r; } static struct __pyx_obj_7pyfuse3__Container *__pyx_freelist_7pyfuse3__Container[60]; static int __pyx_freecount_7pyfuse3__Container = 0; static PyObject *__pyx_tp_new_7pyfuse3__Container(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3__Container > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3__Container)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { o = (PyObject*)__pyx_freelist_7pyfuse3__Container[--__pyx_freecount_7pyfuse3__Container]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3__Container)); (void) PyObject_INIT(o, t); } else { if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3__Container(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3__Container < 60) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3__Container)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { __pyx_freelist_7pyfuse3__Container[__pyx_freecount_7pyfuse3__Container++] = ((struct __pyx_obj_7pyfuse3__Container *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static PyMethodDef __pyx_methods_7pyfuse3__Container[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_10_Container_1__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_10_Container___reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_10_Container_3__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_10_Container_2__setstate_cython__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3__Container = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3._Container", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3__Container), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3__Container, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "For internal use by pyfuse3 only.", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3__Container, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3__Container, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3_ReaddirToken *__pyx_freelist_7pyfuse3_ReaddirToken[10]; static int __pyx_freecount_7pyfuse3_ReaddirToken = 0; static PyObject *__pyx_tp_new_7pyfuse3_ReaddirToken(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3_ReaddirToken > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_ReaddirToken)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { o = (PyObject*)__pyx_freelist_7pyfuse3_ReaddirToken[--__pyx_freecount_7pyfuse3_ReaddirToken]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3_ReaddirToken)); (void) PyObject_INIT(o, t); } else { if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3_ReaddirToken(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3_ReaddirToken < 10) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_ReaddirToken)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { __pyx_freelist_7pyfuse3_ReaddirToken[__pyx_freecount_7pyfuse3_ReaddirToken++] = ((struct __pyx_obj_7pyfuse3_ReaddirToken *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static PyMethodDef __pyx_methods_7pyfuse3_ReaddirToken[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_12ReaddirToken_1__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_12ReaddirToken___reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_12ReaddirToken_3__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_12ReaddirToken_2__setstate_cython__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3_ReaddirToken = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.ReaddirToken", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3_ReaddirToken), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3_ReaddirToken, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ 0, /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3_ReaddirToken, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3_ReaddirToken, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_7pyfuse3__WorkerData __pyx_vtable_7pyfuse3__WorkerData; static PyObject *__pyx_tp_new_7pyfuse3__WorkerData(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_7pyfuse3__WorkerData *p; PyObject *o; if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; p = ((struct __pyx_obj_7pyfuse3__WorkerData *)o); p->__pyx_vtab = __pyx_vtabptr_7pyfuse3__WorkerData; p->read_lock = Py_None; Py_INCREF(Py_None); return o; } static void __pyx_tp_dealloc_7pyfuse3__WorkerData(PyObject *o) { struct __pyx_obj_7pyfuse3__WorkerData *p = (struct __pyx_obj_7pyfuse3__WorkerData *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->read_lock); (*Py_TYPE(o)->tp_free)(o); } static int __pyx_tp_traverse_7pyfuse3__WorkerData(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3__WorkerData *p = (struct __pyx_obj_7pyfuse3__WorkerData *)o; if (p->read_lock) { e = (*v)(p->read_lock, a); if (e) return e; } return 0; } static int __pyx_tp_clear_7pyfuse3__WorkerData(PyObject *o) { PyObject* tmp; struct __pyx_obj_7pyfuse3__WorkerData *p = (struct __pyx_obj_7pyfuse3__WorkerData *)o; tmp = ((PyObject*)p->read_lock); p->read_lock = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyMethodDef __pyx_methods_7pyfuse3__WorkerData[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_11_WorkerData_3__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_11_WorkerData_2__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_11_WorkerData_5__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_11_WorkerData_4__setstate_cython__}, {0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3__WorkerData = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3._WorkerData", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3__WorkerData), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3__WorkerData, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "_WorkerData()\nFor internal use by pyfuse3 only.", /*tp_doc*/ __pyx_tp_traverse_7pyfuse3__WorkerData, /*tp_traverse*/ __pyx_tp_clear_7pyfuse3__WorkerData, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3__WorkerData, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ __pyx_pw_7pyfuse3_11_WorkerData_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3__WorkerData, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3_RequestContext *__pyx_freelist_7pyfuse3_RequestContext[10]; static int __pyx_freecount_7pyfuse3_RequestContext = 0; static PyObject *__pyx_tp_new_7pyfuse3_RequestContext(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3_RequestContext > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_RequestContext)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { o = (PyObject*)__pyx_freelist_7pyfuse3_RequestContext[--__pyx_freecount_7pyfuse3_RequestContext]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3_RequestContext)); (void) PyObject_INIT(o, t); } else { if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3_RequestContext(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3_RequestContext < 10) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_RequestContext)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { __pyx_freelist_7pyfuse3_RequestContext[__pyx_freecount_7pyfuse3_RequestContext++] = ((struct __pyx_obj_7pyfuse3_RequestContext *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static PyObject *__pyx_getprop_7pyfuse3_14RequestContext_uid(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_14RequestContext_3uid_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_14RequestContext_pid(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_14RequestContext_3pid_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_14RequestContext_gid(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_14RequestContext_3gid_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_14RequestContext_umask(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_14RequestContext_5umask_1__get__(o); } static PyMethodDef __pyx_methods_7pyfuse3_RequestContext[] = { {"__getstate__", (PyCFunction)__pyx_pw_7pyfuse3_14RequestContext_1__getstate__, METH_NOARGS, __pyx_doc_7pyfuse3_14RequestContext___getstate__}, {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_14RequestContext_3__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_14RequestContext_2__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_14RequestContext_5__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_14RequestContext_4__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_7pyfuse3_RequestContext[] = { {(char *)"uid", __pyx_getprop_7pyfuse3_14RequestContext_uid, 0, (char *)0, 0}, {(char *)"pid", __pyx_getprop_7pyfuse3_14RequestContext_pid, 0, (char *)0, 0}, {(char *)"gid", __pyx_getprop_7pyfuse3_14RequestContext_gid, 0, (char *)0, 0}, {(char *)"umask", __pyx_getprop_7pyfuse3_14RequestContext_umask, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3_RequestContext = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.RequestContext", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3_RequestContext), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3_RequestContext, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "\n Instances of this class are passed to some `Operations` methods to\n provide information about the caller of the syscall that initiated\n the request.\n ", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3_RequestContext, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_7pyfuse3_RequestContext, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3_RequestContext, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3_SetattrFields *__pyx_freelist_7pyfuse3_SetattrFields[10]; static int __pyx_freecount_7pyfuse3_SetattrFields = 0; static PyObject *__pyx_tp_new_7pyfuse3_SetattrFields(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_7pyfuse3_SetattrFields *p; PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3_SetattrFields > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_SetattrFields)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { o = (PyObject*)__pyx_freelist_7pyfuse3_SetattrFields[--__pyx_freecount_7pyfuse3_SetattrFields]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3_SetattrFields)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; } p = ((struct __pyx_obj_7pyfuse3_SetattrFields *)o); p->update_atime = Py_None; Py_INCREF(Py_None); p->update_mtime = Py_None; Py_INCREF(Py_None); p->update_ctime = Py_None; Py_INCREF(Py_None); p->update_mode = Py_None; Py_INCREF(Py_None); p->update_uid = Py_None; Py_INCREF(Py_None); p->update_gid = Py_None; Py_INCREF(Py_None); p->update_size = Py_None; Py_INCREF(Py_None); if (unlikely(__pyx_pw_7pyfuse3_13SetattrFields_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_7pyfuse3_SetattrFields(PyObject *o) { struct __pyx_obj_7pyfuse3_SetattrFields *p = (struct __pyx_obj_7pyfuse3_SetattrFields *)o; #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); Py_CLEAR(p->update_atime); Py_CLEAR(p->update_mtime); Py_CLEAR(p->update_ctime); Py_CLEAR(p->update_mode); Py_CLEAR(p->update_uid); Py_CLEAR(p->update_gid); Py_CLEAR(p->update_size); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3_SetattrFields < 10) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_SetattrFields)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { __pyx_freelist_7pyfuse3_SetattrFields[__pyx_freecount_7pyfuse3_SetattrFields++] = ((struct __pyx_obj_7pyfuse3_SetattrFields *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3_SetattrFields(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3_SetattrFields *p = (struct __pyx_obj_7pyfuse3_SetattrFields *)o; if (p->update_atime) { e = (*v)(p->update_atime, a); if (e) return e; } if (p->update_mtime) { e = (*v)(p->update_mtime, a); if (e) return e; } if (p->update_ctime) { e = (*v)(p->update_ctime, a); if (e) return e; } if (p->update_mode) { e = (*v)(p->update_mode, a); if (e) return e; } if (p->update_uid) { e = (*v)(p->update_uid, a); if (e) return e; } if (p->update_gid) { e = (*v)(p->update_gid, a); if (e) return e; } if (p->update_size) { e = (*v)(p->update_size, a); if (e) return e; } return 0; } static int __pyx_tp_clear_7pyfuse3_SetattrFields(PyObject *o) { PyObject* tmp; struct __pyx_obj_7pyfuse3_SetattrFields *p = (struct __pyx_obj_7pyfuse3_SetattrFields *)o; tmp = ((PyObject*)p->update_atime); p->update_atime = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->update_mtime); p->update_mtime = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->update_ctime); p->update_ctime = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->update_mode); p->update_mode = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->update_uid); p->update_uid = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->update_gid); p->update_gid = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); tmp = ((PyObject*)p->update_size); p->update_size = Py_None; Py_INCREF(Py_None); Py_XDECREF(tmp); return 0; } static PyObject *__pyx_getprop_7pyfuse3_13SetattrFields_update_atime(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_13SetattrFields_12update_atime_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_13SetattrFields_update_mtime(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_13SetattrFields_12update_mtime_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_13SetattrFields_update_ctime(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_13SetattrFields_12update_ctime_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_13SetattrFields_update_mode(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_13SetattrFields_11update_mode_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_13SetattrFields_update_uid(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_13SetattrFields_10update_uid_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_13SetattrFields_update_gid(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_13SetattrFields_10update_gid_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_13SetattrFields_update_size(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_13SetattrFields_11update_size_1__get__(o); } static PyMethodDef __pyx_methods_7pyfuse3_SetattrFields[] = { {"__getstate__", (PyCFunction)__pyx_pw_7pyfuse3_13SetattrFields_3__getstate__, METH_NOARGS, __pyx_doc_7pyfuse3_13SetattrFields_2__getstate__}, {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_13SetattrFields_5__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_13SetattrFields_4__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_13SetattrFields_7__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_13SetattrFields_6__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_7pyfuse3_SetattrFields[] = { {(char *)"update_atime", __pyx_getprop_7pyfuse3_13SetattrFields_update_atime, 0, (char *)0, 0}, {(char *)"update_mtime", __pyx_getprop_7pyfuse3_13SetattrFields_update_mtime, 0, (char *)0, 0}, {(char *)"update_ctime", __pyx_getprop_7pyfuse3_13SetattrFields_update_ctime, 0, (char *)0, 0}, {(char *)"update_mode", __pyx_getprop_7pyfuse3_13SetattrFields_update_mode, 0, (char *)0, 0}, {(char *)"update_uid", __pyx_getprop_7pyfuse3_13SetattrFields_update_uid, 0, (char *)0, 0}, {(char *)"update_gid", __pyx_getprop_7pyfuse3_13SetattrFields_update_gid, 0, (char *)0, 0}, {(char *)"update_size", __pyx_getprop_7pyfuse3_13SetattrFields_update_size, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3_SetattrFields = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.SetattrFields", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3_SetattrFields), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3_SetattrFields, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "\n `SetattrFields` instances are passed to the `~Operations.setattr` handler\n to specify which attributes should be updated.\n ", /*tp_doc*/ __pyx_tp_traverse_7pyfuse3_SetattrFields, /*tp_traverse*/ __pyx_tp_clear_7pyfuse3_SetattrFields, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3_SetattrFields, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_7pyfuse3_SetattrFields, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3_SetattrFields, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3_EntryAttributes *__pyx_freelist_7pyfuse3_EntryAttributes[30]; static int __pyx_freecount_7pyfuse3_EntryAttributes = 0; static PyObject *__pyx_tp_new_7pyfuse3_EntryAttributes(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3_EntryAttributes > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_EntryAttributes)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { o = (PyObject*)__pyx_freelist_7pyfuse3_EntryAttributes[--__pyx_freecount_7pyfuse3_EntryAttributes]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3_EntryAttributes)); (void) PyObject_INIT(o, t); } else { if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; } if (unlikely(__pyx_pw_7pyfuse3_15EntryAttributes_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_7pyfuse3_EntryAttributes(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3_EntryAttributes < 30) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_EntryAttributes)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { __pyx_freelist_7pyfuse3_EntryAttributes[__pyx_freecount_7pyfuse3_EntryAttributes++] = ((struct __pyx_obj_7pyfuse3_EntryAttributes *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_ino(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_6st_ino_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_ino(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_6st_ino_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_generation(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_10generation_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_generation(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_10generation_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_attr_timeout(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_12attr_timeout_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_attr_timeout(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_12attr_timeout_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_entry_timeout(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_13entry_timeout_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_entry_timeout(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_13entry_timeout_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_mode(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_7st_mode_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_mode(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_7st_mode_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_nlink(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_8st_nlink_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_nlink(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_8st_nlink_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_uid(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_6st_uid_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_uid(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_6st_uid_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_gid(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_6st_gid_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_gid(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_6st_gid_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_rdev(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_7st_rdev_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_rdev(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_7st_rdev_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_size(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_7st_size_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_size(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_7st_size_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_blocks(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_9st_blocks_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_blocks(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_9st_blocks_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_blksize(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_10st_blksize_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_blksize(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_10st_blksize_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_atime_ns(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_11st_atime_ns_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_atime_ns(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_11st_atime_ns_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_mtime_ns(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_11st_mtime_ns_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_mtime_ns(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_11st_mtime_ns_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_ctime_ns(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_11st_ctime_ns_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_ctime_ns(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_11st_ctime_ns_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_15EntryAttributes_st_birthtime_ns(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_15EntryAttributes_15st_birthtime_ns_1__get__(o); } static int __pyx_setprop_7pyfuse3_15EntryAttributes_st_birthtime_ns(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_15EntryAttributes_15st_birthtime_ns_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyMethodDef __pyx_methods_7pyfuse3_EntryAttributes[] = { {"__getstate__", (PyCFunction)__pyx_pw_7pyfuse3_15EntryAttributes_3__getstate__, METH_NOARGS, __pyx_doc_7pyfuse3_15EntryAttributes_2__getstate__}, {"__setstate__", (PyCFunction)__pyx_pw_7pyfuse3_15EntryAttributes_5__setstate__, METH_O, __pyx_doc_7pyfuse3_15EntryAttributes_4__setstate__}, {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_15EntryAttributes_7__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_15EntryAttributes_6__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_15EntryAttributes_9__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_15EntryAttributes_8__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_7pyfuse3_EntryAttributes[] = { {(char *)"st_ino", __pyx_getprop_7pyfuse3_15EntryAttributes_st_ino, __pyx_setprop_7pyfuse3_15EntryAttributes_st_ino, (char *)0, 0}, {(char *)"generation", __pyx_getprop_7pyfuse3_15EntryAttributes_generation, __pyx_setprop_7pyfuse3_15EntryAttributes_generation, (char *)"The inode generation number", 0}, {(char *)"attr_timeout", __pyx_getprop_7pyfuse3_15EntryAttributes_attr_timeout, __pyx_setprop_7pyfuse3_15EntryAttributes_attr_timeout, (char *)"Validity timeout for the attributes of the directory entry\n\n Floating point numbers may be used. Units are seconds.\n ", 0}, {(char *)"entry_timeout", __pyx_getprop_7pyfuse3_15EntryAttributes_entry_timeout, __pyx_setprop_7pyfuse3_15EntryAttributes_entry_timeout, (char *)"Validity timeout for the name/existence of the directory entry\n\n Floating point numbers may be used. Units are seconds.\n ", 0}, {(char *)"st_mode", __pyx_getprop_7pyfuse3_15EntryAttributes_st_mode, __pyx_setprop_7pyfuse3_15EntryAttributes_st_mode, (char *)0, 0}, {(char *)"st_nlink", __pyx_getprop_7pyfuse3_15EntryAttributes_st_nlink, __pyx_setprop_7pyfuse3_15EntryAttributes_st_nlink, (char *)0, 0}, {(char *)"st_uid", __pyx_getprop_7pyfuse3_15EntryAttributes_st_uid, __pyx_setprop_7pyfuse3_15EntryAttributes_st_uid, (char *)0, 0}, {(char *)"st_gid", __pyx_getprop_7pyfuse3_15EntryAttributes_st_gid, __pyx_setprop_7pyfuse3_15EntryAttributes_st_gid, (char *)0, 0}, {(char *)"st_rdev", __pyx_getprop_7pyfuse3_15EntryAttributes_st_rdev, __pyx_setprop_7pyfuse3_15EntryAttributes_st_rdev, (char *)0, 0}, {(char *)"st_size", __pyx_getprop_7pyfuse3_15EntryAttributes_st_size, __pyx_setprop_7pyfuse3_15EntryAttributes_st_size, (char *)0, 0}, {(char *)"st_blocks", __pyx_getprop_7pyfuse3_15EntryAttributes_st_blocks, __pyx_setprop_7pyfuse3_15EntryAttributes_st_blocks, (char *)0, 0}, {(char *)"st_blksize", __pyx_getprop_7pyfuse3_15EntryAttributes_st_blksize, __pyx_setprop_7pyfuse3_15EntryAttributes_st_blksize, (char *)0, 0}, {(char *)"st_atime_ns", __pyx_getprop_7pyfuse3_15EntryAttributes_st_atime_ns, __pyx_setprop_7pyfuse3_15EntryAttributes_st_atime_ns, (char *)"Time of last access in (integer) nanoseconds", 0}, {(char *)"st_mtime_ns", __pyx_getprop_7pyfuse3_15EntryAttributes_st_mtime_ns, __pyx_setprop_7pyfuse3_15EntryAttributes_st_mtime_ns, (char *)"Time of last modification in (integer) nanoseconds", 0}, {(char *)"st_ctime_ns", __pyx_getprop_7pyfuse3_15EntryAttributes_st_ctime_ns, __pyx_setprop_7pyfuse3_15EntryAttributes_st_ctime_ns, (char *)"Time of last inode modification in (integer) nanoseconds", 0}, {(char *)"st_birthtime_ns", __pyx_getprop_7pyfuse3_15EntryAttributes_st_birthtime_ns, __pyx_setprop_7pyfuse3_15EntryAttributes_st_birthtime_ns, (char *)"Time of inode creation in (integer) nanoseconds.\n\n Only available under BSD and OS X. Will be zero on Linux.\n ", 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3_EntryAttributes = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.EntryAttributes", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3_EntryAttributes), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3_EntryAttributes, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "\n Instances of this class store attributes of directory entries.\n Most of the attributes correspond to the elements of the ``stat``\n C struct as returned by e.g. ``fstat`` and should be\n self-explanatory.\n ", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3_EntryAttributes, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_7pyfuse3_EntryAttributes, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3_EntryAttributes, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_vtabstruct_7pyfuse3_FileInfo __pyx_vtable_7pyfuse3_FileInfo; static struct __pyx_obj_7pyfuse3_FileInfo *__pyx_freelist_7pyfuse3_FileInfo[10]; static int __pyx_freecount_7pyfuse3_FileInfo = 0; static PyObject *__pyx_tp_new_7pyfuse3_FileInfo(PyTypeObject *t, PyObject *a, PyObject *k) { struct __pyx_obj_7pyfuse3_FileInfo *p; PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3_FileInfo > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_FileInfo)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { o = (PyObject*)__pyx_freelist_7pyfuse3_FileInfo[--__pyx_freecount_7pyfuse3_FileInfo]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3_FileInfo)); (void) PyObject_INIT(o, t); } else { if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; } p = ((struct __pyx_obj_7pyfuse3_FileInfo *)o); p->__pyx_vtab = __pyx_vtabptr_7pyfuse3_FileInfo; if (unlikely(__pyx_pw_7pyfuse3_8FileInfo_1__cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_7pyfuse3_FileInfo(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3_FileInfo < 10) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_FileInfo)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { __pyx_freelist_7pyfuse3_FileInfo[__pyx_freecount_7pyfuse3_FileInfo++] = ((struct __pyx_obj_7pyfuse3_FileInfo *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static PyObject *__pyx_getprop_7pyfuse3_8FileInfo_fh(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_8FileInfo_2fh_1__get__(o); } static int __pyx_setprop_7pyfuse3_8FileInfo_fh(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_8FileInfo_2fh_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_8FileInfo_direct_io(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_8FileInfo_9direct_io_1__get__(o); } static int __pyx_setprop_7pyfuse3_8FileInfo_direct_io(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_8FileInfo_9direct_io_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_8FileInfo_keep_cache(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_8FileInfo_10keep_cache_1__get__(o); } static int __pyx_setprop_7pyfuse3_8FileInfo_keep_cache(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_8FileInfo_10keep_cache_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_8FileInfo_nonseekable(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_8FileInfo_11nonseekable_1__get__(o); } static int __pyx_setprop_7pyfuse3_8FileInfo_nonseekable(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_8FileInfo_11nonseekable_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyMethodDef __pyx_methods_7pyfuse3_FileInfo[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_8FileInfo_3__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_8FileInfo_2__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_8FileInfo_5__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_8FileInfo_4__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_7pyfuse3_FileInfo[] = { {(char *)"fh", __pyx_getprop_7pyfuse3_8FileInfo_fh, __pyx_setprop_7pyfuse3_8FileInfo_fh, (char *)"fh: 'uint64_t'", 0}, {(char *)"direct_io", __pyx_getprop_7pyfuse3_8FileInfo_direct_io, __pyx_setprop_7pyfuse3_8FileInfo_direct_io, (char *)"direct_io: 'bool'", 0}, {(char *)"keep_cache", __pyx_getprop_7pyfuse3_8FileInfo_keep_cache, __pyx_setprop_7pyfuse3_8FileInfo_keep_cache, (char *)"keep_cache: 'bool'", 0}, {(char *)"nonseekable", __pyx_getprop_7pyfuse3_8FileInfo_nonseekable, __pyx_setprop_7pyfuse3_8FileInfo_nonseekable, (char *)"nonseekable: 'bool'", 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3_FileInfo = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.FileInfo", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3_FileInfo), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3_FileInfo, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "\n Instances of this class store options and data that `Operations.open`\n returns. The attributes correspond to the elements of the ``fuse_file_info``\n struct that are relevant to the `Operations.open` function.\n ", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3_FileInfo, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_7pyfuse3_FileInfo, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3_FileInfo, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3_StatvfsData *__pyx_freelist_7pyfuse3_StatvfsData[1]; static int __pyx_freecount_7pyfuse3_StatvfsData = 0; static PyObject *__pyx_tp_new_7pyfuse3_StatvfsData(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3_StatvfsData > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_StatvfsData)) & ((t->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { o = (PyObject*)__pyx_freelist_7pyfuse3_StatvfsData[--__pyx_freecount_7pyfuse3_StatvfsData]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3_StatvfsData)); (void) PyObject_INIT(o, t); } else { if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; } if (unlikely(__pyx_pw_7pyfuse3_11StatvfsData_1__cinit__(o, __pyx_empty_tuple, NULL) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_7pyfuse3_StatvfsData(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3_StatvfsData < 1) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3_StatvfsData)) & ((Py_TYPE(o)->tp_flags & (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE)) == 0))) { __pyx_freelist_7pyfuse3_StatvfsData[__pyx_freecount_7pyfuse3_StatvfsData++] = ((struct __pyx_obj_7pyfuse3_StatvfsData *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_bsize(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_7f_bsize_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_bsize(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_7f_bsize_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_frsize(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_8f_frsize_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_frsize(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_8f_frsize_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_blocks(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_8f_blocks_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_blocks(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_8f_blocks_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_bfree(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_7f_bfree_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_bfree(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_7f_bfree_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_bavail(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_8f_bavail_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_bavail(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_8f_bavail_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_files(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_7f_files_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_files(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_7f_files_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_ffree(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_7f_ffree_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_ffree(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_7f_ffree_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_favail(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_8f_favail_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_favail(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_8f_favail_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyObject *__pyx_getprop_7pyfuse3_11StatvfsData_f_namemax(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_11StatvfsData_9f_namemax_1__get__(o); } static int __pyx_setprop_7pyfuse3_11StatvfsData_f_namemax(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { if (v) { return __pyx_pw_7pyfuse3_11StatvfsData_9f_namemax_3__set__(o, v); } else { PyErr_SetString(PyExc_NotImplementedError, "__del__"); return -1; } } static PyMethodDef __pyx_methods_7pyfuse3_StatvfsData[] = { {"__getstate__", (PyCFunction)__pyx_pw_7pyfuse3_11StatvfsData_3__getstate__, METH_NOARGS, __pyx_doc_7pyfuse3_11StatvfsData_2__getstate__}, {"__setstate__", (PyCFunction)__pyx_pw_7pyfuse3_11StatvfsData_5__setstate__, METH_O, __pyx_doc_7pyfuse3_11StatvfsData_4__setstate__}, {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_11StatvfsData_7__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_11StatvfsData_6__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_11StatvfsData_9__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_11StatvfsData_8__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_7pyfuse3_StatvfsData[] = { {(char *)"f_bsize", __pyx_getprop_7pyfuse3_11StatvfsData_f_bsize, __pyx_setprop_7pyfuse3_11StatvfsData_f_bsize, (char *)0, 0}, {(char *)"f_frsize", __pyx_getprop_7pyfuse3_11StatvfsData_f_frsize, __pyx_setprop_7pyfuse3_11StatvfsData_f_frsize, (char *)0, 0}, {(char *)"f_blocks", __pyx_getprop_7pyfuse3_11StatvfsData_f_blocks, __pyx_setprop_7pyfuse3_11StatvfsData_f_blocks, (char *)0, 0}, {(char *)"f_bfree", __pyx_getprop_7pyfuse3_11StatvfsData_f_bfree, __pyx_setprop_7pyfuse3_11StatvfsData_f_bfree, (char *)0, 0}, {(char *)"f_bavail", __pyx_getprop_7pyfuse3_11StatvfsData_f_bavail, __pyx_setprop_7pyfuse3_11StatvfsData_f_bavail, (char *)0, 0}, {(char *)"f_files", __pyx_getprop_7pyfuse3_11StatvfsData_f_files, __pyx_setprop_7pyfuse3_11StatvfsData_f_files, (char *)0, 0}, {(char *)"f_ffree", __pyx_getprop_7pyfuse3_11StatvfsData_f_ffree, __pyx_setprop_7pyfuse3_11StatvfsData_f_ffree, (char *)0, 0}, {(char *)"f_favail", __pyx_getprop_7pyfuse3_11StatvfsData_f_favail, __pyx_setprop_7pyfuse3_11StatvfsData_f_favail, (char *)0, 0}, {(char *)"f_namemax", __pyx_getprop_7pyfuse3_11StatvfsData_f_namemax, __pyx_setprop_7pyfuse3_11StatvfsData_f_namemax, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3_StatvfsData = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.StatvfsData", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3_StatvfsData), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3_StatvfsData, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ "\n Instances of this class store information about the file system.\n The attributes correspond to the elements of the ``statvfs``\n struct, see :manpage:`statvfs(2)` for details.\n ", /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3_StatvfsData, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_7pyfuse3_StatvfsData, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3_StatvfsData, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static PyObject *__pyx_tp_new_7pyfuse3_FUSEError(PyTypeObject *t, PyObject *a, PyObject *k) { PyObject *o = (&((PyTypeObject*)PyExc_Exception)[0])->tp_new(t, a, k); if (unlikely(!o)) return 0; if (unlikely(__pyx_pw_7pyfuse3_9FUSEError_1__cinit__(o, a, k) < 0)) goto bad; return o; bad: Py_DECREF(o); o = 0; return NULL; } static void __pyx_tp_dealloc_7pyfuse3_FUSEError(PyObject *o) { #if CYTHON_USE_TP_FINALIZE if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { if (PyObject_CallFinalizerFromDealloc(o)) return; } #endif PyObject_GC_UnTrack(o); PyObject_GC_Track(o); (&((PyTypeObject*)PyExc_Exception)[0])->tp_dealloc(o); } static int __pyx_tp_traverse_7pyfuse3_FUSEError(PyObject *o, visitproc v, void *a) { int e; if (!(&((PyTypeObject*)PyExc_Exception)[0])->tp_traverse); else { e = (&((PyTypeObject*)PyExc_Exception)[0])->tp_traverse(o,v,a); if (e) return e; } return 0; } static int __pyx_tp_clear_7pyfuse3_FUSEError(PyObject *o) { if (!(&((PyTypeObject*)PyExc_Exception)[0])->tp_clear); else (&((PyTypeObject*)PyExc_Exception)[0])->tp_clear(o); return 0; } static PyObject *__pyx_getprop_7pyfuse3_9FUSEError_errno(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_9FUSEError_5errno_1__get__(o); } static PyObject *__pyx_getprop_7pyfuse3_9FUSEError_errno_(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_7pyfuse3_9FUSEError_6errno__1__get__(o); } static PyMethodDef __pyx_methods_7pyfuse3_FUSEError[] = { {"__reduce_cython__", (PyCFunction)__pyx_pw_7pyfuse3_9FUSEError_5__reduce_cython__, METH_NOARGS, __pyx_doc_7pyfuse3_9FUSEError_4__reduce_cython__}, {"__setstate_cython__", (PyCFunction)__pyx_pw_7pyfuse3_9FUSEError_7__setstate_cython__, METH_O, __pyx_doc_7pyfuse3_9FUSEError_6__setstate_cython__}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_7pyfuse3_FUSEError[] = { {(char *)"errno", __pyx_getprop_7pyfuse3_9FUSEError_errno, 0, (char *)"Error code to return to client process", 0}, {(char *)"errno_", __pyx_getprop_7pyfuse3_9FUSEError_errno_, 0, (char *)0, 0}, {0, 0, 0, 0, 0} }; static PyTypeObject __pyx_type_7pyfuse3_FUSEError = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.FUSEError", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3_FUSEError), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3_FUSEError, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ __pyx_pw_7pyfuse3_9FUSEError_3__str__, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ "\n This exception may be raised by request handlers to indicate that\n the requested operation could not be carried out. The system call\n that resulted in the request (if any) will then fail with error\n code *errno_*.\n ", /*tp_doc*/ __pyx_tp_traverse_7pyfuse3_FUSEError, /*tp_traverse*/ __pyx_tp_clear_7pyfuse3_FUSEError, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ __pyx_methods_7pyfuse3_FUSEError, /*tp_methods*/ 0, /*tp_members*/ __pyx_getsets_7pyfuse3_FUSEError, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3_FUSEError, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *__pyx_freelist_7pyfuse3___pyx_scope_struct__fuse_lookup_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct__fuse_lookup_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct__fuse_lookup_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct__fuse_lookup_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct__fuse_lookup_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct__fuse_lookup_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct__fuse_lookup_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_entry); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct__fuse_lookup_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct__fuse_lookup_async[__pyx_freecount_7pyfuse3___pyx_scope_struct__fuse_lookup_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct__fuse_lookup_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_entry) { e = (*v)(((PyObject *)p->__pyx_v_entry), a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct__fuse_lookup_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct__fuse_lookup_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct__fuse_lookup_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct__fuse_lookup_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct__fuse_lookup_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct__fuse_lookup_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_entry); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_entry) { e = (*v)(((PyObject *)p->__pyx_v_entry), a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_1_fuse_getattr_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_entry); Py_CLEAR(p->__pyx_v_fh); Py_CLEAR(p->__pyx_v_fields); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_entry) { e = (*v)(((PyObject *)p->__pyx_v_entry), a); if (e) return e; } if (p->__pyx_v_fh) { e = (*v)(p->__pyx_v_fh, a); if (e) return e; } if (p->__pyx_v_fields) { e = (*v)(((PyObject *)p->__pyx_v_fields), a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_2_fuse_setattr_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_target); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_target) { e = (*v)(p->__pyx_v_target, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_3_fuse_readlink_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_entry); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_entry) { e = (*v)(((PyObject *)p->__pyx_v_entry), a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_4_fuse_mknod_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_entry); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_entry) { e = (*v)(((PyObject *)p->__pyx_v_entry), a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_5_fuse_mkdir_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_6_fuse_unlink_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_7_fuse_rmdir_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_entry); Py_CLEAR(p->__pyx_v_link); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_entry) { e = (*v)(((PyObject *)p->__pyx_v_entry), a); if (e) return e; } if (p->__pyx_v_link) { e = (*v)(p->__pyx_v_link, a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_8_fuse_symlink_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_9_fuse_rename_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_9_fuse_rename_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_9_fuse_rename_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_9_fuse_rename_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_9_fuse_rename_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_9_fuse_rename_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_9_fuse_rename_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_v_newname); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_9_fuse_rename_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_9_fuse_rename_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_9_fuse_rename_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_9_fuse_rename_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_v_newname) { e = (*v)(p->__pyx_v_newname, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_9_fuse_rename_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_9_fuse_rename_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_9_fuse_rename_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_9_fuse_rename_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_9_fuse_rename_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_9_fuse_rename_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_10_fuse_link_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_10_fuse_link_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_10_fuse_link_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_10_fuse_link_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_10_fuse_link_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_10_fuse_link_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_10_fuse_link_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_entry); Py_CLEAR(p->__pyx_v_newname); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_10_fuse_link_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_10_fuse_link_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_10_fuse_link_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_10_fuse_link_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_entry) { e = (*v)(((PyObject *)p->__pyx_v_entry), a); if (e) return e; } if (p->__pyx_v_newname) { e = (*v)(p->__pyx_v_newname, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_10_fuse_link_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_10_fuse_link_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_10_fuse_link_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_10_fuse_link_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_10_fuse_link_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_10_fuse_link_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_11_fuse_open_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_11_fuse_open_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_11_fuse_open_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_11_fuse_open_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_11_fuse_open_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_11_fuse_open_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_11_fuse_open_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_fi); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_11_fuse_open_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_11_fuse_open_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_11_fuse_open_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_11_fuse_open_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_fi) { e = (*v)(((PyObject *)p->__pyx_v_fi), a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_11_fuse_open_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_11_fuse_open_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_11_fuse_open_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_11_fuse_open_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_11_fuse_open_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_11_fuse_open_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_12_fuse_read_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_12_fuse_read_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_12_fuse_read_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *p; PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_12_fuse_read_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_12_fuse_read_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_12_fuse_read_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } p = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *)o); p->__pyx_v_pybuf.obj = NULL; return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_12_fuse_read_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_buf); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_12_fuse_read_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_12_fuse_read_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_12_fuse_read_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_12_fuse_read_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async *)o; if (p->__pyx_v_buf) { e = (*v)(p->__pyx_v_buf, a); if (e) return e; } if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } if (p->__pyx_v_pybuf.obj) { e = (*v)(p->__pyx_v_pybuf.obj, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_12_fuse_read_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_12_fuse_read_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_12_fuse_read_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_12_fuse_read_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_12_fuse_read_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_12_fuse_read_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_13_fuse_write_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_13_fuse_write_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_13_fuse_write_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_13_fuse_write_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_13_fuse_write_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_13_fuse_write_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_13_fuse_write_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_pbuf); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_13_fuse_write_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_13_fuse_write_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_13_fuse_write_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_13_fuse_write_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_pbuf) { e = (*v)(p->__pyx_v_pbuf, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_13_fuse_write_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_13_fuse_write_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_13_fuse_write_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_13_fuse_write_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_13_fuse_write_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_13_fuse_write_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_buf); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async *)o; if (p->__pyx_v_buf) { e = (*v)(p->__pyx_v_buf, a); if (e) return e; } if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_14_fuse_write_buf_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_15_fuse_flush_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_15_fuse_flush_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_15_fuse_flush_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_15_fuse_flush_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_15_fuse_flush_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_15_fuse_flush_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_15_fuse_flush_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_15_fuse_flush_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_15_fuse_flush_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_15_fuse_flush_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_15_fuse_flush_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_15_fuse_flush_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_15_fuse_flush_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_15_fuse_flush_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_15_fuse_flush_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_15_fuse_flush_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_15_fuse_flush_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_16_fuse_release_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_16_fuse_release_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_16_fuse_release_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_16_fuse_release_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_16_fuse_release_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_16_fuse_release_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_16_fuse_release_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_16_fuse_release_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_16_fuse_release_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_16_fuse_release_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_16_fuse_release_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_16_fuse_release_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_16_fuse_release_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_16_fuse_release_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_16_fuse_release_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_16_fuse_release_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_16_fuse_release_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_17_fuse_fsync_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_18_fuse_opendir_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_token); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_token) { e = (*v)(((PyObject *)p->__pyx_v_token), a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_19_fuse_readdirplus_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_20_fuse_releasedir_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_21_fuse_fsyncdir_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_stats); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_stats) { e = (*v)(((PyObject *)p->__pyx_v_stats), a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_22_fuse_statfs_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_v_value); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); Py_CLEAR(p->__pyx_t_3); Py_CLEAR(p->__pyx_t_4); Py_CLEAR(p->__pyx_t_5); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_v_value) { e = (*v)(p->__pyx_v_value, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } if (p->__pyx_t_3) { e = (*v)(p->__pyx_t_3, a); if (e) return e; } if (p->__pyx_t_4) { e = (*v)(p->__pyx_t_4, a); if (e) return e; } if (p->__pyx_t_5) { e = (*v)(p->__pyx_t_5, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_23_fuse_setxattr_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_buf); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async *)o; if (p->__pyx_v_buf) { e = (*v)(p->__pyx_v_buf, a); if (e) return e; } if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_24_fuse_getxattr_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_buf); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_res); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async *)o; if (p->__pyx_v_buf) { e = (*v)(p->__pyx_v_buf, a); if (e) return e; } if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_res) { e = (*v)(p->__pyx_v_res, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_25_fuse_listxattr_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_26_fuse_removexattr_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_27_fuse_access_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_27_fuse_access_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_27_fuse_access_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_27_fuse_access_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_27_fuse_access_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_27_fuse_access_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_27_fuse_access_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_allowed); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_27_fuse_access_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_27_fuse_access_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_27_fuse_access_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_27_fuse_access_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async *)o; if (p->__pyx_v_allowed) { e = (*v)(p->__pyx_v_allowed, a); if (e) return e; } if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_27_fuse_access_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_27_fuse_access_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_27_fuse_access_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_27_fuse_access_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_27_fuse_access_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_27_fuse_access_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *__pyx_freelist_7pyfuse3___pyx_scope_struct_28_fuse_create_async[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_28_fuse_create_async = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_28_fuse_create_async(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_28_fuse_create_async > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_28_fuse_create_async[--__pyx_freecount_7pyfuse3___pyx_scope_struct_28_fuse_create_async]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_28_fuse_create_async(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_c); Py_CLEAR(p->__pyx_v_ctx); Py_CLEAR(p->__pyx_v_e); Py_CLEAR(p->__pyx_v_entry); Py_CLEAR(p->__pyx_v_fi); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_v_tmp); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_28_fuse_create_async < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_28_fuse_create_async[__pyx_freecount_7pyfuse3___pyx_scope_struct_28_fuse_create_async++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_28_fuse_create_async(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async *)o; if (p->__pyx_v_c) { e = (*v)(((PyObject *)p->__pyx_v_c), a); if (e) return e; } if (p->__pyx_v_ctx) { e = (*v)(p->__pyx_v_ctx, a); if (e) return e; } if (p->__pyx_v_e) { e = (*v)(p->__pyx_v_e, a); if (e) return e; } if (p->__pyx_v_entry) { e = (*v)(((PyObject *)p->__pyx_v_entry), a); if (e) return e; } if (p->__pyx_v_fi) { e = (*v)(((PyObject *)p->__pyx_v_fi), a); if (e) return e; } if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_v_tmp) { e = (*v)(p->__pyx_v_tmp, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_28_fuse_create_async = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_28_fuse_create_async", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_28_fuse_create_async), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_28_fuse_create_async, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_28_fuse_create_async, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_28_fuse_create_async, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *__pyx_freelist_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable[--__pyx_freecount_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); Py_CLEAR(p->__pyx_t_3); Py_CLEAR(p->__pyx_t_4); Py_CLEAR(p->__pyx_t_5); Py_CLEAR(p->__pyx_t_6); Py_CLEAR(p->__pyx_t_7); Py_CLEAR(p->__pyx_t_8); Py_CLEAR(p->__pyx_t_9); Py_CLEAR(p->__pyx_t_10); Py_CLEAR(p->__pyx_t_11); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable[__pyx_freecount_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable *)o; if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } if (p->__pyx_t_3) { e = (*v)(p->__pyx_t_3, a); if (e) return e; } if (p->__pyx_t_4) { e = (*v)(p->__pyx_t_4, a); if (e) return e; } if (p->__pyx_t_5) { e = (*v)(p->__pyx_t_5, a); if (e) return e; } if (p->__pyx_t_6) { e = (*v)(p->__pyx_t_6, a); if (e) return e; } if (p->__pyx_t_7) { e = (*v)(p->__pyx_t_7, a); if (e) return e; } if (p->__pyx_t_8) { e = (*v)(p->__pyx_t_8, a); if (e) return e; } if (p->__pyx_t_9) { e = (*v)(p->__pyx_t_9, a); if (e) return e; } if (p->__pyx_t_10) { e = (*v)(p->__pyx_t_10, a); if (e) return e; } if (p->__pyx_t_11) { e = (*v)(p->__pyx_t_11, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_29__wait_fuse_readable", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *__pyx_freelist_7pyfuse3___pyx_scope_struct_30__session_loop[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_30__session_loop = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_30__session_loop(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_30__session_loop > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_30__session_loop[--__pyx_freecount_7pyfuse3___pyx_scope_struct_30__session_loop]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_30__session_loop(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_name); Py_CLEAR(p->__pyx_v_nursery); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_30__session_loop < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_30__session_loop[__pyx_freecount_7pyfuse3___pyx_scope_struct_30__session_loop++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_30__session_loop(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop *)o; if (p->__pyx_v_name) { e = (*v)(p->__pyx_v_name, a); if (e) return e; } if (p->__pyx_v_nursery) { e = (*v)(p->__pyx_v_nursery, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_30__session_loop = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_30__session_loop", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_30__session_loop), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_30__session_loop, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_30__session_loop, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_30__session_loop, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *__pyx_freelist_7pyfuse3___pyx_scope_struct_31_main[8]; static int __pyx_freecount_7pyfuse3___pyx_scope_struct_31_main = 0; static PyObject *__pyx_tp_new_7pyfuse3___pyx_scope_struct_31_main(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; if (CYTHON_COMPILING_IN_CPYTHON && likely((__pyx_freecount_7pyfuse3___pyx_scope_struct_31_main > 0) & (t->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main)))) { o = (PyObject*)__pyx_freelist_7pyfuse3___pyx_scope_struct_31_main[--__pyx_freecount_7pyfuse3___pyx_scope_struct_31_main]; memset(o, 0, sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main)); (void) PyObject_INIT(o, t); PyObject_GC_Track(o); } else { o = (*t->tp_alloc)(t, 0); if (unlikely(!o)) return 0; } return o; } static void __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_31_main(PyObject *o) { struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *)o; PyObject_GC_UnTrack(o); Py_CLEAR(p->__pyx_v_nursery); Py_CLEAR(p->__pyx_t_0); Py_CLEAR(p->__pyx_t_1); Py_CLEAR(p->__pyx_t_2); Py_CLEAR(p->__pyx_t_3); Py_CLEAR(p->__pyx_t_4); Py_CLEAR(p->__pyx_t_5); Py_CLEAR(p->__pyx_t_6); Py_CLEAR(p->__pyx_t_7); if (CYTHON_COMPILING_IN_CPYTHON && ((__pyx_freecount_7pyfuse3___pyx_scope_struct_31_main < 8) & (Py_TYPE(o)->tp_basicsize == sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main)))) { __pyx_freelist_7pyfuse3___pyx_scope_struct_31_main[__pyx_freecount_7pyfuse3___pyx_scope_struct_31_main++] = ((struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *)o); } else { (*Py_TYPE(o)->tp_free)(o); } } static int __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_31_main(PyObject *o, visitproc v, void *a) { int e; struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *p = (struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main *)o; if (p->__pyx_v_nursery) { e = (*v)(p->__pyx_v_nursery, a); if (e) return e; } if (p->__pyx_t_0) { e = (*v)(p->__pyx_t_0, a); if (e) return e; } if (p->__pyx_t_1) { e = (*v)(p->__pyx_t_1, a); if (e) return e; } if (p->__pyx_t_2) { e = (*v)(p->__pyx_t_2, a); if (e) return e; } if (p->__pyx_t_3) { e = (*v)(p->__pyx_t_3, a); if (e) return e; } if (p->__pyx_t_4) { e = (*v)(p->__pyx_t_4, a); if (e) return e; } if (p->__pyx_t_5) { e = (*v)(p->__pyx_t_5, a); if (e) return e; } if (p->__pyx_t_6) { e = (*v)(p->__pyx_t_6, a); if (e) return e; } if (p->__pyx_t_7) { e = (*v)(p->__pyx_t_7, a); if (e) return e; } return 0; } static PyTypeObject __pyx_type_7pyfuse3___pyx_scope_struct_31_main = { PyVarObject_HEAD_INIT(0, 0) "pyfuse3.__pyx_scope_struct_31_main", /*tp_name*/ sizeof(struct __pyx_obj_7pyfuse3___pyx_scope_struct_31_main), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_7pyfuse3___pyx_scope_struct_31_main, /*tp_dealloc*/ #if PY_VERSION_HEX < 0x030800b4 0, /*tp_print*/ #endif #if PY_VERSION_HEX >= 0x030800b4 0, /*tp_vectorcall_offset*/ #endif 0, /*tp_getattr*/ 0, /*tp_setattr*/ #if PY_MAJOR_VERSION < 3 0, /*tp_compare*/ #endif #if PY_MAJOR_VERSION >= 3 0, /*tp_as_async*/ #endif 0, /*tp_repr*/ 0, /*tp_as_number*/ 0, /*tp_as_sequence*/ 0, /*tp_as_mapping*/ 0, /*tp_hash*/ 0, /*tp_call*/ 0, /*tp_str*/ 0, /*tp_getattro*/ 0, /*tp_setattro*/ 0, /*tp_as_buffer*/ Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ 0, /*tp_doc*/ __pyx_tp_traverse_7pyfuse3___pyx_scope_struct_31_main, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ 0, /*tp_weaklistoffset*/ 0, /*tp_iter*/ 0, /*tp_iternext*/ 0, /*tp_methods*/ 0, /*tp_members*/ 0, /*tp_getset*/ 0, /*tp_base*/ 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ 0, /*tp_dictoffset*/ 0, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_7pyfuse3___pyx_scope_struct_31_main, /*tp_new*/ 0, /*tp_free*/ 0, /*tp_is_gc*/ 0, /*tp_bases*/ 0, /*tp_mro*/ 0, /*tp_cache*/ 0, /*tp_subclasses*/ 0, /*tp_weaklist*/ 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 0, /*tp_finalize*/ #endif #if PY_VERSION_HEX >= 0x030800b1 0, /*tp_vectorcall*/ #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, /*tp_print*/ #endif }; static PyMethodDef __pyx_methods[] = { {0, 0, 0, 0} }; #if PY_MAJOR_VERSION >= 3 #if CYTHON_PEP489_MULTI_PHASE_INIT static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ static int __pyx_pymod_exec_pyfuse3(PyObject* module); /*proto*/ static PyModuleDef_Slot __pyx_moduledef_slots[] = { {Py_mod_create, (void*)__pyx_pymod_create}, {Py_mod_exec, (void*)__pyx_pymod_exec_pyfuse3}, {0, NULL} }; #endif static struct PyModuleDef __pyx_moduledef = { PyModuleDef_HEAD_INIT, "pyfuse3", __pyx_k_pyfuse3_pxy_Copyright_2013_Niko, /* m_doc */ #if CYTHON_PEP489_MULTI_PHASE_INIT 0, /* m_size */ #else -1, /* m_size */ #endif __pyx_methods /* m_methods */, #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_moduledef_slots, /* m_slots */ #else NULL, /* m_reload */ #endif NULL, /* m_traverse */ NULL, /* m_clear */ NULL /* m_free */ }; #endif #ifndef CYTHON_SMALL_CODE #if defined(__clang__) #define CYTHON_SMALL_CODE #elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #define CYTHON_SMALL_CODE __attribute__((cold)) #else #define CYTHON_SMALL_CODE #endif #endif static __Pyx_StringTabEntry __pyx_string_tab[] = { {&__pyx_kp_u_Calling_fuse_session_destroy, __pyx_k_Calling_fuse_session_destroy, sizeof(__pyx_k_Calling_fuse_session_destroy), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_mount, __pyx_k_Calling_fuse_session_mount, sizeof(__pyx_k_Calling_fuse_session_mount), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_new, __pyx_k_Calling_fuse_session_new, sizeof(__pyx_k_Calling_fuse_session_new), 0, 1, 0, 0}, {&__pyx_kp_u_Calling_fuse_session_unmount, __pyx_k_Calling_fuse_session_unmount, sizeof(__pyx_k_Calling_fuse_session_unmount), 0, 1, 0, 0}, {&__pyx_n_s_ClosedResourceError, __pyx_k_ClosedResourceError, sizeof(__pyx_k_ClosedResourceError), 0, 0, 1, 1}, {&__pyx_n_s_Container, __pyx_k_Container, sizeof(__pyx_k_Container), 0, 0, 1, 1}, {&__pyx_n_u_ENOATTR, __pyx_k_ENOATTR, sizeof(__pyx_k_ENOATTR), 0, 1, 0, 1}, {&__pyx_n_s_EntryAttributes, __pyx_k_EntryAttributes, sizeof(__pyx_k_EntryAttributes), 0, 0, 1, 1}, {&__pyx_n_s_FUSEError, __pyx_k_FUSEError, sizeof(__pyx_k_FUSEError), 0, 0, 1, 1}, {&__pyx_kp_u_FUSE_fd_about_to_be_closed, __pyx_k_FUSE_fd_about_to_be_closed, sizeof(__pyx_k_FUSE_fd_about_to_be_closed), 0, 1, 0, 0}, {&__pyx_kp_u_FUSE_session_exit_flag_set_while, __pyx_k_FUSE_session_exit_flag_set_while, sizeof(__pyx_k_FUSE_session_exit_flag_set_while), 0, 1, 0, 0}, {&__pyx_kp_u_Failed_to_submit_invalidate_entr, __pyx_k_Failed_to_submit_invalidate_entr, sizeof(__pyx_k_Failed_to_submit_invalidate_entr), 0, 1, 0, 0}, {&__pyx_n_s_FileInfo, __pyx_k_FileInfo, sizeof(__pyx_k_FileInfo), 0, 0, 1, 1}, {&__pyx_n_s_FileNotFoundError, __pyx_k_FileNotFoundError, sizeof(__pyx_k_FileNotFoundError), 0, 0, 1, 1}, {&__pyx_kp_u_Groups, __pyx_k_Groups, sizeof(__pyx_k_Groups), 0, 1, 0, 0}, {&__pyx_kp_s_Incompatible_checksums_s_vs_0x22, __pyx_k_Incompatible_checksums_s_vs_0x22, sizeof(__pyx_k_Incompatible_checksums_s_vs_0x22), 0, 0, 1, 0}, {&__pyx_kp_s_Incompatible_checksums_s_vs_0xe8, __pyx_k_Incompatible_checksums_s_vs_0xe8, sizeof(__pyx_k_Incompatible_checksums_s_vs_0xe8), 0, 0, 1, 0}, {&__pyx_kp_u_Initializing_pyfuse3, __pyx_k_Initializing_pyfuse3, sizeof(__pyx_k_Initializing_pyfuse3), 0, 1, 0, 0}, {&__pyx_kp_u_Kernel_too_old_pyfuse3_requires, __pyx_k_Kernel_too_old_pyfuse3_requires, sizeof(__pyx_k_Kernel_too_old_pyfuse3_requires), 0, 1, 0, 0}, {&__pyx_n_s_Lock, __pyx_k_Lock, sizeof(__pyx_k_Lock), 0, 0, 1, 1}, {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, {&__pyx_n_s_NANOS_PER_SEC, __pyx_k_NANOS_PER_SEC, sizeof(__pyx_k_NANOS_PER_SEC), 0, 0, 1, 1}, {&__pyx_kp_u_Need_to_call_init_before_main, __pyx_k_Need_to_call_init_before_main, sizeof(__pyx_k_Need_to_call_init_before_main), 0, 1, 0, 0}, {&__pyx_n_s_OSError, __pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 0, 1, 1}, {&__pyx_n_s_O_DIRECTORY, __pyx_k_O_DIRECTORY, sizeof(__pyx_k_O_DIRECTORY), 0, 0, 1, 1}, {&__pyx_n_s_Operations, __pyx_k_Operations, sizeof(__pyx_k_Operations), 0, 0, 1, 1}, {&__pyx_n_s_OverflowError, __pyx_k_OverflowError, sizeof(__pyx_k_OverflowError), 0, 0, 1, 1}, {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_PicklingError, __pyx_k_PicklingError, sizeof(__pyx_k_PicklingError), 0, 0, 1, 1}, {&__pyx_n_s_Queue, __pyx_k_Queue, sizeof(__pyx_k_Queue), 0, 0, 1, 1}, {&__pyx_n_u_RENAME_EXCHANGE, __pyx_k_RENAME_EXCHANGE, sizeof(__pyx_k_RENAME_EXCHANGE), 0, 1, 0, 1}, {&__pyx_n_u_RENAME_NOREPLACE, __pyx_k_RENAME_NOREPLACE, sizeof(__pyx_k_RENAME_NOREPLACE), 0, 1, 0, 1}, {&__pyx_n_s_ROOT_INODE, __pyx_k_ROOT_INODE, sizeof(__pyx_k_ROOT_INODE), 0, 0, 1, 1}, {&__pyx_n_s_ReaddirToken, __pyx_k_ReaddirToken, sizeof(__pyx_k_ReaddirToken), 0, 0, 1, 1}, {&__pyx_n_s_RequestContext, __pyx_k_RequestContext, sizeof(__pyx_k_RequestContext), 0, 0, 1, 1}, {&__pyx_kp_u_RequestContext_instances_can_t_b, __pyx_k_RequestContext_instances_can_t_b, sizeof(__pyx_k_RequestContext_instances_can_t_b), 0, 1, 0, 0}, {&__pyx_n_s_RuntimeError, __pyx_k_RuntimeError, sizeof(__pyx_k_RuntimeError), 0, 0, 1, 1}, {&__pyx_n_s_SetattrFields, __pyx_k_SetattrFields, sizeof(__pyx_k_SetattrFields), 0, 0, 1, 1}, {&__pyx_kp_u_SetattrFields_instances_can_t_be, __pyx_k_SetattrFields_instances_can_t_be, sizeof(__pyx_k_SetattrFields_instances_can_t_be), 0, 1, 0, 0}, {&__pyx_kp_u_Starting_notify_worker, __pyx_k_Starting_notify_worker, sizeof(__pyx_k_Starting_notify_worker), 0, 1, 0, 0}, {&__pyx_n_s_StatvfsData, __pyx_k_StatvfsData, sizeof(__pyx_k_StatvfsData), 0, 0, 1, 1}, {&__pyx_n_s_Thread, __pyx_k_Thread, sizeof(__pyx_k_Thread), 0, 0, 1, 1}, {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, {&__pyx_kp_u_Unable_to_parse_s, __pyx_k_Unable_to_parse_s, sizeof(__pyx_k_Unable_to_parse_s), 0, 1, 0, 0}, {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, {&__pyx_kp_u_Value_too_long_to_convert_to_Pyt, __pyx_k_Value_too_long_to_convert_to_Pyt, sizeof(__pyx_k_Value_too_long_to_convert_to_Pyt), 0, 1, 0, 0}, {&__pyx_n_s_WorkerData, __pyx_k_WorkerData, sizeof(__pyx_k_WorkerData), 0, 0, 1, 1}, {&__pyx_kp_b__33, __pyx_k__33, sizeof(__pyx_k__33), 0, 0, 0, 0}, {&__pyx_n_s_abspath, __pyx_k_abspath, sizeof(__pyx_k_abspath), 0, 0, 1, 1}, {&__pyx_n_s_access, __pyx_k_access, sizeof(__pyx_k_access), 0, 0, 1, 1}, {&__pyx_n_s_aenter, __pyx_k_aenter, sizeof(__pyx_k_aenter), 0, 0, 1, 1}, {&__pyx_n_s_aexit, __pyx_k_aexit, sizeof(__pyx_k_aexit), 0, 0, 1, 1}, {&__pyx_n_s_allowed, __pyx_k_allowed, sizeof(__pyx_k_allowed), 0, 0, 1, 1}, {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1}, {&__pyx_n_s_async_wrapper, __pyx_k_async_wrapper, sizeof(__pyx_k_async_wrapper), 0, 0, 1, 1}, {&__pyx_n_s_attr, __pyx_k_attr, sizeof(__pyx_k_attr), 0, 0, 1, 1}, {&__pyx_n_s_attr_only, __pyx_k_attr_only, sizeof(__pyx_k_attr_only), 0, 0, 1, 1}, {&__pyx_n_u_attr_timeout, __pyx_k_attr_timeout, sizeof(__pyx_k_attr_timeout), 0, 1, 0, 1}, {&__pyx_n_s_await, __pyx_k_await, sizeof(__pyx_k_await), 0, 0, 1, 1}, {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1}, {&__pyx_n_s_bufsize, __pyx_k_bufsize, sizeof(__pyx_k_bufsize), 0, 0, 1, 1}, {&__pyx_n_s_bufvec, __pyx_k_bufvec, sizeof(__pyx_k_bufvec), 0, 0, 1, 1}, {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, {&__pyx_n_s_cbuf, __pyx_k_cbuf, sizeof(__pyx_k_cbuf), 0, 0, 1, 1}, {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, {&__pyx_n_s_close, __pyx_k_close, sizeof(__pyx_k_close), 0, 0, 1, 1}, {&__pyx_n_s_cname, __pyx_k_cname, sizeof(__pyx_k_cname), 0, 0, 1, 1}, {&__pyx_n_s_cnamespace, __pyx_k_cnamespace, sizeof(__pyx_k_cnamespace), 0, 0, 1, 1}, {&__pyx_n_s_cpath, __pyx_k_cpath, sizeof(__pyx_k_cpath), 0, 0, 1, 1}, {&__pyx_n_s_create, __pyx_k_create, sizeof(__pyx_k_create), 0, 0, 1, 1}, {&__pyx_n_s_ctx, __pyx_k_ctx, sizeof(__pyx_k_ctx), 0, 0, 1, 1}, {&__pyx_n_s_current_task, __pyx_k_current_task, sizeof(__pyx_k_current_task), 0, 0, 1, 1}, {&__pyx_n_s_current_trio_token, __pyx_k_current_trio_token, sizeof(__pyx_k_current_trio_token), 0, 0, 1, 1}, {&__pyx_n_s_cvalue, __pyx_k_cvalue, sizeof(__pyx_k_cvalue), 0, 0, 1, 1}, {&__pyx_n_s_daemon, __pyx_k_daemon, sizeof(__pyx_k_daemon), 0, 0, 1, 1}, {&__pyx_n_s_data, __pyx_k_data, sizeof(__pyx_k_data), 0, 0, 1, 1}, {&__pyx_n_s_debug, __pyx_k_debug, sizeof(__pyx_k_debug), 0, 0, 1, 1}, {&__pyx_n_s_decode, __pyx_k_decode, sizeof(__pyx_k_decode), 0, 0, 1, 1}, {&__pyx_n_s_default_options, __pyx_k_default_options, sizeof(__pyx_k_default_options), 0, 0, 1, 1}, {&__pyx_n_u_default_permissions, __pyx_k_default_permissions, sizeof(__pyx_k_default_permissions), 0, 1, 0, 1}, {&__pyx_n_s_deleted, __pyx_k_deleted, sizeof(__pyx_k_deleted), 0, 0, 1, 1}, {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, {&__pyx_n_s_direct_io, __pyx_k_direct_io, sizeof(__pyx_k_direct_io), 0, 0, 1, 1}, {&__pyx_n_s_dirp, __pyx_k_dirp, sizeof(__pyx_k_dirp), 0, 0, 1, 1}, {&__pyx_n_s_e, __pyx_k_e, sizeof(__pyx_k_e), 0, 0, 1, 1}, {&__pyx_n_s_enable_acl, __pyx_k_enable_acl, sizeof(__pyx_k_enable_acl), 0, 0, 1, 1}, {&__pyx_n_s_enable_writeback_cache, __pyx_k_enable_writeback_cache, sizeof(__pyx_k_enable_writeback_cache), 0, 0, 1, 1}, {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, {&__pyx_n_s_enter, __pyx_k_enter, sizeof(__pyx_k_enter), 0, 0, 1, 1}, {&__pyx_n_s_entry, __pyx_k_entry, sizeof(__pyx_k_entry), 0, 0, 1, 1}, {&__pyx_n_u_entry_timeout, __pyx_k_entry_timeout, sizeof(__pyx_k_entry_timeout), 0, 1, 0, 1}, {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, {&__pyx_n_s_errno, __pyx_k_errno, sizeof(__pyx_k_errno), 0, 0, 1, 1}, {&__pyx_kp_u_errno_d, __pyx_k_errno_d, sizeof(__pyx_k_errno_d), 0, 1, 0, 0}, {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, {&__pyx_n_s_exc, __pyx_k_exc, sizeof(__pyx_k_exc), 0, 0, 1, 1}, {&__pyx_n_s_exception, __pyx_k_exception, sizeof(__pyx_k_exception), 0, 0, 1, 1}, {&__pyx_n_s_exit, __pyx_k_exit, sizeof(__pyx_k_exit), 0, 0, 1, 1}, {&__pyx_n_s_f_args, __pyx_k_f_args, sizeof(__pyx_k_f_args), 0, 0, 1, 1}, {&__pyx_n_u_f_bavail, __pyx_k_f_bavail, sizeof(__pyx_k_f_bavail), 0, 1, 0, 1}, {&__pyx_n_u_f_bfree, __pyx_k_f_bfree, sizeof(__pyx_k_f_bfree), 0, 1, 0, 1}, {&__pyx_n_u_f_blocks, __pyx_k_f_blocks, sizeof(__pyx_k_f_blocks), 0, 1, 0, 1}, {&__pyx_n_u_f_bsize, __pyx_k_f_bsize, sizeof(__pyx_k_f_bsize), 0, 1, 0, 1}, {&__pyx_n_u_f_favail, __pyx_k_f_favail, sizeof(__pyx_k_f_favail), 0, 1, 0, 1}, {&__pyx_n_u_f_ffree, __pyx_k_f_ffree, sizeof(__pyx_k_f_ffree), 0, 1, 0, 1}, {&__pyx_n_u_f_files, __pyx_k_f_files, sizeof(__pyx_k_f_files), 0, 1, 0, 1}, {&__pyx_n_u_f_frsize, __pyx_k_f_frsize, sizeof(__pyx_k_f_frsize), 0, 1, 0, 1}, {&__pyx_n_u_f_namemax, __pyx_k_f_namemax, sizeof(__pyx_k_f_namemax), 0, 1, 0, 1}, {&__pyx_n_s_fd, __pyx_k_fd, sizeof(__pyx_k_fd), 0, 0, 1, 1}, {&__pyx_n_s_fh, __pyx_k_fh, sizeof(__pyx_k_fh), 0, 0, 1, 1}, {&__pyx_n_s_fi, __pyx_k_fi, sizeof(__pyx_k_fi), 0, 0, 1, 1}, {&__pyx_n_s_fields, __pyx_k_fields, sizeof(__pyx_k_fields), 0, 0, 1, 1}, {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, {&__pyx_n_s_flush, __pyx_k_flush, sizeof(__pyx_k_flush), 0, 0, 1, 1}, {&__pyx_n_s_forget, __pyx_k_forget, sizeof(__pyx_k_forget), 0, 0, 1, 1}, {&__pyx_n_s_fse, __pyx_k_fse, sizeof(__pyx_k_fse), 0, 0, 1, 1}, {&__pyx_n_s_fsync, __pyx_k_fsync, sizeof(__pyx_k_fsync), 0, 0, 1, 1}, {&__pyx_n_s_fsyncdir, __pyx_k_fsyncdir, sizeof(__pyx_k_fsyncdir), 0, 0, 1, 1}, {&__pyx_n_s_fuse_access_async, __pyx_k_fuse_access_async, sizeof(__pyx_k_fuse_access_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_access_fuse_reply__failed_w, __pyx_k_fuse_access_fuse_reply__failed_w, sizeof(__pyx_k_fuse_access_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_buf_copy_failed_with, __pyx_k_fuse_buf_copy_failed_with, sizeof(__pyx_k_fuse_buf_copy_failed_with), 0, 1, 0, 0}, {&__pyx_n_s_fuse_create_async, __pyx_k_fuse_create_async, sizeof(__pyx_k_fuse_create_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_create_fuse_reply__failed_w, __pyx_k_fuse_create_fuse_reply__failed_w, sizeof(__pyx_k_fuse_create_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_n_s_fuse_flush_async, __pyx_k_fuse_flush_async, sizeof(__pyx_k_fuse_flush_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_flush_fuse_reply__failed_wi, __pyx_k_fuse_flush_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_flush_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_n_s_fuse_fsync_async, __pyx_k_fuse_fsync_async, sizeof(__pyx_k_fuse_fsync_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_fsync_fuse_reply__failed_wi, __pyx_k_fuse_fsync_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_fsync_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_n_s_fuse_fsyncdir_async, __pyx_k_fuse_fsyncdir_async, sizeof(__pyx_k_fuse_fsyncdir_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_fsyncdir_fuse_reply__failed, __pyx_k_fuse_fsyncdir_fuse_reply__failed, sizeof(__pyx_k_fuse_fsyncdir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_getattr_async, __pyx_k_fuse_getattr_async, sizeof(__pyx_k_fuse_getattr_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_getattr_fuse_reply__failed, __pyx_k_fuse_getattr_fuse_reply__failed, sizeof(__pyx_k_fuse_getattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_getxattr_async, __pyx_k_fuse_getxattr_async, sizeof(__pyx_k_fuse_getxattr_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_getxattr_fuse_reply__failed, __pyx_k_fuse_getxattr_fuse_reply__failed, sizeof(__pyx_k_fuse_getxattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_link_async, __pyx_k_fuse_link_async, sizeof(__pyx_k_fuse_link_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_link_fuse_reply__failed_wit, __pyx_k_fuse_link_fuse_reply__failed_wit, sizeof(__pyx_k_fuse_link_fuse_reply__failed_wit), 0, 1, 0, 0}, {&__pyx_n_s_fuse_listxattr_async, __pyx_k_fuse_listxattr_async, sizeof(__pyx_k_fuse_listxattr_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_listxattr_fuse_reply__faile, __pyx_k_fuse_listxattr_fuse_reply__faile, sizeof(__pyx_k_fuse_listxattr_fuse_reply__faile), 0, 1, 0, 0}, {&__pyx_n_s_fuse_lookup_async, __pyx_k_fuse_lookup_async, sizeof(__pyx_k_fuse_lookup_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_lookup_fuse_reply__failed_w, __pyx_k_fuse_lookup_fuse_reply__failed_w, sizeof(__pyx_k_fuse_lookup_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lowlevel_notify_delete_retu, __pyx_k_fuse_lowlevel_notify_delete_retu, sizeof(__pyx_k_fuse_lowlevel_notify_delete_retu), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lowlevel_notify_inval_entry, __pyx_k_fuse_lowlevel_notify_inval_entry, sizeof(__pyx_k_fuse_lowlevel_notify_inval_entry), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lowlevel_notify_inval_inode, __pyx_k_fuse_lowlevel_notify_inval_inode, sizeof(__pyx_k_fuse_lowlevel_notify_inval_inode), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_lowlevel_notify_store_retur, __pyx_k_fuse_lowlevel_notify_store_retur, sizeof(__pyx_k_fuse_lowlevel_notify_store_retur), 0, 1, 0, 0}, {&__pyx_n_s_fuse_mkdir_async, __pyx_k_fuse_mkdir_async, sizeof(__pyx_k_fuse_mkdir_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_mkdir_fuse_reply__failed_wi, __pyx_k_fuse_mkdir_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_mkdir_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_n_s_fuse_mknod_async, __pyx_k_fuse_mknod_async, sizeof(__pyx_k_fuse_mknod_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_mknod_fuse_reply__failed_wi, __pyx_k_fuse_mknod_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_mknod_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_n_s_fuse_open_async, __pyx_k_fuse_open_async, sizeof(__pyx_k_fuse_open_async), 0, 0, 1, 1}, {&__pyx_n_s_fuse_opendir_async, __pyx_k_fuse_opendir_async, sizeof(__pyx_k_fuse_opendir_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_opendir_fuse_reply__failed, __pyx_k_fuse_opendir_fuse_reply__failed, sizeof(__pyx_k_fuse_opendir_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_read_async, __pyx_k_fuse_read_async, sizeof(__pyx_k_fuse_read_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_read_fuse_reply__failed_wit, __pyx_k_fuse_read_fuse_reply__failed_wit, sizeof(__pyx_k_fuse_read_fuse_reply__failed_wit), 0, 1, 0, 0}, {&__pyx_n_s_fuse_readdirplus_async, __pyx_k_fuse_readdirplus_async, sizeof(__pyx_k_fuse_readdirplus_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_readdirplus_fuse_reply__fai, __pyx_k_fuse_readdirplus_fuse_reply__fai, sizeof(__pyx_k_fuse_readdirplus_fuse_reply__fai), 0, 1, 0, 0}, {&__pyx_n_s_fuse_readlink_async, __pyx_k_fuse_readlink_async, sizeof(__pyx_k_fuse_readlink_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_readlink_fuse_reply__failed, __pyx_k_fuse_readlink_fuse_reply__failed, sizeof(__pyx_k_fuse_readlink_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_release_async, __pyx_k_fuse_release_async, sizeof(__pyx_k_fuse_release_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_release_fuse_reply__failed, __pyx_k_fuse_release_fuse_reply__failed, sizeof(__pyx_k_fuse_release_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_releasedir_async, __pyx_k_fuse_releasedir_async, sizeof(__pyx_k_fuse_releasedir_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_releasedir_fuse_reply__fail, __pyx_k_fuse_releasedir_fuse_reply__fail, sizeof(__pyx_k_fuse_releasedir_fuse_reply__fail), 0, 1, 0, 0}, {&__pyx_n_s_fuse_removexattr_async, __pyx_k_fuse_removexattr_async, sizeof(__pyx_k_fuse_removexattr_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_removexattr_fuse_reply__fai, __pyx_k_fuse_removexattr_fuse_reply__fai, sizeof(__pyx_k_fuse_removexattr_fuse_reply__fai), 0, 1, 0, 0}, {&__pyx_n_s_fuse_rename_async, __pyx_k_fuse_rename_async, sizeof(__pyx_k_fuse_rename_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_rename_fuse_reply__failed_w, __pyx_k_fuse_rename_fuse_reply__failed_w, sizeof(__pyx_k_fuse_rename_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_n_s_fuse_rmdir_async, __pyx_k_fuse_rmdir_async, sizeof(__pyx_k_fuse_rmdir_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_rmdir_fuse_reply__failed_wi, __pyx_k_fuse_rmdir_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_rmdir_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_mount_failed, __pyx_k_fuse_session_mount_failed, sizeof(__pyx_k_fuse_session_mount_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_new_failed, __pyx_k_fuse_session_new_failed, sizeof(__pyx_k_fuse_session_new_failed), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_session_receive_buf_failed, __pyx_k_fuse_session_receive_buf_failed, sizeof(__pyx_k_fuse_session_receive_buf_failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_setattr_async, __pyx_k_fuse_setattr_async, sizeof(__pyx_k_fuse_setattr_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_setattr_clock_gettime_CLOCK, __pyx_k_fuse_setattr_clock_gettime_CLOCK, sizeof(__pyx_k_fuse_setattr_clock_gettime_CLOCK), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_setattr_fuse_reply__failed, __pyx_k_fuse_setattr_fuse_reply__failed, sizeof(__pyx_k_fuse_setattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_setxattr_async, __pyx_k_fuse_setxattr_async, sizeof(__pyx_k_fuse_setxattr_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_setxattr_fuse_reply__failed, __pyx_k_fuse_setxattr_fuse_reply__failed, sizeof(__pyx_k_fuse_setxattr_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_u_fuse_stacktrace, __pyx_k_fuse_stacktrace, sizeof(__pyx_k_fuse_stacktrace), 0, 1, 0, 1}, {&__pyx_n_s_fuse_statfs_async, __pyx_k_fuse_statfs_async, sizeof(__pyx_k_fuse_statfs_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_statfs_fuse_reply__failed_w, __pyx_k_fuse_statfs_fuse_reply__failed_w, sizeof(__pyx_k_fuse_statfs_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_n_s_fuse_symlink_async, __pyx_k_fuse_symlink_async, sizeof(__pyx_k_fuse_symlink_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_symlink_fuse_reply__failed, __pyx_k_fuse_symlink_fuse_reply__failed, sizeof(__pyx_k_fuse_symlink_fuse_reply__failed), 0, 1, 0, 0}, {&__pyx_n_s_fuse_unlink_async, __pyx_k_fuse_unlink_async, sizeof(__pyx_k_fuse_unlink_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_unlink_fuse_reply__failed_w, __pyx_k_fuse_unlink_fuse_reply__failed_w, sizeof(__pyx_k_fuse_unlink_fuse_reply__failed_w), 0, 1, 0, 0}, {&__pyx_n_s_fuse_write_async, __pyx_k_fuse_write_async, sizeof(__pyx_k_fuse_write_async), 0, 0, 1, 1}, {&__pyx_n_s_fuse_write_buf_async, __pyx_k_fuse_write_buf_async, sizeof(__pyx_k_fuse_write_buf_async), 0, 0, 1, 1}, {&__pyx_kp_u_fuse_write_buf_fuse_reply__faile, __pyx_k_fuse_write_buf_fuse_reply__faile, sizeof(__pyx_k_fuse_write_buf_fuse_reply__faile), 0, 1, 0, 0}, {&__pyx_kp_u_fuse_write_fuse_reply__failed_wi, __pyx_k_fuse_write_fuse_reply__failed_wi, sizeof(__pyx_k_fuse_write_fuse_reply__failed_wi), 0, 1, 0, 0}, {&__pyx_n_s_g, __pyx_k_g, sizeof(__pyx_k_g), 0, 0, 1, 1}, {&__pyx_n_u_generation, __pyx_k_generation, sizeof(__pyx_k_generation), 0, 1, 0, 1}, {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, {&__pyx_n_s_getLogger, __pyx_k_getLogger, sizeof(__pyx_k_getLogger), 0, 0, 1, 1}, {&__pyx_n_s_get_sup_groups, __pyx_k_get_sup_groups, sizeof(__pyx_k_get_sup_groups), 0, 0, 1, 1}, {&__pyx_n_s_getattr, __pyx_k_getattr, sizeof(__pyx_k_getattr), 0, 0, 1, 1}, {&__pyx_n_s_getfilesystemencoding, __pyx_k_getfilesystemencoding, sizeof(__pyx_k_getfilesystemencoding), 0, 0, 1, 1}, {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, {&__pyx_n_s_getxattr, __pyx_k_getxattr, sizeof(__pyx_k_getxattr), 0, 0, 1, 1}, {&__pyx_n_s_gids, __pyx_k_gids, sizeof(__pyx_k_gids), 0, 0, 1, 1}, {&__pyx_n_s_ignore_enoent, __pyx_k_ignore_enoent, sizeof(__pyx_k_ignore_enoent), 0, 0, 1, 1}, {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, {&__pyx_n_s_init, __pyx_k_init, sizeof(__pyx_k_init), 0, 0, 1, 1}, {&__pyx_n_s_ino, __pyx_k_ino, sizeof(__pyx_k_ino), 0, 0, 1, 1}, {&__pyx_n_s_inode, __pyx_k_inode, sizeof(__pyx_k_inode), 0, 0, 1, 1}, {&__pyx_n_s_inode_p, __pyx_k_inode_p, sizeof(__pyx_k_inode_p), 0, 0, 1, 1}, {&__pyx_n_s_invalidate_entry, __pyx_k_invalidate_entry, sizeof(__pyx_k_invalidate_entry), 0, 0, 1, 1}, {&__pyx_n_s_invalidate_entry_async, __pyx_k_invalidate_entry_async, sizeof(__pyx_k_invalidate_entry_async), 0, 0, 1, 1}, {&__pyx_n_s_invalidate_inode, __pyx_k_invalidate_inode, sizeof(__pyx_k_invalidate_inode), 0, 0, 1, 1}, {&__pyx_n_s_items, __pyx_k_items, sizeof(__pyx_k_items), 0, 0, 1, 1}, {&__pyx_n_s_join, __pyx_k_join, sizeof(__pyx_k_join), 0, 0, 1, 1}, {&__pyx_n_s_keep_cache, __pyx_k_keep_cache, sizeof(__pyx_k_keep_cache), 0, 0, 1, 1}, {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1}, {&__pyx_n_s_len_s, __pyx_k_len_s, sizeof(__pyx_k_len_s), 0, 0, 1, 1}, {&__pyx_n_s_line, __pyx_k_line, sizeof(__pyx_k_line), 0, 0, 1, 1}, {&__pyx_n_s_link, __pyx_k_link, sizeof(__pyx_k_link), 0, 0, 1, 1}, {&__pyx_n_s_listdir, __pyx_k_listdir, sizeof(__pyx_k_listdir), 0, 0, 1, 1}, {&__pyx_n_s_listxattr, __pyx_k_listxattr, sizeof(__pyx_k_listxattr), 0, 0, 1, 1}, {&__pyx_n_s_log, __pyx_k_log, sizeof(__pyx_k_log), 0, 0, 1, 1}, {&__pyx_n_s_logging, __pyx_k_logging, sizeof(__pyx_k_logging), 0, 0, 1, 1}, {&__pyx_n_s_lookup, __pyx_k_lookup, sizeof(__pyx_k_lookup), 0, 0, 1, 1}, {&__pyx_n_s_lowlevel, __pyx_k_lowlevel, sizeof(__pyx_k_lowlevel), 0, 0, 1, 1}, {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, {&__pyx_n_s_main_2, __pyx_k_main_2, sizeof(__pyx_k_main_2), 0, 0, 1, 1}, {&__pyx_n_s_mask, __pyx_k_mask, sizeof(__pyx_k_mask), 0, 0, 1, 1}, {&__pyx_n_s_max_tasks, __pyx_k_max_tasks, sizeof(__pyx_k_max_tasks), 0, 0, 1, 1}, {&__pyx_n_s_min_tasks, __pyx_k_min_tasks, sizeof(__pyx_k_min_tasks), 0, 0, 1, 1}, {&__pyx_n_s_mkdir, __pyx_k_mkdir, sizeof(__pyx_k_mkdir), 0, 0, 1, 1}, {&__pyx_n_s_mknod, __pyx_k_mknod, sizeof(__pyx_k_mknod), 0, 0, 1, 1}, {&__pyx_n_s_mountpoint, __pyx_k_mountpoint, sizeof(__pyx_k_mountpoint), 0, 0, 1, 1}, {&__pyx_kp_u_mountpoint__argument_must_be_of, __pyx_k_mountpoint__argument_must_be_of, sizeof(__pyx_k_mountpoint__argument_must_be_of), 0, 1, 0, 0}, {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, {&__pyx_kp_u_name_argument_must_be_of_type_s, __pyx_k_name_argument_must_be_of_type_s, sizeof(__pyx_k_name_argument_must_be_of_type_s), 0, 1, 0, 0}, {&__pyx_n_s_name_b, __pyx_k_name_b, sizeof(__pyx_k_name_b), 0, 0, 1, 1}, {&__pyx_n_s_names, __pyx_k_names, sizeof(__pyx_k_names), 0, 0, 1, 1}, {&__pyx_n_s_namespace, __pyx_k_namespace, sizeof(__pyx_k_namespace), 0, 0, 1, 1}, {&__pyx_kp_u_namespace_parameter_must_be_sys, __pyx_k_namespace_parameter_must_be_sys, sizeof(__pyx_k_namespace_parameter_must_be_sys), 0, 1, 0, 0}, {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, {&__pyx_n_s_newname, __pyx_k_newname, sizeof(__pyx_k_newname), 0, 0, 1, 1}, {&__pyx_n_s_newparent, __pyx_k_newparent, sizeof(__pyx_k_newparent), 0, 0, 1, 1}, {&__pyx_n_s_next_id, __pyx_k_next_id, sizeof(__pyx_k_next_id), 0, 0, 1, 1}, {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, {&__pyx_n_s_nonseekable, __pyx_k_nonseekable, sizeof(__pyx_k_nonseekable), 0, 0, 1, 1}, {&__pyx_n_s_notify_closing, __pyx_k_notify_closing, sizeof(__pyx_k_notify_closing), 0, 0, 1, 1}, {&__pyx_n_s_notify_loop, __pyx_k_notify_loop, sizeof(__pyx_k_notify_loop), 0, 0, 1, 1}, {&__pyx_n_s_notify_store, __pyx_k_notify_store, sizeof(__pyx_k_notify_store), 0, 0, 1, 1}, {&__pyx_n_s_now, __pyx_k_now, sizeof(__pyx_k_now), 0, 0, 1, 1}, {&__pyx_n_s_nursery, __pyx_k_nursery, sizeof(__pyx_k_nursery), 0, 0, 1, 1}, {&__pyx_kp_b_o, __pyx_k_o, sizeof(__pyx_k_o), 0, 0, 0, 0}, {&__pyx_n_s_off, __pyx_k_off, sizeof(__pyx_k_off), 0, 0, 1, 1}, {&__pyx_n_s_offset, __pyx_k_offset, sizeof(__pyx_k_offset), 0, 0, 1, 1}, {&__pyx_n_s_open, __pyx_k_open, sizeof(__pyx_k_open), 0, 0, 1, 1}, {&__pyx_n_s_open_nursery, __pyx_k_open_nursery, sizeof(__pyx_k_open_nursery), 0, 0, 1, 1}, {&__pyx_n_s_opendir, __pyx_k_opendir, sizeof(__pyx_k_opendir), 0, 0, 1, 1}, {&__pyx_n_s_ops, __pyx_k_ops, sizeof(__pyx_k_ops), 0, 0, 1, 1}, {&__pyx_n_s_options, __pyx_k_options, sizeof(__pyx_k_options), 0, 0, 1, 1}, {&__pyx_n_s_os, __pyx_k_os, sizeof(__pyx_k_os), 0, 0, 1, 1}, {&__pyx_n_s_os_path, __pyx_k_os_path, sizeof(__pyx_k_os_path), 0, 0, 1, 1}, {&__pyx_n_s_path, __pyx_k_path, sizeof(__pyx_k_path), 0, 0, 1, 1}, {&__pyx_kp_u_path_argument_must_be_of_type_s, __pyx_k_path_argument_must_be_of_type_s, sizeof(__pyx_k_path_argument_must_be_of_type_s), 0, 1, 0, 0}, {&__pyx_n_s_path_b, __pyx_k_path_b, sizeof(__pyx_k_path_b), 0, 0, 1, 1}, {&__pyx_n_s_pbuf, __pyx_k_pbuf, sizeof(__pyx_k_pbuf), 0, 0, 1, 1}, {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, {&__pyx_n_s_pid, __pyx_k_pid, sizeof(__pyx_k_pid), 0, 0, 1, 1}, {&__pyx_kp_u_proc_d_status, __pyx_k_proc_d_status, sizeof(__pyx_k_proc_d_status), 0, 1, 0, 0}, {&__pyx_n_s_put, __pyx_k_put, sizeof(__pyx_k_put), 0, 0, 1, 1}, {&__pyx_kp_u_py_retval_was_not_awaited_please, __pyx_k_py_retval_was_not_awaited_please, sizeof(__pyx_k_py_retval_was_not_awaited_please), 0, 1, 0, 0}, {&__pyx_n_s_pybuf, __pyx_k_pybuf, sizeof(__pyx_k_pybuf), 0, 0, 1, 1}, {&__pyx_n_b_pyfuse3, __pyx_k_pyfuse3, sizeof(__pyx_k_pyfuse3), 0, 0, 0, 1}, {&__pyx_n_s_pyfuse3, __pyx_k_pyfuse3, sizeof(__pyx_k_pyfuse3), 0, 0, 1, 1}, {&__pyx_n_u_pyfuse3, __pyx_k_pyfuse3, sizeof(__pyx_k_pyfuse3), 0, 1, 0, 1}, {&__pyx_n_s_pyfuse3_2, __pyx_k_pyfuse3_2, sizeof(__pyx_k_pyfuse3_2), 0, 0, 1, 1}, {&__pyx_kp_u_pyfuse_02d, __pyx_k_pyfuse_02d, sizeof(__pyx_k_pyfuse_02d), 0, 1, 0, 0}, {&__pyx_n_s_pyx_PickleError, __pyx_k_pyx_PickleError, sizeof(__pyx_k_pyx_PickleError), 0, 0, 1, 1}, {&__pyx_n_s_pyx_checksum, __pyx_k_pyx_checksum, sizeof(__pyx_k_pyx_checksum), 0, 0, 1, 1}, {&__pyx_n_s_pyx_result, __pyx_k_pyx_result, sizeof(__pyx_k_pyx_result), 0, 0, 1, 1}, {&__pyx_n_s_pyx_state, __pyx_k_pyx_state, sizeof(__pyx_k_pyx_state), 0, 0, 1, 1}, {&__pyx_n_s_pyx_type, __pyx_k_pyx_type, sizeof(__pyx_k_pyx_type), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle_RequestContext, __pyx_k_pyx_unpickle_RequestContext, sizeof(__pyx_k_pyx_unpickle_RequestContext), 0, 0, 1, 1}, {&__pyx_n_s_pyx_unpickle__WorkerData, __pyx_k_pyx_unpickle__WorkerData, sizeof(__pyx_k_pyx_unpickle__WorkerData), 0, 0, 1, 1}, {&__pyx_n_s_pyx_vtable, __pyx_k_pyx_vtable, sizeof(__pyx_k_pyx_vtable), 0, 0, 1, 1}, {&__pyx_n_s_queue, __pyx_k_queue, sizeof(__pyx_k_queue), 0, 0, 1, 1}, {&__pyx_n_u_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 1, 0, 1}, {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1}, {&__pyx_n_s_read, __pyx_k_read, sizeof(__pyx_k_read), 0, 0, 1, 1}, {&__pyx_n_s_readdir, __pyx_k_readdir, sizeof(__pyx_k_readdir), 0, 0, 1, 1}, {&__pyx_n_s_readdir_reply, __pyx_k_readdir_reply, sizeof(__pyx_k_readdir_reply), 0, 0, 1, 1}, {&__pyx_n_s_readlink, __pyx_k_readlink, sizeof(__pyx_k_readlink), 0, 0, 1, 1}, {&__pyx_n_s_reduce, __pyx_k_reduce, sizeof(__pyx_k_reduce), 0, 0, 1, 1}, {&__pyx_n_s_reduce_cython, __pyx_k_reduce_cython, sizeof(__pyx_k_reduce_cython), 0, 0, 1, 1}, {&__pyx_n_s_reduce_ex, __pyx_k_reduce_ex, sizeof(__pyx_k_reduce_ex), 0, 0, 1, 1}, {&__pyx_n_s_release, __pyx_k_release, sizeof(__pyx_k_release), 0, 0, 1, 1}, {&__pyx_n_s_releasedir, __pyx_k_releasedir, sizeof(__pyx_k_releasedir), 0, 0, 1, 1}, {&__pyx_n_s_removexattr, __pyx_k_removexattr, sizeof(__pyx_k_removexattr), 0, 0, 1, 1}, {&__pyx_n_s_rename, __pyx_k_rename, sizeof(__pyx_k_rename), 0, 0, 1, 1}, {&__pyx_n_s_req, __pyx_k_req, sizeof(__pyx_k_req), 0, 0, 1, 1}, {&__pyx_n_s_res, __pyx_k_res, sizeof(__pyx_k_res), 0, 0, 1, 1}, {&__pyx_n_s_ret, __pyx_k_ret, sizeof(__pyx_k_ret), 0, 0, 1, 1}, {&__pyx_n_s_rmdir, __pyx_k_rmdir, sizeof(__pyx_k_rmdir), 0, 0, 1, 1}, {&__pyx_kp_u_s_No_tasks_waiting_starting_ano, __pyx_k_s_No_tasks_waiting_starting_ano, sizeof(__pyx_k_s_No_tasks_waiting_starting_ano), 0, 1, 0, 0}, {&__pyx_kp_u_s_terminated, __pyx_k_s_terminated, sizeof(__pyx_k_s_terminated), 0, 1, 0, 0}, {&__pyx_kp_u_s_too_many_idle_tasks_d_total_d, __pyx_k_s_too_many_idle_tasks_d_total_d, sizeof(__pyx_k_s_too_many_idle_tasks_d_total_d), 0, 1, 0, 0}, {&__pyx_kp_s_self_req_cannot_be_converted_to, __pyx_k_self_req_cannot_be_converted_to, sizeof(__pyx_k_self_req_cannot_be_converted_to), 0, 0, 1, 0}, {&__pyx_n_s_send, __pyx_k_send, sizeof(__pyx_k_send), 0, 0, 1, 1}, {&__pyx_n_s_session_loop, __pyx_k_session_loop, sizeof(__pyx_k_session_loop), 0, 0, 1, 1}, {&__pyx_n_s_setattr, __pyx_k_setattr, sizeof(__pyx_k_setattr), 0, 0, 1, 1}, {&__pyx_n_s_setstate, __pyx_k_setstate, sizeof(__pyx_k_setstate), 0, 0, 1, 1}, {&__pyx_n_s_setstate_cython, __pyx_k_setstate_cython, sizeof(__pyx_k_setstate_cython), 0, 0, 1, 1}, {&__pyx_n_s_setxattr, __pyx_k_setxattr, sizeof(__pyx_k_setxattr), 0, 0, 1, 1}, {&__pyx_n_s_size_guess, __pyx_k_size_guess, sizeof(__pyx_k_size_guess), 0, 0, 1, 1}, {&__pyx_n_s_slen, __pyx_k_slen, sizeof(__pyx_k_slen), 0, 0, 1, 1}, {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1}, {&__pyx_kp_s_src_handlers_pxi, __pyx_k_src_handlers_pxi, sizeof(__pyx_k_src_handlers_pxi), 0, 0, 1, 0}, {&__pyx_kp_s_src_internal_pxi, __pyx_k_src_internal_pxi, sizeof(__pyx_k_src_internal_pxi), 0, 0, 1, 0}, {&__pyx_kp_s_src_pyfuse3_pyx, __pyx_k_src_pyfuse3_pyx, sizeof(__pyx_k_src_pyfuse3_pyx), 0, 0, 1, 0}, {&__pyx_n_u_st_atime_ns, __pyx_k_st_atime_ns, sizeof(__pyx_k_st_atime_ns), 0, 1, 0, 1}, {&__pyx_n_u_st_birthtime_ns, __pyx_k_st_birthtime_ns, sizeof(__pyx_k_st_birthtime_ns), 0, 1, 0, 1}, {&__pyx_n_u_st_blksize, __pyx_k_st_blksize, sizeof(__pyx_k_st_blksize), 0, 1, 0, 1}, {&__pyx_n_u_st_blocks, __pyx_k_st_blocks, sizeof(__pyx_k_st_blocks), 0, 1, 0, 1}, {&__pyx_n_u_st_ctime_ns, __pyx_k_st_ctime_ns, sizeof(__pyx_k_st_ctime_ns), 0, 1, 0, 1}, {&__pyx_n_u_st_gid, __pyx_k_st_gid, sizeof(__pyx_k_st_gid), 0, 1, 0, 1}, {&__pyx_n_u_st_ino, __pyx_k_st_ino, sizeof(__pyx_k_st_ino), 0, 1, 0, 1}, {&__pyx_n_u_st_mode, __pyx_k_st_mode, sizeof(__pyx_k_st_mode), 0, 1, 0, 1}, {&__pyx_n_u_st_mtime_ns, __pyx_k_st_mtime_ns, sizeof(__pyx_k_st_mtime_ns), 0, 1, 0, 1}, {&__pyx_n_u_st_nlink, __pyx_k_st_nlink, sizeof(__pyx_k_st_nlink), 0, 1, 0, 1}, {&__pyx_n_u_st_rdev, __pyx_k_st_rdev, sizeof(__pyx_k_st_rdev), 0, 1, 0, 1}, {&__pyx_n_u_st_size, __pyx_k_st_size, sizeof(__pyx_k_st_size), 0, 1, 0, 1}, {&__pyx_n_u_st_uid, __pyx_k_st_uid, sizeof(__pyx_k_st_uid), 0, 1, 0, 1}, {&__pyx_n_s_stacktrace, __pyx_k_stacktrace, sizeof(__pyx_k_stacktrace), 0, 0, 1, 1}, {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, {&__pyx_n_s_start_soon, __pyx_k_start_soon, sizeof(__pyx_k_start_soon), 0, 0, 1, 1}, {&__pyx_n_s_startswith, __pyx_k_startswith, sizeof(__pyx_k_startswith), 0, 0, 1, 1}, {&__pyx_n_s_statfs, __pyx_k_statfs, sizeof(__pyx_k_statfs), 0, 0, 1, 1}, {&__pyx_n_s_stats, __pyx_k_stats, sizeof(__pyx_k_stats), 0, 0, 1, 1}, {&__pyx_n_s_strerror, __pyx_k_strerror, sizeof(__pyx_k_strerror), 0, 0, 1, 1}, {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, {&__pyx_n_s_supports_dot_lookup, __pyx_k_supports_dot_lookup, sizeof(__pyx_k_supports_dot_lookup), 0, 0, 1, 1}, {&__pyx_n_u_surrogateescape, __pyx_k_surrogateescape, sizeof(__pyx_k_surrogateescape), 0, 1, 0, 1}, {&__pyx_n_s_symlink, __pyx_k_symlink, sizeof(__pyx_k_symlink), 0, 0, 1, 1}, {&__pyx_n_s_syncfs, __pyx_k_syncfs, sizeof(__pyx_k_syncfs), 0, 0, 1, 1}, {&__pyx_n_s_sys, __pyx_k_sys, sizeof(__pyx_k_sys), 0, 0, 1, 1}, {&__pyx_n_u_system, __pyx_k_system, sizeof(__pyx_k_system), 0, 1, 0, 1}, {&__pyx_n_s_t, __pyx_k_t, sizeof(__pyx_k_t), 0, 0, 1, 1}, {&__pyx_n_s_target, __pyx_k_target, sizeof(__pyx_k_target), 0, 0, 1, 1}, {&__pyx_n_s_terminate, __pyx_k_terminate, sizeof(__pyx_k_terminate), 0, 0, 1, 1}, {&__pyx_kp_u_terminating_notify_thread, __pyx_k_terminating_notify_thread, sizeof(__pyx_k_terminating_notify_thread), 0, 1, 0, 0}, {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, {&__pyx_n_s_threading, __pyx_k_threading, sizeof(__pyx_k_threading), 0, 0, 1, 1}, {&__pyx_n_s_throw, __pyx_k_throw, sizeof(__pyx_k_throw), 0, 0, 1, 1}, {&__pyx_n_s_tmp, __pyx_k_tmp, sizeof(__pyx_k_tmp), 0, 0, 1, 1}, {&__pyx_n_s_to_set, __pyx_k_to_set, sizeof(__pyx_k_to_set), 0, 0, 1, 1}, {&__pyx_n_s_token, __pyx_k_token, sizeof(__pyx_k_token), 0, 0, 1, 1}, {&__pyx_n_s_trio, __pyx_k_trio, sizeof(__pyx_k_trio), 0, 0, 1, 1}, {&__pyx_n_s_trio_token, __pyx_k_trio_token, sizeof(__pyx_k_trio_token), 0, 0, 1, 1}, {&__pyx_kp_u_unknown_flag_s_o, __pyx_k_unknown_flag_s_o, sizeof(__pyx_k_unknown_flag_s_o), 0, 1, 0, 0}, {&__pyx_n_s_unlink, __pyx_k_unlink, sizeof(__pyx_k_unlink), 0, 0, 1, 1}, {&__pyx_n_s_unmount, __pyx_k_unmount, sizeof(__pyx_k_unmount), 0, 0, 1, 1}, {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, {&__pyx_kp_u_us_ascii, __pyx_k_us_ascii, sizeof(__pyx_k_us_ascii), 0, 1, 0, 0}, {&__pyx_n_u_user, __pyx_k_user, sizeof(__pyx_k_user), 0, 1, 0, 1}, {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1}, {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, {&__pyx_n_s_wait_fuse_readable, __pyx_k_wait_fuse_readable, sizeof(__pyx_k_wait_fuse_readable), 0, 0, 1, 1}, {&__pyx_n_s_wait_readable, __pyx_k_wait_readable, sizeof(__pyx_k_wait_readable), 0, 0, 1, 1}, {&__pyx_n_s_write, __pyx_k_write, sizeof(__pyx_k_write), 0, 0, 1, 1}, {&__pyx_n_s_x, __pyx_k_x, sizeof(__pyx_k_x), 0, 0, 1, 1}, {0, 0, 0, 0, 0, 0, 0} }; static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 2, __pyx_L1_error) __pyx_builtin_RuntimeError = __Pyx_GetBuiltinName(__pyx_n_s_RuntimeError); if (!__pyx_builtin_RuntimeError) __PYX_ERR(1, 35, __pyx_L1_error) __pyx_builtin_OverflowError = __Pyx_GetBuiltinName(__pyx_n_s_OverflowError); if (!__pyx_builtin_OverflowError) __PYX_ERR(1, 434, __pyx_L1_error) __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 692, __pyx_L1_error) __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(2, 97, __pyx_L1_error) __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(2, 107, __pyx_L1_error) __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_n_s_OSError); if (!__pyx_builtin_OSError) __PYX_ERR(2, 166, __pyx_L1_error) __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(2, 178, __pyx_L1_error) __pyx_builtin_open = __Pyx_GetBuiltinName(__pyx_n_s_open); if (!__pyx_builtin_open) __PYX_ERR(3, 1005, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self.req cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.req cannot be converted to a Python object for pickling") */ __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_self_req_cannot_be_converted_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple_); __Pyx_GIVEREF(__pyx_tuple_); /* "(tree fragment)":4 * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.req cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_self_req_cannot_be_converted_to); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); /* "src/handlers.pxi":35 * cdef void fuse_init (void *userdata, fuse_conn_info *conn): * if not conn.capable & FUSE_CAP_READDIRPLUS: * raise RuntimeError('Kernel too old, pyfuse3 requires kernel 3.9 or newer!') # <<<<<<<<<<<<<< * conn.want &= ~( FUSE_CAP_READDIRPLUS_AUTO) * */ __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_u_Kernel_too_old_pyfuse3_requires); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 35, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__3); __Pyx_GIVEREF(__pyx_tuple__3); /* "src/handlers.pxi":434 * * if size > PY_SSIZE_T_MAX: * raise OverflowError('Value too long to convert to Python') # <<<<<<<<<<<<<< * pbuf = PyBytes_FromStringAndSize(buf, size) * save_retval(fuse_write_async(c, pbuf)) */ __pyx_tuple__17 = PyTuple_Pack(1, __pyx_kp_u_Value_too_long_to_convert_to_Pyt); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 434, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__17); __Pyx_GIVEREF(__pyx_tuple__17); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("self.req cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.req cannot be converted to a Python object for pickling") */ __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_self_req_cannot_be_converted_to); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__24); __Pyx_GIVEREF(__pyx_tuple__24); /* "(tree fragment)":4 * raise TypeError("self.req cannot be converted to a Python object for pickling") * def __setstate_cython__(self, __pyx_state): * raise TypeError("self.req cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_self_req_cannot_be_converted_to); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__25); __Pyx_GIVEREF(__pyx_tuple__25); /* "src/internal.pxi":212 * try: * #log.debug('%s: Waiting for read lock...', name) * async with worker_data.read_lock: # <<<<<<<<<<<<<< * #log.debug('%s: Waiting for fuse fd to become readable...', name) * if fuse_session_exited(session): */ __pyx_tuple__38 = PyTuple_Pack(3, Py_None, Py_None, Py_None); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(2, 212, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__38); __Pyx_GIVEREF(__pyx_tuple__38); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__40); __Pyx_GIVEREF(__pyx_tuple__40); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__41); __Pyx_GIVEREF(__pyx_tuple__41); /* "pyfuse3.pyx":338 * def __getstate__(self): * state = dict() * for k in ('st_ino', 'generation', 'entry_timeout', 'attr_timeout', # <<<<<<<<<<<<<< * 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev', * 'st_size', 'st_blksize', 'st_blocks', 'st_atime_ns', */ __pyx_tuple__42 = PyTuple_Pack(16, __pyx_n_u_st_ino, __pyx_n_u_generation, __pyx_n_u_entry_timeout, __pyx_n_u_attr_timeout, __pyx_n_u_st_mode, __pyx_n_u_st_nlink, __pyx_n_u_st_uid, __pyx_n_u_st_gid, __pyx_n_u_st_rdev, __pyx_n_u_st_size, __pyx_n_u_st_blksize, __pyx_n_u_st_blocks, __pyx_n_u_st_atime_ns, __pyx_n_u_st_ctime_ns, __pyx_n_u_st_mtime_ns, __pyx_n_u_st_birthtime_ns); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(3, 338, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__42); __Pyx_GIVEREF(__pyx_tuple__42); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__43 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__43); __Pyx_GIVEREF(__pyx_tuple__43); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__44 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__44); __Pyx_GIVEREF(__pyx_tuple__44); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__45 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__45); __Pyx_GIVEREF(__pyx_tuple__45); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__46 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__46); __Pyx_GIVEREF(__pyx_tuple__46); /* "pyfuse3.pyx":469 * def __getstate__(self): * state = dict() * for k in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', # <<<<<<<<<<<<<< * 'f_bavail', 'f_files', 'f_ffree', 'f_favail', * 'f_namemax'): */ __pyx_tuple__47 = PyTuple_Pack(9, __pyx_n_u_f_bsize, __pyx_n_u_f_frsize, __pyx_n_u_f_blocks, __pyx_n_u_f_bfree, __pyx_n_u_f_bavail, __pyx_n_u_f_files, __pyx_n_u_f_ffree, __pyx_n_u_f_favail, __pyx_n_u_f_namemax); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(3, 469, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__47); __Pyx_GIVEREF(__pyx_tuple__47); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__48 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__48); __Pyx_GIVEREF(__pyx_tuple__48); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__49 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__49)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__49); __Pyx_GIVEREF(__pyx_tuple__49); /* "(tree fragment)":2 * def __reduce_cython__(self): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") */ __pyx_tuple__50 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 2, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__50); __Pyx_GIVEREF(__pyx_tuple__50); /* "(tree fragment)":4 * raise TypeError("no default __reduce__ due to non-trivial __cinit__") * def __setstate_cython__(self, __pyx_state): * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< */ __pyx_tuple__51 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(0, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__51); __Pyx_GIVEREF(__pyx_tuple__51); /* "pyfuse3.pyx":516 * * if not isinstance(path, str): * raise TypeError('*path* argument must be of type str') # <<<<<<<<<<<<<< * * cdef libc_extra.DIR* dirp */ __pyx_tuple__52 = PyTuple_Pack(1, __pyx_kp_u_path_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(3, 516, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__52); __Pyx_GIVEREF(__pyx_tuple__52); /* "pyfuse3.pyx":591 * * if not isinstance(name, str): * raise TypeError('*name* argument must be of type str') # <<<<<<<<<<<<<< * * if namespace not in ('system', 'user'): */ __pyx_tuple__53 = PyTuple_Pack(1, __pyx_kp_u_name_argument_must_be_of_type_s); if (unlikely(!__pyx_tuple__53)) __PYX_ERR(3, 591, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__53); __Pyx_GIVEREF(__pyx_tuple__53); /* "pyfuse3.pyx":733 * * if not isinstance(mountpoint, str): * raise TypeError('*mountpoint_* argument must be of type str') # <<<<<<<<<<<<<< * * global operations */ __pyx_tuple__55 = PyTuple_Pack(1, __pyx_kp_u_mountpoint__argument_must_be_of); if (unlikely(!__pyx_tuple__55)) __PYX_ERR(3, 733, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__55); __Pyx_GIVEREF(__pyx_tuple__55); /* "pyfuse3.pyx":752 * session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) * if not session: * raise RuntimeError("fuse_session_new() failed") # <<<<<<<<<<<<<< * * log.debug('Calling fuse_session_mount') */ __pyx_tuple__56 = PyTuple_Pack(1, __pyx_kp_u_fuse_session_new_failed); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(3, 752, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__56); __Pyx_GIVEREF(__pyx_tuple__56); /* "pyfuse3.pyx":757 * res = fuse_session_mount(session, mountpoint_b) * if res != 0: * raise RuntimeError('fuse_session_mount failed') # <<<<<<<<<<<<<< * * session_fd = fuse_session_fd(session) */ __pyx_tuple__57 = PyTuple_Pack(1, __pyx_kp_u_fuse_session_mount_failed); if (unlikely(!__pyx_tuple__57)) __PYX_ERR(3, 757, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__57); __Pyx_GIVEREF(__pyx_tuple__57); /* "pyfuse3.pyx":767 * * if session == NULL: * raise RuntimeError('Need to call init() before main()') # <<<<<<<<<<<<<< * * global trio_token */ __pyx_tuple__59 = PyTuple_Pack(1, __pyx_kp_u_Need_to_call_init_before_main); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(3, 767, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__59); __Pyx_GIVEREF(__pyx_tuple__59); /* "pyfuse3.pyx":1012 * raise RuntimeError("Unable to parse %s" % fh.name) * gids = set() * for x in line.split()[1:]: # <<<<<<<<<<<<<< * gids.add(int(x)) * */ __pyx_slice__60 = PySlice_New(__pyx_int_1, Py_None, Py_None); if (unlikely(!__pyx_slice__60)) __PYX_ERR(3, 1012, __pyx_L1_error) __Pyx_GOTREF(__pyx_slice__60); __Pyx_GIVEREF(__pyx_slice__60); /* "pyfuse3.pyx":81 * ################## * * log = logging.getLogger("pyfuse3") # <<<<<<<<<<<<<< * fse = sys.getfilesystemencoding() * */ __pyx_tuple__61 = PyTuple_Pack(1, __pyx_n_u_pyfuse3); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(3, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__61); __Pyx_GIVEREF(__pyx_tuple__61); /* "src/handlers.pxi":59 * save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) * * async def fuse_lookup_async (_Container c, name): # <<<<<<<<<<<<<< * cdef EntryAttributes entry * cdef int ret */ __pyx_tuple__62 = PyTuple_Pack(6, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_entry, __pyx_n_s_ret, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(1, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__62); __Pyx_GIVEREF(__pyx_tuple__62); __pyx_codeobj__4 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__62, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_lookup_async, 59, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__4)) __PYX_ERR(1, 59, __pyx_L1_error) /* "src/handlers.pxi":98 * save_retval(fuse_getattr_async(c)) * * async def fuse_getattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_tuple__63 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_entry, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__63)) __PYX_ERR(1, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__63); __Pyx_GIVEREF(__pyx_tuple__63); __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__63, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_getattr_async, 98, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(1, 98, __pyx_L1_error) /* "src/handlers.pxi":127 * save_retval(fuse_setattr_async(c, fh)) * * async def fuse_setattr_async (_Container c, fh): # <<<<<<<<<<<<<< * cdef int ret * cdef timespec now */ __pyx_tuple__64 = PyTuple_Pack(10, __pyx_n_s_c, __pyx_n_s_fh, __pyx_n_s_ret, __pyx_n_s_now, __pyx_n_s_entry, __pyx_n_s_fields, __pyx_n_s_attr, __pyx_n_s_to_set, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(1, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__64); __Pyx_GIVEREF(__pyx_tuple__64); __pyx_codeobj__6 = (PyObject*)__Pyx_PyCode_New(2, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__64, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_setattr_async, 127, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__6)) __PYX_ERR(1, 127, __pyx_L1_error) /* "src/handlers.pxi":184 * save_retval(fuse_readlink_async(c)) * * async def fuse_readlink_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ __pyx_tuple__65 = PyTuple_Pack(6, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_name, __pyx_n_s_ctx, __pyx_n_s_target, __pyx_n_s_e); if (unlikely(!__pyx_tuple__65)) __PYX_ERR(1, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__65); __Pyx_GIVEREF(__pyx_tuple__65); __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__65, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_readlink_async, 184, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(1, 184, __pyx_L1_error) /* "src/handlers.pxi":209 * save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) * * async def fuse_mknod_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_tuple__66 = PyTuple_Pack(6, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_ret, __pyx_n_s_entry, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(1, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__66); __Pyx_GIVEREF(__pyx_tuple__66); __pyx_codeobj__8 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__66, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_mknod_async, 209, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__8)) __PYX_ERR(1, 209, __pyx_L1_error) /* "src/handlers.pxi":234 * save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) * * async def fuse_mkdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_tuple__67 = PyTuple_Pack(6, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_ret, __pyx_n_s_entry, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__67)) __PYX_ERR(1, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__67); __Pyx_GIVEREF(__pyx_tuple__67); __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__67, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_mkdir_async, 234, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(1, 234, __pyx_L1_error) /* "src/handlers.pxi":260 * save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) * * async def fuse_unlink_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__68 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_ret, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(1, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__68); __Pyx_GIVEREF(__pyx_tuple__68); __pyx_codeobj__10 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__68, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_unlink_async, 260, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__10)) __PYX_ERR(1, 260, __pyx_L1_error) /* "src/handlers.pxi":281 * save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) * * async def fuse_rmdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__69 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_ret, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__69)) __PYX_ERR(1, 281, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__69); __Pyx_GIVEREF(__pyx_tuple__69); __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__69, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_rmdir_async, 281, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(1, 281, __pyx_L1_error) /* "src/handlers.pxi":304 * c, PyBytes_FromString(name), PyBytes_FromString(link))) * * async def fuse_symlink_async (_Container c, name, link): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_tuple__70 = PyTuple_Pack(7, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_link, __pyx_n_s_ret, __pyx_n_s_entry, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(1, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__70); __Pyx_GIVEREF(__pyx_tuple__70); __pyx_codeobj__12 = (PyObject*)__Pyx_PyCode_New(3, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__70, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_symlink_async, 304, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__12)) __PYX_ERR(1, 304, __pyx_L1_error) /* "src/handlers.pxi":332 * * * async def fuse_rename_async (_Container c, name, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef unsigned flags = c.flags */ __pyx_tuple__71 = PyTuple_Pack(8, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_newname, __pyx_n_s_ret, __pyx_n_s_flags, __pyx_n_s_newparent, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__71)) __PYX_ERR(1, 332, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__71); __Pyx_GIVEREF(__pyx_tuple__71); __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(3, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__71, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_rename_async, 332, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(1, 332, __pyx_L1_error) /* "src/handlers.pxi":357 * save_retval(fuse_link_async(c, PyBytes_FromString(newname))) * * async def fuse_link_async (_Container c, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_tuple__72 = PyTuple_Pack(6, __pyx_n_s_c, __pyx_n_s_newname, __pyx_n_s_ret, __pyx_n_s_entry, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(1, 357, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__72); __Pyx_GIVEREF(__pyx_tuple__72); __pyx_codeobj__14 = (PyObject*)__Pyx_PyCode_New(2, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__72, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_link_async, 357, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__14)) __PYX_ERR(1, 357, __pyx_L1_error) /* "src/handlers.pxi":381 * save_retval(fuse_open_async(c)) * * async def fuse_open_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef FileInfo fi */ __pyx_tuple__73 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_fi, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__73)) __PYX_ERR(1, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__73); __Pyx_GIVEREF(__pyx_tuple__73); __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__73, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_open_async, 381, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(1, 381, __pyx_L1_error) /* "src/handlers.pxi":408 * save_retval(fuse_read_async(c)) * * async def fuse_read_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef Py_buffer pybuf */ __pyx_tuple__74 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_pybuf, __pyx_n_s_buf, __pyx_n_s_e); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(1, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__74); __Pyx_GIVEREF(__pyx_tuple__74); __pyx_codeobj__16 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__74, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_read_async, 408, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__16)) __PYX_ERR(1, 408, __pyx_L1_error) /* "src/handlers.pxi":438 * save_retval(fuse_write_async(c, pbuf)) * * async def fuse_write_async (_Container c, pbuf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ __pyx_tuple__75 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_pbuf, __pyx_n_s_ret, __pyx_n_s_len, __pyx_n_s_e); if (unlikely(!__pyx_tuple__75)) __PYX_ERR(1, 438, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__75); __Pyx_GIVEREF(__pyx_tuple__75); __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__75, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_write_async, 438, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(1, 438, __pyx_L1_error) /* "src/handlers.pxi":462 * save_retval(fuse_write_buf_async(c, buf)) * * async def fuse_write_buf_async (_Container c, buf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ __pyx_tuple__76 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_buf, __pyx_n_s_ret, __pyx_n_s_len, __pyx_n_s_e); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(1, 462, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__76); __Pyx_GIVEREF(__pyx_tuple__76); __pyx_codeobj__19 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__76, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_write_buf_async, 462, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__19)) __PYX_ERR(1, 462, __pyx_L1_error) /* "src/handlers.pxi":483 * save_retval(fuse_flush_async(c)) * * async def fuse_flush_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__77 = PyTuple_Pack(3, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_e); if (unlikely(!__pyx_tuple__77)) __PYX_ERR(1, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__77); __Pyx_GIVEREF(__pyx_tuple__77); __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__77, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_flush_async, 483, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(1, 483, __pyx_L1_error) /* "src/handlers.pxi":503 * save_retval(fuse_release_async(c)) * * async def fuse_release_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__78 = PyTuple_Pack(3, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_e); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__78); __Pyx_GIVEREF(__pyx_tuple__78); __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__78, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_release_async, 503, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(1, 503, __pyx_L1_error) /* "src/handlers.pxi":525 * save_retval(fuse_fsync_async(c)) * * async def fuse_fsync_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__79 = PyTuple_Pack(3, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_e); if (unlikely(!__pyx_tuple__79)) __PYX_ERR(1, 525, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__79); __Pyx_GIVEREF(__pyx_tuple__79); __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__79, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_fsync_async, 525, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(1, 525, __pyx_L1_error) /* "src/handlers.pxi":546 * save_retval(fuse_opendir_async(c)) * * async def fuse_opendir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__80 = PyTuple_Pack(4, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__80)) __PYX_ERR(1, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__80); __Pyx_GIVEREF(__pyx_tuple__80); __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__80, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_opendir_async, 546, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(1, 546, __pyx_L1_error) /* "src/handlers.pxi":578 * save_retval(fuse_readdirplus_async(c)) * * async def fuse_readdirplus_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ReaddirToken token = ReaddirToken() */ __pyx_tuple__81 = PyTuple_Pack(4, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_token, __pyx_n_s_e); if (unlikely(!__pyx_tuple__81)) __PYX_ERR(1, 578, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__81); __Pyx_GIVEREF(__pyx_tuple__81); __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(1, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__81, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_readdirplus_async, 578, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(1, 578, __pyx_L1_error) /* "src/handlers.pxi":607 * save_retval(fuse_releasedir_async(c)) * * async def fuse_releasedir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__82 = PyTuple_Pack(3, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_e); if (unlikely(!__pyx_tuple__82)) __PYX_ERR(1, 607, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__82); __Pyx_GIVEREF(__pyx_tuple__82); __pyx_codeobj__27 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__82, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_releasedir_async, 607, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__27)) __PYX_ERR(1, 607, __pyx_L1_error) /* "src/handlers.pxi":630 * save_retval(fuse_fsyncdir_async(c)) * * async def fuse_fsyncdir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__83 = PyTuple_Pack(3, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_e); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(1, 630, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__83); __Pyx_GIVEREF(__pyx_tuple__83); __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__83, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_fsyncdir_async, 630, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(1, 630, __pyx_L1_error) /* "src/handlers.pxi":650 * save_retval(fuse_statfs_async(c)) * * async def fuse_statfs_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef StatvfsData stats */ __pyx_tuple__84 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_stats, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__84)) __PYX_ERR(1, 650, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__84); __Pyx_GIVEREF(__pyx_tuple__84); __pyx_codeobj__29 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__84, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_statfs_async, 650, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__29)) __PYX_ERR(1, 650, __pyx_L1_error) /* "src/handlers.pxi":681 * save_retval(fuse_setxattr_async(c, name, value)) * * async def fuse_setxattr_async (_Container c, name, value): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__85 = PyTuple_Pack(6, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_ret, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__85); __Pyx_GIVEREF(__pyx_tuple__85); __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(3, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__85, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_setxattr_async, 681, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(1, 681, __pyx_L1_error) /* "src/handlers.pxi":726 * save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) * * async def fuse_getxattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ __pyx_tuple__86 = PyTuple_Pack(9, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_ret, __pyx_n_s_len_s, __pyx_n_s_len, __pyx_n_s_cbuf, __pyx_n_s_ctx, __pyx_n_s_buf, __pyx_n_s_e); if (unlikely(!__pyx_tuple__86)) __PYX_ERR(1, 726, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__86); __Pyx_GIVEREF(__pyx_tuple__86); __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(2, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__86, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_getxattr_async, 726, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __PYX_ERR(1, 726, __pyx_L1_error) /* "src/handlers.pxi":759 * save_retval(fuse_listxattr_async(c)) * * async def fuse_listxattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ __pyx_tuple__87 = PyTuple_Pack(9, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_len_s, __pyx_n_s_len, __pyx_n_s_cbuf, __pyx_n_s_ctx, __pyx_n_s_res, __pyx_n_s_e, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__87)) __PYX_ERR(1, 759, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__87); __Pyx_GIVEREF(__pyx_tuple__87); __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(1, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__87, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_listxattr_async, 759, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(1, 759, __pyx_L1_error) /* "src/handlers.pxi":797 * save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) * * async def fuse_removexattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_tuple__88 = PyTuple_Pack(5, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_ret, __pyx_n_s_ctx, __pyx_n_s_e); if (unlikely(!__pyx_tuple__88)) __PYX_ERR(1, 797, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__88); __Pyx_GIVEREF(__pyx_tuple__88); __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__88, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_removexattr_async, 797, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(1, 797, __pyx_L1_error) /* "src/handlers.pxi":819 * save_retval(fuse_access_async(c)) * * async def fuse_access_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef int mask = c.flags */ __pyx_tuple__89 = PyTuple_Pack(6, __pyx_n_s_c, __pyx_n_s_ret, __pyx_n_s_mask, __pyx_n_s_ctx, __pyx_n_s_allowed, __pyx_n_s_e); if (unlikely(!__pyx_tuple__89)) __PYX_ERR(1, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__89); __Pyx_GIVEREF(__pyx_tuple__89); __pyx_codeobj__35 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__89, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_access_async, 819, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__35)) __PYX_ERR(1, 819, __pyx_L1_error) /* "src/handlers.pxi":848 * save_retval(fuse_create_async(c, PyBytes_FromString(name))) * * async def fuse_create_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_tuple__90 = PyTuple_Pack(8, __pyx_n_s_c, __pyx_n_s_name, __pyx_n_s_ret, __pyx_n_s_entry, __pyx_n_s_fi, __pyx_n_s_ctx, __pyx_n_s_tmp, __pyx_n_s_e); if (unlikely(!__pyx_tuple__90)) __PYX_ERR(1, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__90); __Pyx_GIVEREF(__pyx_tuple__90); __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(2, 0, 8, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__90, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_handlers_pxi, __pyx_n_s_fuse_create_async, 848, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(1, 848, __pyx_L1_error) /* "src/internal.pxi":114 * raise * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Process async invalidate_entry calls.''' * */ __pyx_tuple__91 = PyTuple_Pack(6, __pyx_n_s_req, __pyx_n_s_inode_p, __pyx_n_s_name, __pyx_n_s_deleted, __pyx_n_s_ignore_enoent, __pyx_n_s_exc); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(2, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__91); __Pyx_GIVEREF(__pyx_tuple__91); __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__91, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_internal_pxi, __pyx_n_s_notify_loop, 114, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) __PYX_ERR(2, 114, __pyx_L1_error) /* "src/internal.pxi":201 * cdef _WorkerData worker_data * * async def _wait_fuse_readable(): # <<<<<<<<<<<<<< * '''Wait for FUSE fd to become readable * */ __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_internal_pxi, __pyx_n_s_wait_fuse_readable, 201, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(2, 201, __pyx_L1_error) /* "src/internal.pxi":230 * * @async_wrapper * async def _session_loop(nursery, int min_tasks, int max_tasks): # <<<<<<<<<<<<<< * cdef int res * cdef fuse_buf buf */ __pyx_tuple__93 = PyTuple_Pack(6, __pyx_n_s_nursery, __pyx_n_s_min_tasks, __pyx_n_s_max_tasks, __pyx_n_s_res, __pyx_n_s_buf, __pyx_n_s_name); if (unlikely(!__pyx_tuple__93)) __PYX_ERR(2, 230, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__93); __Pyx_GIVEREF(__pyx_tuple__93); __pyx_codeobj__39 = (PyObject*)__Pyx_PyCode_New(3, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__93, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_internal_pxi, __pyx_n_s_session_loop, 230, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__39)) __PYX_ERR(2, 230, __pyx_L1_error) /* "pyfuse3.pyx":505 * return strerror(self.errno_) * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ __pyx_tuple__94 = PyTuple_Pack(6, __pyx_n_s_path, __pyx_n_s_dirp, __pyx_n_s_res, __pyx_n_s_buf, __pyx_n_s_path_b, __pyx_n_s_names); if (unlikely(!__pyx_tuple__94)) __PYX_ERR(3, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__94); __Pyx_GIVEREF(__pyx_tuple__94); __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(1, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__94, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_listdir, 505, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) __PYX_ERR(3, 505, __pyx_L1_error) /* "pyfuse3.pyx":554 * * * def syncfs(path): # <<<<<<<<<<<<<< * '''Sync filesystem mounted at *path* * */ __pyx_tuple__96 = PyTuple_Pack(3, __pyx_n_s_path, __pyx_n_s_ret, __pyx_n_s_fd); if (unlikely(!__pyx_tuple__96)) __PYX_ERR(3, 554, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__96); __Pyx_GIVEREF(__pyx_tuple__96); __pyx_codeobj__97 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__96, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_syncfs, 554, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__97)) __PYX_ERR(3, 554, __pyx_L1_error) /* "pyfuse3.pyx":573 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ __pyx_tuple__98 = PyTuple_Pack(12, __pyx_n_s_path, __pyx_n_s_name, __pyx_n_s_value, __pyx_n_s_namespace, __pyx_n_s_ret, __pyx_n_s_len, __pyx_n_s_cvalue, __pyx_n_s_cpath, __pyx_n_s_cname, __pyx_n_s_cnamespace, __pyx_n_s_path_b, __pyx_n_s_name_b); if (unlikely(!__pyx_tuple__98)) __PYX_ERR(3, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__98); __Pyx_GIVEREF(__pyx_tuple__98); __pyx_codeobj__99 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__98, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_setxattr, 573, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__99)) __PYX_ERR(3, 573, __pyx_L1_error) /* "pyfuse3.pyx":624 * * * def getxattr(path, name, size_t size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ __pyx_tuple__100 = PyTuple_Pack(12, __pyx_n_s_path, __pyx_n_s_name, __pyx_n_s_size_guess, __pyx_n_s_namespace, __pyx_n_s_ret, __pyx_n_s_buf, __pyx_n_s_cpath, __pyx_n_s_cname, __pyx_n_s_bufsize, __pyx_n_s_cnamespace, __pyx_n_s_path_b, __pyx_n_s_name_b); if (unlikely(!__pyx_tuple__100)) __PYX_ERR(3, 624, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__100); __Pyx_GIVEREF(__pyx_tuple__100); __pyx_codeobj__101 = (PyObject*)__Pyx_PyCode_New(4, 0, 12, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__100, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_getxattr, 624, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__101)) __PYX_ERR(3, 624, __pyx_L1_error) /* "pyfuse3.pyx":704 * * * default_options = frozenset(('default_permissions',)) # <<<<<<<<<<<<<< * * def init(ops, mountpoint, options=default_options): */ __pyx_tuple__102 = PyTuple_Pack(1, __pyx_n_u_default_permissions); if (unlikely(!__pyx_tuple__102)) __PYX_ERR(3, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__102); __Pyx_GIVEREF(__pyx_tuple__102); /* "pyfuse3.pyx":706 * default_options = frozenset(('default_permissions',)) * * def init(ops, mountpoint, options=default_options): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ __pyx_tuple__103 = PyTuple_Pack(5, __pyx_n_s_ops, __pyx_n_s_mountpoint, __pyx_n_s_options, __pyx_n_s_f_args, __pyx_n_s_res); if (unlikely(!__pyx_tuple__103)) __PYX_ERR(3, 706, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__103); __Pyx_GIVEREF(__pyx_tuple__103); __pyx_codeobj__104 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__103, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_init, 706, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__104)) __PYX_ERR(3, 706, __pyx_L1_error) /* "pyfuse3.pyx":763 * * @async_wrapper * async def main(int min_tasks=1, int max_tasks=99): # <<<<<<<<<<<<<< * '''Run FUSE main loop''' * */ __pyx_tuple__105 = PyTuple_Pack(3, __pyx_n_s_min_tasks, __pyx_n_s_max_tasks, __pyx_n_s_nursery); if (unlikely(!__pyx_tuple__105)) __PYX_ERR(3, 763, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__105); __Pyx_GIVEREF(__pyx_tuple__105); __pyx_codeobj__58 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__105, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_main, 763, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__58)) __PYX_ERR(3, 763, __pyx_L1_error) /* "pyfuse3.pyx":784 * * * def terminate(): # <<<<<<<<<<<<<< * '''Terminate FUSE main loop. * */ __pyx_codeobj__106 = (PyObject*)__Pyx_PyCode_New(0, 0, 0, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_terminate, 784, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__106)) __PYX_ERR(3, 784, __pyx_L1_error) /* "pyfuse3.pyx":799 * * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Clean up and ensure filesystem is unmounted * */ __pyx_tuple__107 = PyTuple_Pack(1, __pyx_n_s_unmount); if (unlikely(!__pyx_tuple__107)) __PYX_ERR(3, 799, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__107); __Pyx_GIVEREF(__pyx_tuple__107); __pyx_codeobj__108 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__107, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_close, 799, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__108)) __PYX_ERR(3, 799, __pyx_L1_error) /* "pyfuse3.pyx":831 * session = NULL * * def invalidate_inode(fuse_ino_t inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ __pyx_tuple__109 = PyTuple_Pack(3, __pyx_n_s_inode, __pyx_n_s_attr_only, __pyx_n_s_ret); if (unlikely(!__pyx_tuple__109)) __PYX_ERR(3, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__109); __Pyx_GIVEREF(__pyx_tuple__109); __pyx_codeobj__110 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__109, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_invalidate_inode, 831, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__110)) __PYX_ERR(3, 831, __pyx_L1_error) /* "pyfuse3.pyx":860 * * * def invalidate_entry(fuse_ino_t inode_p, bytes name, fuse_ino_t deleted=0): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ __pyx_tuple__111 = PyTuple_Pack(7, __pyx_n_s_inode_p, __pyx_n_s_name, __pyx_n_s_deleted, __pyx_n_s_cname, __pyx_n_s_slen, __pyx_n_s_len, __pyx_n_s_ret); if (unlikely(!__pyx_tuple__111)) __PYX_ERR(3, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__111); __Pyx_GIVEREF(__pyx_tuple__111); __pyx_codeobj__112 = (PyObject*)__Pyx_PyCode_New(3, 0, 7, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__111, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_invalidate_entry, 860, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__112)) __PYX_ERR(3, 860, __pyx_L1_error) /* "pyfuse3.pyx":916 * * * def invalidate_entry_async(inode_p, name, deleted=0, ignore_enoent=False): # <<<<<<<<<<<<<< * '''Asynchronously invalidate directory entry * */ __pyx_tuple__113 = PyTuple_Pack(5, __pyx_n_s_inode_p, __pyx_n_s_name, __pyx_n_s_deleted, __pyx_n_s_ignore_enoent, __pyx_n_s_t); if (unlikely(!__pyx_tuple__113)) __PYX_ERR(3, 916, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__113); __Pyx_GIVEREF(__pyx_tuple__113); __pyx_codeobj__114 = (PyObject*)__Pyx_PyCode_New(4, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__113, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_invalidate_entry_async, 916, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__114)) __PYX_ERR(3, 916, __pyx_L1_error) /* "pyfuse3.pyx":952 * * * def notify_store(inode, offset, data): # <<<<<<<<<<<<<< * '''Store data in kernel page cache * */ __pyx_tuple__115 = PyTuple_Pack(9, __pyx_n_s_inode, __pyx_n_s_offset, __pyx_n_s_data, __pyx_n_s_ret, __pyx_n_s_ino, __pyx_n_s_off, __pyx_n_s_pybuf, __pyx_n_s_bufvec, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__115)) __PYX_ERR(3, 952, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__115); __Pyx_GIVEREF(__pyx_tuple__115); __pyx_codeobj__116 = (PyObject*)__Pyx_PyCode_New(3, 0, 9, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__115, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_notify_store, 952, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__116)) __PYX_ERR(3, 952, __pyx_L1_error) /* "pyfuse3.pyx":995 * raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) * * def get_sup_groups(pid): # <<<<<<<<<<<<<< * '''Return supplementary group ids of *pid* * */ __pyx_tuple__117 = PyTuple_Pack(5, __pyx_n_s_pid, __pyx_n_s_fh, __pyx_n_s_line, __pyx_n_s_gids, __pyx_n_s_x); if (unlikely(!__pyx_tuple__117)) __PYX_ERR(3, 995, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__117); __Pyx_GIVEREF(__pyx_tuple__117); __pyx_codeobj__118 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__117, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_get_sup_groups, 995, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__118)) __PYX_ERR(3, 995, __pyx_L1_error) /* "pyfuse3.pyx":1018 * * * def readdir_reply(ReaddirToken token, name, EntryAttributes attr, off_t next_id): # <<<<<<<<<<<<<< * '''Report a directory entry in response to a `~Operations.readdir` request. * */ __pyx_tuple__119 = PyTuple_Pack(6, __pyx_n_s_token, __pyx_n_s_name, __pyx_n_s_attr, __pyx_n_s_next_id, __pyx_n_s_cname, __pyx_n_s_len); if (unlikely(!__pyx_tuple__119)) __PYX_ERR(3, 1018, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__119); __Pyx_GIVEREF(__pyx_tuple__119); __pyx_codeobj__120 = (PyObject*)__Pyx_PyCode_New(4, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__119, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_src_pyfuse3_pyx, __pyx_n_s_readdir_reply, 1018, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__120)) __PYX_ERR(3, 1018, __pyx_L1_error) /* "(tree fragment)":1 * def __pyx_unpickle__WorkerData(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_tuple__121 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__121)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__121); __Pyx_GIVEREF(__pyx_tuple__121); __pyx_codeobj__122 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__121, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle__WorkerData, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__122)) __PYX_ERR(0, 1, __pyx_L1_error) __pyx_tuple__123 = PyTuple_Pack(5, __pyx_n_s_pyx_type, __pyx_n_s_pyx_checksum, __pyx_n_s_pyx_state, __pyx_n_s_pyx_PickleError, __pyx_n_s_pyx_result); if (unlikely(!__pyx_tuple__123)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__123); __Pyx_GIVEREF(__pyx_tuple__123); __pyx_codeobj__124 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__123, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_RequestContext, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__124)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(3, 1, __pyx_L1_error); __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(3, 1, __pyx_L1_error) __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(3, 1, __pyx_L1_error) __pyx_int_35895208 = PyInt_FromLong(35895208L); if (unlikely(!__pyx_int_35895208)) __PYX_ERR(3, 1, __pyx_L1_error) __pyx_int_244161614 = PyInt_FromLong(244161614L); if (unlikely(!__pyx_int_244161614)) __PYX_ERR(3, 1, __pyx_L1_error) __pyx_int_1000000000 = PyInt_FromLong(1000000000L); if (unlikely(!__pyx_int_1000000000)) __PYX_ERR(3, 1, __pyx_L1_error) return 0; __pyx_L1_error:; return -1; } static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ static int __Pyx_modinit_global_init_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); /*--- Global init code ---*/ __pyx_v_7pyfuse3_operations = Py_None; Py_INCREF(Py_None); __pyx_v_7pyfuse3_mountpoint_b = Py_None; Py_INCREF(Py_None); __pyx_v_7pyfuse3_py_retval = Py_None; Py_INCREF(Py_None); __pyx_v_7pyfuse3__notify_queue = Py_None; Py_INCREF(Py_None); __pyx_v_7pyfuse3_worker_data = ((struct __pyx_obj_7pyfuse3__WorkerData *)Py_None); Py_INCREF(Py_None); __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_variable_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); /*--- Variable export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_export_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); /*--- Function export code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_type_init_code(void) { __Pyx_RefNannyDeclarations int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); /*--- Type init code ---*/ if (PyType_Ready(&__pyx_type_7pyfuse3__Container) < 0) __PYX_ERR(1, 14, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3__Container.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3__Container.tp_dictoffset && __pyx_type_7pyfuse3__Container.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3__Container.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_Container, (PyObject *)&__pyx_type_7pyfuse3__Container) < 0) __PYX_ERR(1, 14, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3__Container) < 0) __PYX_ERR(1, 14, __pyx_L1_error) __pyx_ptype_7pyfuse3__Container = &__pyx_type_7pyfuse3__Container; if (PyType_Ready(&__pyx_type_7pyfuse3_ReaddirToken) < 0) __PYX_ERR(1, 562, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3_ReaddirToken.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3_ReaddirToken.tp_dictoffset && __pyx_type_7pyfuse3_ReaddirToken.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3_ReaddirToken.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ReaddirToken, (PyObject *)&__pyx_type_7pyfuse3_ReaddirToken) < 0) __PYX_ERR(1, 562, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3_ReaddirToken) < 0) __PYX_ERR(1, 562, __pyx_L1_error) __pyx_ptype_7pyfuse3_ReaddirToken = &__pyx_type_7pyfuse3_ReaddirToken; __pyx_vtabptr_7pyfuse3__WorkerData = &__pyx_vtable_7pyfuse3__WorkerData; __pyx_vtable_7pyfuse3__WorkerData.get_name = (PyObject *(*)(struct __pyx_obj_7pyfuse3__WorkerData *))__pyx_f_7pyfuse3_11_WorkerData_get_name; if (PyType_Ready(&__pyx_type_7pyfuse3__WorkerData) < 0) __PYX_ERR(2, 181, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3__WorkerData.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3__WorkerData.tp_dictoffset && __pyx_type_7pyfuse3__WorkerData.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3__WorkerData.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_7pyfuse3__WorkerData.tp_dict, __pyx_vtabptr_7pyfuse3__WorkerData) < 0) __PYX_ERR(2, 181, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_WorkerData, (PyObject *)&__pyx_type_7pyfuse3__WorkerData) < 0) __PYX_ERR(2, 181, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3__WorkerData) < 0) __PYX_ERR(2, 181, __pyx_L1_error) __pyx_ptype_7pyfuse3__WorkerData = &__pyx_type_7pyfuse3__WorkerData; if (PyType_Ready(&__pyx_type_7pyfuse3_RequestContext) < 0) __PYX_ERR(3, 127, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3_RequestContext.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3_RequestContext.tp_dictoffset && __pyx_type_7pyfuse3_RequestContext.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3_RequestContext.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_RequestContext, (PyObject *)&__pyx_type_7pyfuse3_RequestContext) < 0) __PYX_ERR(3, 127, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3_RequestContext) < 0) __PYX_ERR(3, 127, __pyx_L1_error) __pyx_ptype_7pyfuse3_RequestContext = &__pyx_type_7pyfuse3_RequestContext; if (PyType_Ready(&__pyx_type_7pyfuse3_SetattrFields) < 0) __PYX_ERR(3, 144, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3_SetattrFields.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3_SetattrFields.tp_dictoffset && __pyx_type_7pyfuse3_SetattrFields.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3_SetattrFields.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_SetattrFields, (PyObject *)&__pyx_type_7pyfuse3_SetattrFields) < 0) __PYX_ERR(3, 144, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3_SetattrFields) < 0) __PYX_ERR(3, 144, __pyx_L1_error) __pyx_ptype_7pyfuse3_SetattrFields = &__pyx_type_7pyfuse3_SetattrFields; if (PyType_Ready(&__pyx_type_7pyfuse3_EntryAttributes) < 0) __PYX_ERR(3, 171, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3_EntryAttributes.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3_EntryAttributes.tp_dictoffset && __pyx_type_7pyfuse3_EntryAttributes.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3_EntryAttributes.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_EntryAttributes, (PyObject *)&__pyx_type_7pyfuse3_EntryAttributes) < 0) __PYX_ERR(3, 171, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3_EntryAttributes) < 0) __PYX_ERR(3, 171, __pyx_L1_error) __pyx_ptype_7pyfuse3_EntryAttributes = &__pyx_type_7pyfuse3_EntryAttributes; __pyx_vtabptr_7pyfuse3_FileInfo = &__pyx_vtable_7pyfuse3_FileInfo; __pyx_vtable_7pyfuse3_FileInfo._copy_to_fuse = (PyObject *(*)(struct __pyx_obj_7pyfuse3_FileInfo *, struct fuse_file_info *))__pyx_f_7pyfuse3_8FileInfo__copy_to_fuse; if (PyType_Ready(&__pyx_type_7pyfuse3_FileInfo) < 0) __PYX_ERR(3, 351, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3_FileInfo.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3_FileInfo.tp_dictoffset && __pyx_type_7pyfuse3_FileInfo.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3_FileInfo.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (__Pyx_SetVtable(__pyx_type_7pyfuse3_FileInfo.tp_dict, __pyx_vtabptr_7pyfuse3_FileInfo) < 0) __PYX_ERR(3, 351, __pyx_L1_error) if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FileInfo, (PyObject *)&__pyx_type_7pyfuse3_FileInfo) < 0) __PYX_ERR(3, 351, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3_FileInfo) < 0) __PYX_ERR(3, 351, __pyx_L1_error) __pyx_ptype_7pyfuse3_FileInfo = &__pyx_type_7pyfuse3_FileInfo; if (PyType_Ready(&__pyx_type_7pyfuse3_StatvfsData) < 0) __PYX_ERR(3, 391, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3_StatvfsData.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3_StatvfsData.tp_dictoffset && __pyx_type_7pyfuse3_StatvfsData.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3_StatvfsData.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_StatvfsData, (PyObject *)&__pyx_type_7pyfuse3_StatvfsData) < 0) __PYX_ERR(3, 391, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3_StatvfsData) < 0) __PYX_ERR(3, 391, __pyx_L1_error) __pyx_ptype_7pyfuse3_StatvfsData = &__pyx_type_7pyfuse3_StatvfsData; __pyx_type_7pyfuse3_FUSEError.tp_base = (&((PyTypeObject*)PyExc_Exception)[0]); if (PyType_Ready(&__pyx_type_7pyfuse3_FUSEError) < 0) __PYX_ERR(3, 481, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3_FUSEError.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3_FUSEError.tp_dictoffset && __pyx_type_7pyfuse3_FUSEError.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3_FUSEError.tp_getattro = __Pyx_PyObject_GenericGetAttr; } if (PyObject_SetAttr(__pyx_m, __pyx_n_s_FUSEError, (PyObject *)&__pyx_type_7pyfuse3_FUSEError) < 0) __PYX_ERR(3, 481, __pyx_L1_error) if (__Pyx_setup_reduce((PyObject*)&__pyx_type_7pyfuse3_FUSEError) < 0) __PYX_ERR(3, 481, __pyx_L1_error) __pyx_ptype_7pyfuse3_FUSEError = &__pyx_type_7pyfuse3_FUSEError; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct__fuse_lookup_async) < 0) __PYX_ERR(1, 59, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct__fuse_lookup_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct__fuse_lookup_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct__fuse_lookup_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct__fuse_lookup_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct__fuse_lookup_async = &__pyx_type_7pyfuse3___pyx_scope_struct__fuse_lookup_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async) < 0) __PYX_ERR(1, 98, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async = &__pyx_type_7pyfuse3___pyx_scope_struct_1_fuse_getattr_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async) < 0) __PYX_ERR(1, 127, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async = &__pyx_type_7pyfuse3___pyx_scope_struct_2_fuse_setattr_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async) < 0) __PYX_ERR(1, 184, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async = &__pyx_type_7pyfuse3___pyx_scope_struct_3_fuse_readlink_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async) < 0) __PYX_ERR(1, 209, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async = &__pyx_type_7pyfuse3___pyx_scope_struct_4_fuse_mknod_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async) < 0) __PYX_ERR(1, 234, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async = &__pyx_type_7pyfuse3___pyx_scope_struct_5_fuse_mkdir_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async) < 0) __PYX_ERR(1, 260, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async = &__pyx_type_7pyfuse3___pyx_scope_struct_6_fuse_unlink_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async) < 0) __PYX_ERR(1, 281, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async = &__pyx_type_7pyfuse3___pyx_scope_struct_7_fuse_rmdir_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async) < 0) __PYX_ERR(1, 304, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async = &__pyx_type_7pyfuse3___pyx_scope_struct_8_fuse_symlink_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_9_fuse_rename_async) < 0) __PYX_ERR(1, 332, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_9_fuse_rename_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_9_fuse_rename_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_9_fuse_rename_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_9_fuse_rename_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_9_fuse_rename_async = &__pyx_type_7pyfuse3___pyx_scope_struct_9_fuse_rename_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_10_fuse_link_async) < 0) __PYX_ERR(1, 357, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_10_fuse_link_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_10_fuse_link_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_10_fuse_link_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_10_fuse_link_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_10_fuse_link_async = &__pyx_type_7pyfuse3___pyx_scope_struct_10_fuse_link_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_11_fuse_open_async) < 0) __PYX_ERR(1, 381, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_11_fuse_open_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_11_fuse_open_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_11_fuse_open_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_11_fuse_open_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_11_fuse_open_async = &__pyx_type_7pyfuse3___pyx_scope_struct_11_fuse_open_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_12_fuse_read_async) < 0) __PYX_ERR(1, 408, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_12_fuse_read_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_12_fuse_read_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_12_fuse_read_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_12_fuse_read_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_12_fuse_read_async = &__pyx_type_7pyfuse3___pyx_scope_struct_12_fuse_read_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_13_fuse_write_async) < 0) __PYX_ERR(1, 438, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_13_fuse_write_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_13_fuse_write_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_13_fuse_write_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_13_fuse_write_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_13_fuse_write_async = &__pyx_type_7pyfuse3___pyx_scope_struct_13_fuse_write_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async) < 0) __PYX_ERR(1, 462, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async = &__pyx_type_7pyfuse3___pyx_scope_struct_14_fuse_write_buf_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_15_fuse_flush_async) < 0) __PYX_ERR(1, 483, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_15_fuse_flush_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_15_fuse_flush_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_15_fuse_flush_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_15_fuse_flush_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_15_fuse_flush_async = &__pyx_type_7pyfuse3___pyx_scope_struct_15_fuse_flush_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_16_fuse_release_async) < 0) __PYX_ERR(1, 503, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_16_fuse_release_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_16_fuse_release_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_16_fuse_release_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_16_fuse_release_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_16_fuse_release_async = &__pyx_type_7pyfuse3___pyx_scope_struct_16_fuse_release_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async) < 0) __PYX_ERR(1, 525, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async = &__pyx_type_7pyfuse3___pyx_scope_struct_17_fuse_fsync_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async) < 0) __PYX_ERR(1, 546, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async = &__pyx_type_7pyfuse3___pyx_scope_struct_18_fuse_opendir_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async) < 0) __PYX_ERR(1, 578, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async = &__pyx_type_7pyfuse3___pyx_scope_struct_19_fuse_readdirplus_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async) < 0) __PYX_ERR(1, 607, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async = &__pyx_type_7pyfuse3___pyx_scope_struct_20_fuse_releasedir_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async) < 0) __PYX_ERR(1, 630, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async = &__pyx_type_7pyfuse3___pyx_scope_struct_21_fuse_fsyncdir_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async) < 0) __PYX_ERR(1, 650, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async = &__pyx_type_7pyfuse3___pyx_scope_struct_22_fuse_statfs_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async) < 0) __PYX_ERR(1, 681, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async = &__pyx_type_7pyfuse3___pyx_scope_struct_23_fuse_setxattr_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async) < 0) __PYX_ERR(1, 726, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async = &__pyx_type_7pyfuse3___pyx_scope_struct_24_fuse_getxattr_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async) < 0) __PYX_ERR(1, 759, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async = &__pyx_type_7pyfuse3___pyx_scope_struct_25_fuse_listxattr_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async) < 0) __PYX_ERR(1, 797, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async = &__pyx_type_7pyfuse3___pyx_scope_struct_26_fuse_removexattr_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_27_fuse_access_async) < 0) __PYX_ERR(1, 819, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_27_fuse_access_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_27_fuse_access_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_27_fuse_access_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_27_fuse_access_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_27_fuse_access_async = &__pyx_type_7pyfuse3___pyx_scope_struct_27_fuse_access_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_28_fuse_create_async) < 0) __PYX_ERR(1, 848, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_28_fuse_create_async.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_28_fuse_create_async.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_28_fuse_create_async.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_28_fuse_create_async.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_28_fuse_create_async = &__pyx_type_7pyfuse3___pyx_scope_struct_28_fuse_create_async; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable) < 0) __PYX_ERR(2, 201, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable = &__pyx_type_7pyfuse3___pyx_scope_struct_29__wait_fuse_readable; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_30__session_loop) < 0) __PYX_ERR(2, 230, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_30__session_loop.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_30__session_loop.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_30__session_loop.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_30__session_loop.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_30__session_loop = &__pyx_type_7pyfuse3___pyx_scope_struct_30__session_loop; if (PyType_Ready(&__pyx_type_7pyfuse3___pyx_scope_struct_31_main) < 0) __PYX_ERR(3, 763, __pyx_L1_error) #if PY_VERSION_HEX < 0x030800B1 __pyx_type_7pyfuse3___pyx_scope_struct_31_main.tp_print = 0; #endif if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_7pyfuse3___pyx_scope_struct_31_main.tp_dictoffset && __pyx_type_7pyfuse3___pyx_scope_struct_31_main.tp_getattro == PyObject_GenericGetAttr)) { __pyx_type_7pyfuse3___pyx_scope_struct_31_main.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; } __pyx_ptype_7pyfuse3___pyx_scope_struct_31_main = &__pyx_type_7pyfuse3___pyx_scope_struct_31_main; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_type_import_code(void) { __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); /*--- Type import code ---*/ __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(4, 9, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __pyx_ptype_7cpython_4type_type = __Pyx_ImportType(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 sizeof(PyTypeObject), #else sizeof(PyHeapTypeObject), #endif __Pyx_ImportType_CheckSize_Warn); if (!__pyx_ptype_7cpython_4type_type) __PYX_ERR(4, 9, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_RefNannyFinishContext(); return 0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_RefNannyFinishContext(); return -1; } static int __Pyx_modinit_variable_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); /*--- Variable import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } static int __Pyx_modinit_function_import_code(void) { __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); /*--- Function import code ---*/ __Pyx_RefNannyFinishContext(); return 0; } #ifndef CYTHON_NO_PYINIT_EXPORT #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC #elif PY_MAJOR_VERSION < 3 #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" void #else #define __Pyx_PyMODINIT_FUNC void #endif #else #ifdef __cplusplus #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * #else #define __Pyx_PyMODINIT_FUNC PyObject * #endif #endif #if PY_MAJOR_VERSION < 3 __Pyx_PyMODINIT_FUNC initpyfuse3(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC initpyfuse3(void) #else __Pyx_PyMODINIT_FUNC PyInit_pyfuse3(void) CYTHON_SMALL_CODE; /*proto*/ __Pyx_PyMODINIT_FUNC PyInit_pyfuse3(void) #if CYTHON_PEP489_MULTI_PHASE_INIT { return PyModuleDef_Init(&__pyx_moduledef); } static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { #if PY_VERSION_HEX >= 0x030700A1 static PY_INT64_T main_interpreter_id = -1; PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); if (main_interpreter_id == -1) { main_interpreter_id = current_id; return (unlikely(current_id == -1)) ? -1 : 0; } else if (unlikely(main_interpreter_id != current_id)) #else static PyInterpreterState *main_interpreter = NULL; PyInterpreterState *current_interpreter = PyThreadState_Get()->interp; if (!main_interpreter) { main_interpreter = current_interpreter; } else if (unlikely(main_interpreter != current_interpreter)) #endif { PyErr_SetString( PyExc_ImportError, "Interpreter change detected - this module can only be loaded into one interpreter per process."); return -1; } return 0; } static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) { PyObject *value = PyObject_GetAttrString(spec, from_name); int result = 0; if (likely(value)) { if (allow_none || value != Py_None) { result = PyDict_SetItemString(moddict, to_name, value); } Py_DECREF(value); } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Clear(); } else { result = -1; } return result; } static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) { PyObject *module = NULL, *moddict, *modname; if (__Pyx_check_single_interpreter()) return NULL; if (__pyx_m) return __Pyx_NewRef(__pyx_m); modname = PyObject_GetAttrString(spec, "name"); if (unlikely(!modname)) goto bad; module = PyModule_NewObject(modname); Py_DECREF(modname); if (unlikely(!module)) goto bad; moddict = PyModule_GetDict(module); if (unlikely(!moddict)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; return module; bad: Py_XDECREF(module); return NULL; } static CYTHON_SMALL_CODE int __pyx_pymod_exec_pyfuse3(PyObject *__pyx_pyinit_module) #endif #endif { PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; __Pyx_RefNannyDeclarations #if CYTHON_PEP489_MULTI_PHASE_INIT if (__pyx_m) { if (__pyx_m == __pyx_pyinit_module) return 0; PyErr_SetString(PyExc_RuntimeError, "Module 'pyfuse3' has already been imported. Re-initialisation is not supported."); return -1; } #elif PY_MAJOR_VERSION >= 3 if (__pyx_m) return __Pyx_NewRef(__pyx_m); #endif #if CYTHON_REFNANNY __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); if (!__Pyx_RefNanny) { PyErr_Clear(); __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); if (!__Pyx_RefNanny) Py_FatalError("failed to import 'refnanny' module"); } #endif __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_pyfuse3(void)", 0); if (__Pyx_check_binary_version() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #ifdef __Pxy_PyFrame_Initialize_Offsets __Pxy_PyFrame_Initialize_Offsets(); #endif __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(3, 1, __pyx_L1_error) __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(3, 1, __pyx_L1_error) __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(3, 1, __pyx_L1_error) #ifdef __Pyx_CyFunction_USED if (__pyx_CyFunction_init() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #endif #ifdef __Pyx_FusedFunction_USED if (__pyx_FusedFunction_init() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #endif #ifdef __Pyx_Coroutine_USED if (__pyx_Coroutine_init() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #endif #ifdef __Pyx_Generator_USED if (__pyx_Generator_init() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_AsyncGen_init() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #endif #ifdef __Pyx_StopAsyncIteration_USED if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #endif /*--- Library function declarations ---*/ /*--- Threads initialization code ---*/ #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS #ifdef WITH_THREAD /* Python build with threading support? */ PyEval_InitThreads(); #endif #endif /*--- Module creation code ---*/ #if CYTHON_PEP489_MULTI_PHASE_INIT __pyx_m = __pyx_pyinit_module; Py_INCREF(__pyx_m); #else #if PY_MAJOR_VERSION < 3 __pyx_m = Py_InitModule4("pyfuse3", __pyx_methods, __pyx_k_pyfuse3_pxy_Copyright_2013_Niko, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); #else __pyx_m = PyModule_Create(&__pyx_moduledef); #endif if (unlikely(!__pyx_m)) __PYX_ERR(3, 1, __pyx_L1_error) #endif __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(3, 1, __pyx_L1_error) Py_INCREF(__pyx_d); __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(3, 1, __pyx_L1_error) Py_INCREF(__pyx_b); __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(3, 1, __pyx_L1_error) Py_INCREF(__pyx_cython_runtime); if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(3, 1, __pyx_L1_error); /*--- Initialize various global constants etc. ---*/ if (__Pyx_InitGlobals() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT) if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #endif if (__pyx_module_is_main_pyfuse3) { if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main_2) < 0) __PYX_ERR(3, 1, __pyx_L1_error) } #if PY_MAJOR_VERSION >= 3 { PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(3, 1, __pyx_L1_error) if (!PyDict_GetItemString(modules, "pyfuse3")) { if (unlikely(PyDict_SetItemString(modules, "pyfuse3", __pyx_m) < 0)) __PYX_ERR(3, 1, __pyx_L1_error) } } #endif /*--- Builtin init code ---*/ if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(3, 1, __pyx_L1_error) /*--- Constants init code ---*/ if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(3, 1, __pyx_L1_error) /*--- Global type/function init code ---*/ (void)__Pyx_modinit_global_init_code(); (void)__Pyx_modinit_variable_export_code(); (void)__Pyx_modinit_function_export_code(); if (unlikely(__Pyx_modinit_type_init_code() < 0)) __PYX_ERR(3, 1, __pyx_L1_error) if (unlikely(__Pyx_modinit_type_import_code() < 0)) __PYX_ERR(3, 1, __pyx_L1_error) (void)__Pyx_modinit_variable_import_code(); (void)__Pyx_modinit_function_import_code(); /*--- Execution code ---*/ #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) if (__Pyx_patch_abc() < 0) __PYX_ERR(3, 1, __pyx_L1_error) #endif /* "pyfuse3.pyx":62 * ################ * * from pickle import PicklingError # <<<<<<<<<<<<<< * from queue import Queue * import logging */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PicklingError); __Pyx_GIVEREF(__pyx_n_s_PicklingError); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PicklingError); __pyx_t_2 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_PicklingError); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 62, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_PicklingError, __pyx_t_1) < 0) __PYX_ERR(3, 62, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":63 * * from pickle import PicklingError * from queue import Queue # <<<<<<<<<<<<<< * import logging * import os */ __pyx_t_2 = PyList_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_INCREF(__pyx_n_s_Queue); __Pyx_GIVEREF(__pyx_n_s_Queue); PyList_SET_ITEM(__pyx_t_2, 0, __pyx_n_s_Queue); __pyx_t_1 = __Pyx_Import(__pyx_n_s_queue, __pyx_t_2, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_ImportFrom(__pyx_t_1, __pyx_n_s_Queue); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 63, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Queue, __pyx_t_2) < 0) __PYX_ERR(3, 63, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":64 * from pickle import PicklingError * from queue import Queue * import logging # <<<<<<<<<<<<<< * import os * import os.path */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_logging, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 64, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_logging, __pyx_t_1) < 0) __PYX_ERR(3, 64, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":65 * from queue import Queue * import logging * import os # <<<<<<<<<<<<<< * import os.path * import sys */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 65, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(3, 65, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":66 * import logging * import os * import os.path # <<<<<<<<<<<<<< * import sys * import trio */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_os_path, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 66, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_os, __pyx_t_1) < 0) __PYX_ERR(3, 66, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":67 * import os * import os.path * import sys # <<<<<<<<<<<<<< * import trio * import threading */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_sys, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 67, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_sys, __pyx_t_1) < 0) __PYX_ERR(3, 67, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":68 * import os.path * import sys * import trio # <<<<<<<<<<<<<< * import threading * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_trio, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 68, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_trio, __pyx_t_1) < 0) __PYX_ERR(3, 68, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":69 * import sys * import trio * import threading # <<<<<<<<<<<<<< * * import _pyfuse3 */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_threading, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 69, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_threading, __pyx_t_1) < 0) __PYX_ERR(3, 69, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":71 * import threading * * import _pyfuse3 # <<<<<<<<<<<<<< * _pyfuse3.FUSEError = FUSEError * */ __pyx_t_1 = __Pyx_Import(__pyx_n_s_pyfuse3_2, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 71, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyfuse3_2, __pyx_t_1) < 0) __PYX_ERR(3, 71, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":72 * * import _pyfuse3 * _pyfuse3.FUSEError = FUSEError # <<<<<<<<<<<<<< * * from _pyfuse3 import Operations, async_wrapper */ __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_pyfuse3_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 72, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (__Pyx_PyObject_SetAttrStr(__pyx_t_1, __pyx_n_s_FUSEError, ((PyObject *)__pyx_ptype_7pyfuse3_FUSEError)) < 0) __PYX_ERR(3, 72, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "pyfuse3.pyx":74 * _pyfuse3.FUSEError = FUSEError * * from _pyfuse3 import Operations, async_wrapper # <<<<<<<<<<<<<< * * */ __pyx_t_1 = PyList_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_Operations); __Pyx_GIVEREF(__pyx_n_s_Operations); PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_Operations); __Pyx_INCREF(__pyx_n_s_async_wrapper); __Pyx_GIVEREF(__pyx_n_s_async_wrapper); PyList_SET_ITEM(__pyx_t_1, 1, __pyx_n_s_async_wrapper); __pyx_t_2 = __Pyx_Import(__pyx_n_s_pyfuse3_2, __pyx_t_1, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_Operations); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_Operations, __pyx_t_1) < 0) __PYX_ERR(3, 74, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_2, __pyx_n_s_async_wrapper); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 74, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (PyDict_SetItem(__pyx_d, __pyx_n_s_async_wrapper, __pyx_t_1) < 0) __PYX_ERR(3, 74, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":81 * ################## * * log = logging.getLogger("pyfuse3") # <<<<<<<<<<<<<< * fse = sys.getfilesystemencoding() * */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_logging); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getLogger); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__61, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 81, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_log, __pyx_t_2) < 0) __PYX_ERR(3, 81, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":82 * * log = logging.getLogger("pyfuse3") * fse = sys.getfilesystemencoding() # <<<<<<<<<<<<<< * * cdef object operations */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_sys); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_getfilesystemencoding); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_t_2 = __Pyx_PyObject_CallNoArg(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 82, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_fse, __pyx_t_2) < 0) __PYX_ERR(3, 82, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":86 * cdef object operations * cdef object mountpoint_b * cdef fuse_session* session = NULL # <<<<<<<<<<<<<< * cdef fuse_lowlevel_ops fuse_ops * cdef int session_fd */ __pyx_v_7pyfuse3_session = NULL; /* "pyfuse3.pyx":91 * cdef object py_retval * * cdef object _notify_queue = None # <<<<<<<<<<<<<< * * ROOT_INODE = FUSE_ROOT_ID */ __Pyx_INCREF(Py_None); __Pyx_XGOTREF(__pyx_v_7pyfuse3__notify_queue); __Pyx_DECREF_SET(__pyx_v_7pyfuse3__notify_queue, Py_None); __Pyx_GIVEREF(Py_None); /* "pyfuse3.pyx":93 * cdef object _notify_queue = None * * ROOT_INODE = FUSE_ROOT_ID # <<<<<<<<<<<<<< * __version__ = PYFUSE3_VERSION.decode('utf-8') * */ __pyx_t_2 = __Pyx_PyInt_From_int(FUSE_ROOT_ID); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 93, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_ROOT_INODE, __pyx_t_2) < 0) __PYX_ERR(3, 93, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":94 * * ROOT_INODE = FUSE_ROOT_ID * __version__ = PYFUSE3_VERSION.decode('utf-8') # <<<<<<<<<<<<<< * * _NANOS_PER_SEC = 1000000000 */ __pyx_t_2 = __Pyx_decode_c_string(PYFUSE3_VERSION, 0, strlen(PYFUSE3_VERSION), NULL, NULL, PyUnicode_DecodeUTF8); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 94, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_t_2) < 0) __PYX_ERR(3, 94, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":96 * __version__ = PYFUSE3_VERSION.decode('utf-8') * * _NANOS_PER_SEC = 1000000000 # <<<<<<<<<<<<<< * * # In the Cython source, we want the names to refer to the */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_NANOS_PER_SEC, __pyx_int_1000000000) < 0) __PYX_ERR(3, 96, __pyx_L1_error) /* "pyfuse3.pyx":100 * # In the Cython source, we want the names to refer to the * # C constants. Therefore, we assign through globals(). * g = globals() # <<<<<<<<<<<<<< * g['ENOATTR'] = ENOATTR * g['RENAME_EXCHANGE'] = RENAME_EXCHANGE */ __pyx_t_2 = __Pyx_Globals(); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 100, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_g, __pyx_t_2) < 0) __PYX_ERR(3, 100, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":101 * # C constants. Therefore, we assign through globals(). * g = globals() * g['ENOATTR'] = ENOATTR # <<<<<<<<<<<<<< * g['RENAME_EXCHANGE'] = RENAME_EXCHANGE * g['RENAME_NOREPLACE'] = RENAME_NOREPLACE */ __pyx_t_2 = __Pyx_PyInt_From_int(ENOATTR); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_g); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 101, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_n_u_ENOATTR, __pyx_t_2) < 0)) __PYX_ERR(3, 101, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":102 * g = globals() * g['ENOATTR'] = ENOATTR * g['RENAME_EXCHANGE'] = RENAME_EXCHANGE # <<<<<<<<<<<<<< * g['RENAME_NOREPLACE'] = RENAME_NOREPLACE * */ __pyx_t_2 = __Pyx_PyInt_From_int(RENAME_EXCHANGE); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_g); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 102, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_n_u_RENAME_EXCHANGE, __pyx_t_2) < 0)) __PYX_ERR(3, 102, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":103 * g['ENOATTR'] = ENOATTR * g['RENAME_EXCHANGE'] = RENAME_EXCHANGE * g['RENAME_NOREPLACE'] = RENAME_NOREPLACE # <<<<<<<<<<<<<< * * trio_token = None */ __pyx_t_2 = __Pyx_PyInt_From_int(RENAME_NOREPLACE); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_g); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 103, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_n_u_RENAME_NOREPLACE, __pyx_t_2) < 0)) __PYX_ERR(3, 103, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":105 * g['RENAME_NOREPLACE'] = RENAME_NOREPLACE * * trio_token = None # <<<<<<<<<<<<<< * * */ if (PyDict_SetItem(__pyx_d, __pyx_n_s_trio_token, Py_None) < 0) __PYX_ERR(3, 105, __pyx_L1_error) /* "src/handlers.pxi":59 * save_retval(fuse_lookup_async(c, PyBytes_FromString(name))) * * async def fuse_lookup_async (_Container c, name): # <<<<<<<<<<<<<< * cdef EntryAttributes entry * cdef int ret */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_1fuse_lookup_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 59, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_lookup_async, __pyx_t_2) < 0) __PYX_ERR(1, 59, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":98 * save_retval(fuse_getattr_async(c)) * * async def fuse_getattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_4fuse_getattr_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 98, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_getattr_async, __pyx_t_2) < 0) __PYX_ERR(1, 98, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":127 * save_retval(fuse_setattr_async(c, fh)) * * async def fuse_setattr_async (_Container c, fh): # <<<<<<<<<<<<<< * cdef int ret * cdef timespec now */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_7fuse_setattr_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 127, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_setattr_async, __pyx_t_2) < 0) __PYX_ERR(1, 127, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":184 * save_retval(fuse_readlink_async(c)) * * async def fuse_readlink_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef char* name */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_10fuse_readlink_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 184, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_readlink_async, __pyx_t_2) < 0) __PYX_ERR(1, 184, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":209 * save_retval(fuse_mknod_async(c, PyBytes_FromString(name))) * * async def fuse_mknod_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_13fuse_mknod_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 209, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_mknod_async, __pyx_t_2) < 0) __PYX_ERR(1, 209, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":234 * save_retval(fuse_mkdir_async(c, PyBytes_FromString(name))) * * async def fuse_mkdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_16fuse_mkdir_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 234, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_mkdir_async, __pyx_t_2) < 0) __PYX_ERR(1, 234, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":260 * save_retval(fuse_unlink_async(c, PyBytes_FromString(name))) * * async def fuse_unlink_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_19fuse_unlink_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 260, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_unlink_async, __pyx_t_2) < 0) __PYX_ERR(1, 260, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":281 * save_retval(fuse_rmdir_async(c, PyBytes_FromString(name))) * * async def fuse_rmdir_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_22fuse_rmdir_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 281, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_rmdir_async, __pyx_t_2) < 0) __PYX_ERR(1, 281, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":304 * c, PyBytes_FromString(name), PyBytes_FromString(link))) * * async def fuse_symlink_async (_Container c, name, link): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_25fuse_symlink_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 304, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_symlink_async, __pyx_t_2) < 0) __PYX_ERR(1, 304, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":332 * * * async def fuse_rename_async (_Container c, name, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef unsigned flags = c.flags */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_28fuse_rename_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 332, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_rename_async, __pyx_t_2) < 0) __PYX_ERR(1, 332, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":357 * save_retval(fuse_link_async(c, PyBytes_FromString(newname))) * * async def fuse_link_async (_Container c, newname): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_31fuse_link_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 357, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_link_async, __pyx_t_2) < 0) __PYX_ERR(1, 357, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":381 * save_retval(fuse_open_async(c)) * * async def fuse_open_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef FileInfo fi */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_34fuse_open_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 381, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_open_async, __pyx_t_2) < 0) __PYX_ERR(1, 381, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":408 * save_retval(fuse_read_async(c)) * * async def fuse_read_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef Py_buffer pybuf */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_37fuse_read_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 408, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_read_async, __pyx_t_2) < 0) __PYX_ERR(1, 408, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":438 * save_retval(fuse_write_async(c, pbuf)) * * async def fuse_write_async (_Container c, pbuf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_40fuse_write_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 438, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_write_async, __pyx_t_2) < 0) __PYX_ERR(1, 438, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":462 * save_retval(fuse_write_buf_async(c, buf)) * * async def fuse_write_buf_async (_Container c, buf): # <<<<<<<<<<<<<< * cdef int ret * cdef size_t len_ */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_43fuse_write_buf_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 462, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_write_buf_async, __pyx_t_2) < 0) __PYX_ERR(1, 462, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":483 * save_retval(fuse_flush_async(c)) * * async def fuse_flush_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_46fuse_flush_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 483, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_flush_async, __pyx_t_2) < 0) __PYX_ERR(1, 483, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":503 * save_retval(fuse_release_async(c)) * * async def fuse_release_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_49fuse_release_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_release_async, __pyx_t_2) < 0) __PYX_ERR(1, 503, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":525 * save_retval(fuse_fsync_async(c)) * * async def fuse_fsync_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_52fuse_fsync_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 525, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_fsync_async, __pyx_t_2) < 0) __PYX_ERR(1, 525, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":546 * save_retval(fuse_opendir_async(c)) * * async def fuse_opendir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_55fuse_opendir_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 546, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_opendir_async, __pyx_t_2) < 0) __PYX_ERR(1, 546, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":578 * save_retval(fuse_readdirplus_async(c)) * * async def fuse_readdirplus_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ReaddirToken token = ReaddirToken() */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_58fuse_readdirplus_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 578, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_readdirplus_async, __pyx_t_2) < 0) __PYX_ERR(1, 578, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":607 * save_retval(fuse_releasedir_async(c)) * * async def fuse_releasedir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_61fuse_releasedir_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 607, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_releasedir_async, __pyx_t_2) < 0) __PYX_ERR(1, 607, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":630 * save_retval(fuse_fsyncdir_async(c)) * * async def fuse_fsyncdir_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_64fuse_fsyncdir_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 630, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_fsyncdir_async, __pyx_t_2) < 0) __PYX_ERR(1, 630, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":650 * save_retval(fuse_statfs_async(c)) * * async def fuse_statfs_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef StatvfsData stats */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_67fuse_statfs_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 650, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_statfs_async, __pyx_t_2) < 0) __PYX_ERR(1, 650, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":681 * save_retval(fuse_setxattr_async(c, name, value)) * * async def fuse_setxattr_async (_Container c, name, value): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_70fuse_setxattr_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_setxattr_async, __pyx_t_2) < 0) __PYX_ERR(1, 681, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":726 * save_retval(fuse_getxattr_async(c, PyBytes_FromString(name))) * * async def fuse_getxattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_73fuse_getxattr_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 726, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_getxattr_async, __pyx_t_2) < 0) __PYX_ERR(1, 726, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":759 * save_retval(fuse_listxattr_async(c)) * * async def fuse_listxattr_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef ssize_t len_s */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_76fuse_listxattr_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 759, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_listxattr_async, __pyx_t_2) < 0) __PYX_ERR(1, 759, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":797 * save_retval(fuse_removexattr_async(c, PyBytes_FromString(name))) * * async def fuse_removexattr_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_79fuse_removexattr_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 797, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_removexattr_async, __pyx_t_2) < 0) __PYX_ERR(1, 797, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":819 * save_retval(fuse_access_async(c)) * * async def fuse_access_async (_Container c): # <<<<<<<<<<<<<< * cdef int ret * cdef int mask = c.flags */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_82fuse_access_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 819, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_access_async, __pyx_t_2) < 0) __PYX_ERR(1, 819, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/handlers.pxi":848 * save_retval(fuse_create_async(c, PyBytes_FromString(name))) * * async def fuse_create_async (_Container c, name): # <<<<<<<<<<<<<< * cdef int ret * cdef EntryAttributes entry */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_85fuse_create_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 848, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_fuse_create_async, __pyx_t_2) < 0) __PYX_ERR(1, 848, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/internal.pxi":114 * raise * * def _notify_loop(): # <<<<<<<<<<<<<< * '''Process async invalidate_entry calls.''' * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_88_notify_loop, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 114, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_notify_loop, __pyx_t_2) < 0) __PYX_ERR(2, 114, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/internal.pxi":201 * cdef _WorkerData worker_data * * async def _wait_fuse_readable(): # <<<<<<<<<<<<<< * '''Wait for FUSE fd to become readable * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_90_wait_fuse_readable, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 201, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_wait_fuse_readable, __pyx_t_2) < 0) __PYX_ERR(2, 201, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "src/internal.pxi":229 * return True * * @async_wrapper # <<<<<<<<<<<<<< * async def _session_loop(nursery, int min_tasks, int max_tasks): * cdef int res */ __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_async_wrapper); if (unlikely(!__pyx_t_2)) __PYX_ERR(2, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); /* "src/internal.pxi":230 * * @async_wrapper * async def _session_loop(nursery, int min_tasks, int max_tasks): # <<<<<<<<<<<<<< * cdef int res * cdef fuse_buf buf */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_93_session_loop, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 230, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "src/internal.pxi":229 * return True * * @async_wrapper # <<<<<<<<<<<<<< * async def _session_loop(nursery, int min_tasks, int max_tasks): * cdef int res */ __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(2, 229, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_session_loop, __pyx_t_3) < 0) __PYX_ERR(2, 230, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":505 * return strerror(self.errno_) * * def listdir(path): # <<<<<<<<<<<<<< * '''Like `os.listdir`, but releases the GIL. * */ __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_96listdir, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 505, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_listdir, __pyx_t_3) < 0) __PYX_ERR(3, 505, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":554 * * * def syncfs(path): # <<<<<<<<<<<<<< * '''Sync filesystem mounted at *path* * */ __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_98syncfs, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 554, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_syncfs, __pyx_t_3) < 0) __PYX_ERR(3, 554, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":573 * * * def setxattr(path, name, bytes value, namespace='user'): # <<<<<<<<<<<<<< * '''Set extended attribute * */ __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_100setxattr, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 573, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_setxattr, __pyx_t_3) < 0) __PYX_ERR(3, 573, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":624 * * * def getxattr(path, name, size_t size_guess=128, namespace='user'): # <<<<<<<<<<<<<< * '''Get extended attribute * */ __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_102getxattr, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 624, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_getxattr, __pyx_t_3) < 0) __PYX_ERR(3, 624, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":704 * * * default_options = frozenset(('default_permissions',)) # <<<<<<<<<<<<<< * * def init(ops, mountpoint, options=default_options): */ __pyx_t_3 = __Pyx_PyFrozenSet_New(__pyx_tuple__102); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 704, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_default_options, __pyx_t_3) < 0) __PYX_ERR(3, 704, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":706 * default_options = frozenset(('default_permissions',)) * * def init(ops, mountpoint, options=default_options): # <<<<<<<<<<<<<< * '''Initialize and mount FUSE file system * */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_default_options); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_k__54 = __pyx_t_3; __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_104init, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 706, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); if (PyDict_SetItem(__pyx_d, __pyx_n_s_init, __pyx_t_3) < 0) __PYX_ERR(3, 706, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "pyfuse3.pyx":762 * * * @async_wrapper # <<<<<<<<<<<<<< * async def main(int min_tasks=1, int max_tasks=99): * '''Run FUSE main loop''' */ __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_async_wrapper); if (unlikely(!__pyx_t_3)) __PYX_ERR(3, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); /* "pyfuse3.pyx":763 * * @async_wrapper * async def main(int min_tasks=1, int max_tasks=99): # <<<<<<<<<<<<<< * '''Run FUSE main loop''' * */ __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_106main, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 763, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); /* "pyfuse3.pyx":762 * * * @async_wrapper # <<<<<<<<<<<<<< * async def main(int min_tasks=1, int max_tasks=99): * '''Run FUSE main loop''' */ __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 762, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (PyDict_SetItem(__pyx_d, __pyx_n_s_main, __pyx_t_2) < 0) __PYX_ERR(3, 763, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":784 * * * def terminate(): # <<<<<<<<<<<<<< * '''Terminate FUSE main loop. * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_109terminate, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 784, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_terminate, __pyx_t_2) < 0) __PYX_ERR(3, 784, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":799 * * * def close(unmount=True): # <<<<<<<<<<<<<< * '''Clean up and ensure filesystem is unmounted * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_111close, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 799, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_close, __pyx_t_2) < 0) __PYX_ERR(3, 799, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":831 * session = NULL * * def invalidate_inode(fuse_ino_t inode, attr_only=False): # <<<<<<<<<<<<<< * '''Invalidate cache for *inode* * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_113invalidate_inode, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 831, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_inode, __pyx_t_2) < 0) __PYX_ERR(3, 831, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":860 * * * def invalidate_entry(fuse_ino_t inode_p, bytes name, fuse_ino_t deleted=0): # <<<<<<<<<<<<<< * '''Invalidate directory entry * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_115invalidate_entry, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 860, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_entry, __pyx_t_2) < 0) __PYX_ERR(3, 860, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":916 * * * def invalidate_entry_async(inode_p, name, deleted=0, ignore_enoent=False): # <<<<<<<<<<<<<< * '''Asynchronously invalidate directory entry * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_117invalidate_entry_async, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 916, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_invalidate_entry_async, __pyx_t_2) < 0) __PYX_ERR(3, 916, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":952 * * * def notify_store(inode, offset, data): # <<<<<<<<<<<<<< * '''Store data in kernel page cache * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_119notify_store, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 952, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_notify_store, __pyx_t_2) < 0) __PYX_ERR(3, 952, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":995 * raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) * * def get_sup_groups(pid): # <<<<<<<<<<<<<< * '''Return supplementary group ids of *pid* * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_121get_sup_groups, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 995, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_get_sup_groups, __pyx_t_2) < 0) __PYX_ERR(3, 995, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":1018 * * * def readdir_reply(ReaddirToken token, name, EntryAttributes attr, off_t next_id): # <<<<<<<<<<<<<< * '''Report a directory entry in response to a `~Operations.readdir` request. * */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_123readdir_reply, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1018, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_readdir_reply, __pyx_t_2) < 0) __PYX_ERR(3, 1018, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":1 * def __pyx_unpickle__WorkerData(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< * cdef object __pyx_PickleError * cdef object __pyx_result */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_125__pyx_unpickle__WorkerData, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle__WorkerData, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "(tree fragment)":11 * __pyx_unpickle__WorkerData__set_state(<_WorkerData> __pyx_result, __pyx_state) * return __pyx_result * cdef __pyx_unpickle__WorkerData__set_state(_WorkerData __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< * __pyx_result.active_readers = __pyx_state[0]; __pyx_result.read_lock = __pyx_state[1]; __pyx_result.task_count = __pyx_state[2]; __pyx_result.task_serial = __pyx_state[3] * if len(__pyx_state) > 4 and hasattr(__pyx_result, '__dict__'): */ __pyx_t_2 = PyCFunction_NewEx(&__pyx_mdef_7pyfuse3_127__pyx_unpickle_RequestContext, NULL, __pyx_n_s_pyfuse3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_RequestContext, __pyx_t_2) < 0) __PYX_ERR(0, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "pyfuse3.pyx":1 * ''' # <<<<<<<<<<<<<< * pyfuse3.pxy * */ __pyx_t_2 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(3, 1, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_2) < 0) __PYX_ERR(3, 1, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /*--- Wrapped vars code ---*/ goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); if (__pyx_m) { if (__pyx_d) { __Pyx_AddTraceback("init pyfuse3", __pyx_clineno, __pyx_lineno, __pyx_filename); } Py_CLEAR(__pyx_m); } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_ImportError, "init pyfuse3"); } __pyx_L0:; __Pyx_RefNannyFinishContext(); #if CYTHON_PEP489_MULTI_PHASE_INIT return (__pyx_m != NULL) ? 0 : -1; #elif PY_MAJOR_VERSION >= 3 return __pyx_m; #else return; #endif } /* --- Runtime support code --- */ /* Refnanny */ #if CYTHON_REFNANNY static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { PyObject *m = NULL, *p = NULL; void *r = NULL; m = PyImport_ImportModule(modname); if (!m) goto end; p = PyObject_GetAttrString(m, "RefNannyAPI"); if (!p) goto end; r = PyLong_AsVoidPtr(p); end: Py_XDECREF(p); Py_XDECREF(m); return (__Pyx_RefNannyAPIStruct *)r; } #endif /* PyObjectGetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro)) return tp->tp_getattro(obj, attr_name); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_getattr)) return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); #endif return PyObject_GetAttr(obj, attr_name); } #endif /* GetBuiltinName */ static PyObject *__Pyx_GetBuiltinName(PyObject *name) { PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); if (unlikely(!result)) { PyErr_Format(PyExc_NameError, #if PY_MAJOR_VERSION >= 3 "name '%U' is not defined", name); #else "name '%.200s' is not defined", PyString_AS_STRING(name)); #endif } return result; } /* PyObjectCall */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { PyObject *result; ternaryfunc call = func->ob_type->tp_call; if (unlikely(!call)) return PyObject_Call(func, arg, kw); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = (*call)(func, arg, kw); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyErrFetchRestore */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; tmp_type = tstate->curexc_type; tmp_value = tstate->curexc_value; tmp_tb = tstate->curexc_traceback; tstate->curexc_type = type; tstate->curexc_value = value; tstate->curexc_traceback = tb; Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { *type = tstate->curexc_type; *value = tstate->curexc_value; *tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; } #endif /* RaiseException */ #if PY_MAJOR_VERSION < 3 static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, CYTHON_UNUSED PyObject *cause) { __Pyx_PyThreadState_declare Py_XINCREF(type); if (!value || value == Py_None) value = NULL; else Py_INCREF(value); if (!tb || tb == Py_None) tb = NULL; else { Py_INCREF(tb); if (!PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto raise_error; } } if (PyType_Check(type)) { #if CYTHON_COMPILING_IN_PYPY if (!value) { Py_INCREF(Py_None); value = Py_None; } #endif PyErr_NormalizeException(&type, &value, &tb); } else { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto raise_error; } value = type; type = (PyObject*) Py_TYPE(type); Py_INCREF(type); if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto raise_error; } } __Pyx_PyThreadState_assign __Pyx_ErrRestore(type, value, tb); return; raise_error: Py_XDECREF(value); Py_XDECREF(type); Py_XDECREF(tb); return; } #else static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { PyObject* owned_instance = NULL; if (tb == Py_None) { tb = 0; } else if (tb && !PyTraceBack_Check(tb)) { PyErr_SetString(PyExc_TypeError, "raise: arg 3 must be a traceback or None"); goto bad; } if (value == Py_None) value = 0; if (PyExceptionInstance_Check(type)) { if (value) { PyErr_SetString(PyExc_TypeError, "instance exception may not have a separate value"); goto bad; } value = type; type = (PyObject*) Py_TYPE(value); } else if (PyExceptionClass_Check(type)) { PyObject *instance_class = NULL; if (value && PyExceptionInstance_Check(value)) { instance_class = (PyObject*) Py_TYPE(value); if (instance_class != type) { int is_subclass = PyObject_IsSubclass(instance_class, type); if (!is_subclass) { instance_class = NULL; } else if (unlikely(is_subclass == -1)) { goto bad; } else { type = instance_class; } } } if (!instance_class) { PyObject *args; if (!value) args = PyTuple_New(0); else if (PyTuple_Check(value)) { Py_INCREF(value); args = value; } else args = PyTuple_Pack(1, value); if (!args) goto bad; owned_instance = PyObject_Call(type, args, NULL); Py_DECREF(args); if (!owned_instance) goto bad; value = owned_instance; if (!PyExceptionInstance_Check(value)) { PyErr_Format(PyExc_TypeError, "calling %R should have returned an instance of " "BaseException, not %R", type, Py_TYPE(value)); goto bad; } } } else { PyErr_SetString(PyExc_TypeError, "raise: exception class must be a subclass of BaseException"); goto bad; } if (cause) { PyObject *fixed_cause; if (cause == Py_None) { fixed_cause = NULL; } else if (PyExceptionClass_Check(cause)) { fixed_cause = PyObject_CallObject(cause, NULL); if (fixed_cause == NULL) goto bad; } else if (PyExceptionInstance_Check(cause)) { fixed_cause = cause; Py_INCREF(fixed_cause); } else { PyErr_SetString(PyExc_TypeError, "exception causes must derive from " "BaseException"); goto bad; } PyException_SetCause(value, fixed_cause); } PyErr_SetObject(type, value); if (tb) { #if CYTHON_COMPILING_IN_PYPY PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); Py_INCREF(tb); PyErr_Restore(tmp_type, tmp_value, tb); Py_XDECREF(tmp_tb); #else PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* tmp_tb = tstate->curexc_traceback; if (tb != tmp_tb) { Py_INCREF(tb); tstate->curexc_traceback = tb; Py_XDECREF(tmp_tb); } #endif } bad: Py_XDECREF(owned_instance); return; } #endif /* PyFunctionFastCall */ #if CYTHON_FAST_PYCALL static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, PyObject *globals) { PyFrameObject *f; PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject **fastlocals; Py_ssize_t i; PyObject *result; assert(globals != NULL); /* XXX Perhaps we should create a specialized PyFrame_New() that doesn't take locals, but does take builtins without sanity checking them. */ assert(tstate != NULL); f = PyFrame_New(tstate, co, globals, NULL); if (f == NULL) { return NULL; } fastlocals = __Pyx_PyFrame_GetLocalsplus(f); for (i = 0; i < na; i++) { Py_INCREF(*args); fastlocals[i] = *args++; } result = PyEval_EvalFrameEx(f,0); ++tstate->recursion_depth; Py_DECREF(f); --tstate->recursion_depth; return result; } #if 1 || PY_VERSION_HEX < 0x030600B1 static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); PyObject *globals = PyFunction_GET_GLOBALS(func); PyObject *argdefs = PyFunction_GET_DEFAULTS(func); PyObject *closure; #if PY_MAJOR_VERSION >= 3 PyObject *kwdefs; #endif PyObject *kwtuple, **k; PyObject **d; Py_ssize_t nd; Py_ssize_t nk; PyObject *result; assert(kwargs == NULL || PyDict_Check(kwargs)); nk = kwargs ? PyDict_Size(kwargs) : 0; if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { return NULL; } if ( #if PY_MAJOR_VERSION >= 3 co->co_kwonlyargcount == 0 && #endif likely(kwargs == NULL || nk == 0) && co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { if (argdefs == NULL && co->co_argcount == nargs) { result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); goto done; } else if (nargs == 0 && argdefs != NULL && co->co_argcount == Py_SIZE(argdefs)) { /* function called with no arguments, but all parameters have a default value: use default values as arguments .*/ args = &PyTuple_GET_ITEM(argdefs, 0); result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); goto done; } } if (kwargs != NULL) { Py_ssize_t pos, i; kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { result = NULL; goto done; } k = &PyTuple_GET_ITEM(kwtuple, 0); pos = i = 0; while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { Py_INCREF(k[i]); Py_INCREF(k[i+1]); i += 2; } nk = i / 2; } else { kwtuple = NULL; k = NULL; } closure = PyFunction_GET_CLOSURE(func); #if PY_MAJOR_VERSION >= 3 kwdefs = PyFunction_GET_KW_DEFAULTS(func); #endif if (argdefs != NULL) { d = &PyTuple_GET_ITEM(argdefs, 0); nd = Py_SIZE(argdefs); } else { d = NULL; nd = 0; } #if PY_MAJOR_VERSION >= 3 result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, kwdefs, closure); #else result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, args, (int)nargs, k, (int)nk, d, (int)nd, closure); #endif Py_XDECREF(kwtuple); done: Py_LeaveRecursiveCall(); return result; } #endif #endif /* PyObjectCallMethO */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { PyObject *self, *result; PyCFunction cfunc; cfunc = PyCFunction_GET_FUNCTION(func); self = PyCFunction_GET_SELF(func); if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) return NULL; result = cfunc(self, arg); Py_LeaveRecursiveCall(); if (unlikely(!result) && unlikely(!PyErr_Occurred())) { PyErr_SetString( PyExc_SystemError, "NULL result without error in PyObject_Call"); } return result; } #endif /* PyObjectCallNoArg */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, NULL, 0); } #endif #ifdef __Pyx_CyFunction_USED if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) #else if (likely(PyCFunction_Check(func))) #endif { if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { return __Pyx_PyObject_CallMethO(func, NULL); } } return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); } #endif /* PyCFunctionFastCall */ #if CYTHON_FAST_PYCCALL static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { PyCFunctionObject *func = (PyCFunctionObject*)func_obj; PyCFunction meth = PyCFunction_GET_FUNCTION(func); PyObject *self = PyCFunction_GET_SELF(func); int flags = PyCFunction_GET_FLAGS(func); assert(PyCFunction_Check(func)); assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); assert(nargs >= 0); assert(nargs == 0 || args != NULL); /* _PyCFunction_FastCallDict() must not be called with an exception set, because it may clear it (directly or indirectly) and so the caller loses its exception */ assert(!PyErr_Occurred()); if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); } else { return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); } } #endif /* PyObjectCallOneArg */ #if CYTHON_COMPILING_IN_CPYTHON static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_New(1); if (unlikely(!args)) return NULL; Py_INCREF(arg); PyTuple_SET_ITEM(args, 0, arg); result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { #if CYTHON_FAST_PYCALL if (PyFunction_Check(func)) { return __Pyx_PyFunction_FastCall(func, &arg, 1); } #endif if (likely(PyCFunction_Check(func))) { if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { return __Pyx_PyObject_CallMethO(func, arg); #if CYTHON_FAST_PYCCALL } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) { return __Pyx_PyCFunction_FastCall(func, &arg, 1); #endif } } return __Pyx__PyObject_CallOneArg(func, arg); } #else static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { PyObject *result; PyObject *args = PyTuple_Pack(1, arg); if (unlikely(!args)) return NULL; result = __Pyx_PyObject_Call(func, args, NULL); Py_DECREF(args); return result; } #endif /* WriteUnraisableException */ static void __Pyx_WriteUnraisable(const char *name, CYTHON_UNUSED int clineno, CYTHON_UNUSED int lineno, CYTHON_UNUSED const char *filename, int full_traceback, CYTHON_UNUSED int nogil) { PyObject *old_exc, *old_val, *old_tb; PyObject *ctx; __Pyx_PyThreadState_declare #ifdef WITH_THREAD PyGILState_STATE state; if (nogil) state = PyGILState_Ensure(); #ifdef _MSC_VER else state = (PyGILState_STATE)-1; #endif #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&old_exc, &old_val, &old_tb); if (full_traceback) { Py_XINCREF(old_exc); Py_XINCREF(old_val); Py_XINCREF(old_tb); __Pyx_ErrRestore(old_exc, old_val, old_tb); PyErr_PrintEx(1); } #if PY_MAJOR_VERSION < 3 ctx = PyString_FromString(name); #else ctx = PyUnicode_FromString(name); #endif __Pyx_ErrRestore(old_exc, old_val, old_tb); if (!ctx) { PyErr_WriteUnraisable(Py_None); } else { PyErr_WriteUnraisable(ctx); Py_DECREF(ctx); } #ifdef WITH_THREAD if (nogil) PyGILState_Release(state); #endif } /* PyDictVersioning */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { PyObject *dict = Py_TYPE(obj)->tp_dict; return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; } static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { PyObject **dictptr = NULL; Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; if (offset) { #if CYTHON_COMPILING_IN_CPYTHON dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); #else dictptr = _PyObject_GetDictPtr(obj); #endif } return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; } static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { PyObject *dict = Py_TYPE(obj)->tp_dict; if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) return 0; return obj_dict_version == __Pyx_get_object_dict_version(obj); } #endif /* GetModuleGlobalName */ #if CYTHON_USE_DICT_VERSIONS static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) #else static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) #endif { PyObject *result; #if !CYTHON_AVOID_BORROWED_REFS #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } else if (unlikely(PyErr_Occurred())) { return NULL; } #else result = PyDict_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } #endif #else result = PyObject_GetItem(__pyx_d, name); __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) if (likely(result)) { return __Pyx_NewRef(result); } PyErr_Clear(); #endif return __Pyx_GetBuiltinName(name); } /* RaiseArgTupleInvalid */ static void __Pyx_RaiseArgtupleInvalid( const char* func_name, int exact, Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found) { Py_ssize_t num_expected; const char *more_or_less; if (num_found < num_min) { num_expected = num_min; more_or_less = "at least"; } else { num_expected = num_max; more_or_less = "at most"; } if (exact) { more_or_less = "exactly"; } PyErr_Format(PyExc_TypeError, "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", func_name, more_or_less, num_expected, (num_expected == 1) ? "" : "s", num_found); } /* RaiseDoubleKeywords */ static void __Pyx_RaiseDoubleKeywordsError( const char* func_name, PyObject* kw_name) { PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION >= 3 "%s() got multiple values for keyword argument '%U'", func_name, kw_name); #else "%s() got multiple values for keyword argument '%s'", func_name, PyString_AsString(kw_name)); #endif } /* ParseKeywords */ static int __Pyx_ParseOptionalKeywords( PyObject *kwds, PyObject **argnames[], PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name) { PyObject *key = 0, *value = 0; Py_ssize_t pos = 0; PyObject*** name; PyObject*** first_kw_arg = argnames + num_pos_args; while (PyDict_Next(kwds, &pos, &key, &value)) { name = first_kw_arg; while (*name && (**name != key)) name++; if (*name) { values[name-argnames] = value; continue; } name = first_kw_arg; #if PY_MAJOR_VERSION < 3 if (likely(PyString_Check(key))) { while (*name) { if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) && _PyString_Eq(**name, key)) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { if ((**argname == key) || ( (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) && _PyString_Eq(**argname, key))) { goto arg_passed_twice; } argname++; } } } else #endif if (likely(PyUnicode_Check(key))) { while (*name) { int cmp = (**name == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**name, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) { values[name-argnames] = value; break; } name++; } if (*name) continue; else { PyObject*** argname = argnames; while (argname != first_kw_arg) { int cmp = (**argname == key) ? 0 : #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : #endif PyUnicode_Compare(**argname, key); if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; if (cmp == 0) goto arg_passed_twice; argname++; } } } else goto invalid_keyword_type; if (kwds2) { if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; } else { goto invalid_keyword; } } return 0; arg_passed_twice: __Pyx_RaiseDoubleKeywordsError(function_name, key); goto bad; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); goto bad; invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif bad: return -1; } /* ArgTypeTest */ static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } else if (exact) { #if PY_MAJOR_VERSION == 2 if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; #endif } else { if (likely(__Pyx_TypeCheck(obj, type))) return 1; } PyErr_Format(PyExc_TypeError, "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", name, type->tp_name, Py_TYPE(obj)->tp_name); return 0; } /* FetchCommonType */ static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { PyObject* fake_module; PyTypeObject* cached_type = NULL; fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI); if (!fake_module) return NULL; Py_INCREF(fake_module); cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name); if (cached_type) { if (!PyType_Check((PyObject*)cached_type)) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s is not a type object", type->tp_name); goto bad; } if (cached_type->tp_basicsize != type->tp_basicsize) { PyErr_Format(PyExc_TypeError, "Shared Cython type %.200s has the wrong size, try recompiling", type->tp_name); goto bad; } } else { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; PyErr_Clear(); if (PyType_Ready(type) < 0) goto bad; if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0) goto bad; Py_INCREF(type); cached_type = type; } done: Py_DECREF(fake_module); return cached_type; bad: Py_XDECREF(cached_type); cached_type = NULL; goto done; } /* GetTopmostException */ #if CYTHON_USE_EXC_INFO_STACK static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate) { _PyErr_StackItem *exc_info = tstate->exc_info; while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && exc_info->previous_item != NULL) { exc_info = exc_info->previous_item; } return exc_info; } #endif /* SaveResetException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); *type = exc_info->exc_type; *value = exc_info->exc_value; *tb = exc_info->exc_traceback; #else *type = tstate->exc_type; *value = tstate->exc_value; *tb = tstate->exc_traceback; #endif Py_XINCREF(*type); Py_XINCREF(*value); Py_XINCREF(*tb); } static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = type; exc_info->exc_value = value; exc_info->exc_traceback = tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = type; tstate->exc_value = value; tstate->exc_traceback = tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); } #endif /* SwapException */ #if CYTHON_FAST_THREAD_STATE static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; #if CYTHON_USE_EXC_INFO_STACK _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = *type; exc_info->exc_value = *value; exc_info->exc_traceback = *tb; #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = *type; tstate->exc_value = *value; tstate->exc_traceback = *tb; #endif *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #else static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { PyObject *tmp_type, *tmp_value, *tmp_tb; PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); PyErr_SetExcInfo(*type, *value, *tb); *type = tmp_type; *value = tmp_value; *tb = tmp_tb; } #endif /* PyObjectCall2Args */ static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { PyObject *args, *result = NULL; #if CYTHON_FAST_PYCALL if (PyFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyFunction_FastCall(function, args, 2); } #endif #if CYTHON_FAST_PYCCALL if (__Pyx_PyFastCFunction_Check(function)) { PyObject *args[2] = {arg1, arg2}; return __Pyx_PyCFunction_FastCall(function, args, 2); } #endif args = PyTuple_New(2); if (unlikely(!args)) goto done; Py_INCREF(arg1); PyTuple_SET_ITEM(args, 0, arg1); Py_INCREF(arg2); PyTuple_SET_ITEM(args, 1, arg2); Py_INCREF(function); result = __Pyx_PyObject_Call(function, args, NULL); Py_DECREF(args); Py_DECREF(function); done: return result; } /* PyObjectGetMethod */ static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { PyObject *attr; #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP PyTypeObject *tp = Py_TYPE(obj); PyObject *descr; descrgetfunc f = NULL; PyObject **dictptr, *dict; int meth_found = 0; assert (*method == NULL); if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; } if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { return 0; } descr = _PyType_Lookup(tp, name); if (likely(descr != NULL)) { Py_INCREF(descr); #if PY_MAJOR_VERSION >= 3 #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr) || (Py_TYPE(descr) == &PyMethodDescr_Type))) #endif #else #ifdef __Pyx_CyFunction_USED if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) #else if (likely(PyFunction_Check(descr))) #endif #endif { meth_found = 1; } else { f = Py_TYPE(descr)->tp_descr_get; if (f != NULL && PyDescr_IsData(descr)) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } } } dictptr = _PyObject_GetDictPtr(obj); if (dictptr != NULL && (dict = *dictptr) != NULL) { Py_INCREF(dict); attr = __Pyx_PyDict_GetItemStr(dict, name); if (attr != NULL) { Py_INCREF(attr); Py_DECREF(dict); Py_XDECREF(descr); goto try_unpack; } Py_DECREF(dict); } if (meth_found) { *method = descr; return 1; } if (f != NULL) { attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); Py_DECREF(descr); goto try_unpack; } if (descr != NULL) { *method = descr; return 0; } PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(name)); #endif return 0; #else attr = __Pyx_PyObject_GetAttrStr(obj, name); goto try_unpack; #endif try_unpack: #if CYTHON_UNPACK_METHODS if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { PyObject *function = PyMethod_GET_FUNCTION(attr); Py_INCREF(function); Py_DECREF(attr); *method = function; return 1; } #endif *method = attr; return 0; } /* PyObjectCallMethod1 */ static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); Py_DECREF(method); return result; } static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { PyObject *method = NULL, *result; int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); if (likely(is_method)) { result = __Pyx_PyObject_Call2Args(method, obj, arg); Py_DECREF(method); return result; } if (unlikely(!method)) return NULL; return __Pyx__PyObject_CallMethod1(method, arg); } /* CoroutineBase */ #include #include #define __Pyx_Coroutine_Undelegate(gen) Py_CLEAR((gen)->yieldfrom) static int __Pyx_PyGen__FetchStopIterationValue(CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject **pvalue) { PyObject *et, *ev, *tb; PyObject *value = NULL; __Pyx_ErrFetch(&et, &ev, &tb); if (!et) { Py_XDECREF(tb); Py_XDECREF(ev); Py_INCREF(Py_None); *pvalue = Py_None; return 0; } if (likely(et == PyExc_StopIteration)) { if (!ev) { Py_INCREF(Py_None); value = Py_None; } #if PY_VERSION_HEX >= 0x030300A0 else if (Py_TYPE(ev) == (PyTypeObject*)PyExc_StopIteration) { value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); Py_DECREF(ev); } #endif else if (unlikely(PyTuple_Check(ev))) { if (PyTuple_GET_SIZE(ev) >= 1) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS value = PyTuple_GET_ITEM(ev, 0); Py_INCREF(value); #else value = PySequence_ITEM(ev, 0); #endif } else { Py_INCREF(Py_None); value = Py_None; } Py_DECREF(ev); } else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { value = ev; } if (likely(value)) { Py_XDECREF(tb); Py_DECREF(et); *pvalue = value; return 0; } } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { __Pyx_ErrRestore(et, ev, tb); return -1; } PyErr_NormalizeException(&et, &ev, &tb); if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { __Pyx_ErrRestore(et, ev, tb); return -1; } Py_XDECREF(tb); Py_DECREF(et); #if PY_VERSION_HEX >= 0x030300A0 value = ((PyStopIterationObject *)ev)->value; Py_INCREF(value); Py_DECREF(ev); #else { PyObject* args = __Pyx_PyObject_GetAttrStr(ev, __pyx_n_s_args); Py_DECREF(ev); if (likely(args)) { value = PySequence_GetItem(args, 0); Py_DECREF(args); } if (unlikely(!value)) { __Pyx_ErrRestore(NULL, NULL, NULL); Py_INCREF(Py_None); value = Py_None; } } #endif *pvalue = value; return 0; } static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { PyObject *t, *v, *tb; t = exc_state->exc_type; v = exc_state->exc_value; tb = exc_state->exc_traceback; exc_state->exc_type = NULL; exc_state->exc_value = NULL; exc_state->exc_traceback = NULL; Py_XDECREF(t); Py_XDECREF(v); Py_XDECREF(tb); } #define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) static void __Pyx__Coroutine_AlreadyRunningError(CYTHON_UNUSED __pyx_CoroutineObject *gen) { const char *msg; if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { msg = "coroutine already executing"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { msg = "async generator already executing"; #endif } else { msg = "generator already executing"; } PyErr_SetString(PyExc_ValueError, msg); } #define __Pyx_Coroutine_NotStartedError(gen) (__Pyx__Coroutine_NotStartedError(gen), (PyObject*)NULL) static void __Pyx__Coroutine_NotStartedError(CYTHON_UNUSED PyObject *gen) { const char *msg; if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(gen)) { msg = "can't send non-None value to a just-started coroutine"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact(gen)) { msg = "can't send non-None value to a just-started async generator"; #endif } else { msg = "can't send non-None value to a just-started generator"; } PyErr_SetString(PyExc_TypeError, msg); } #define __Pyx_Coroutine_AlreadyTerminatedError(gen, value, closing) (__Pyx__Coroutine_AlreadyTerminatedError(gen, value, closing), (PyObject*)NULL) static void __Pyx__Coroutine_AlreadyTerminatedError(CYTHON_UNUSED PyObject *gen, PyObject *value, CYTHON_UNUSED int closing) { #ifdef __Pyx_Coroutine_USED if (!closing && __Pyx_Coroutine_Check(gen)) { PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); } else #endif if (value) { #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(gen)) PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration); else #endif PyErr_SetNone(PyExc_StopIteration); } } static PyObject *__Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, int closing) { __Pyx_PyThreadState_declare PyThreadState *tstate; __Pyx_ExcInfoStruct *exc_state; PyObject *retval; assert(!self->is_running); if (unlikely(self->resume_label == 0)) { if (unlikely(value && value != Py_None)) { return __Pyx_Coroutine_NotStartedError((PyObject*)self); } } if (unlikely(self->resume_label == -1)) { return __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign tstate = __pyx_tstate; #else tstate = __Pyx_PyThreadState_Current; #endif exc_state = &self->gi_exc_state; if (exc_state->exc_type) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON #else if (exc_state->exc_traceback) { PyTracebackObject *tb = (PyTracebackObject *) exc_state->exc_traceback; PyFrameObject *f = tb->tb_frame; Py_XINCREF(tstate->frame); assert(f->f_back == NULL); f->f_back = tstate->frame; } #endif } #if CYTHON_USE_EXC_INFO_STACK exc_state->previous_item = tstate->exc_info; tstate->exc_info = exc_state; #else if (exc_state->exc_type) { __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } else { __Pyx_Coroutine_ExceptionClear(exc_state); __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); } #endif self->is_running = 1; retval = self->body((PyObject *) self, tstate, value); self->is_running = 0; #if CYTHON_USE_EXC_INFO_STACK exc_state = &self->gi_exc_state; tstate->exc_info = exc_state->previous_item; exc_state->previous_item = NULL; __Pyx_Coroutine_ResetFrameBackpointer(exc_state); #endif return retval; } static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { PyObject *exc_tb = exc_state->exc_traceback; if (likely(exc_tb)) { #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_PYSTON #else PyTracebackObject *tb = (PyTracebackObject *) exc_tb; PyFrameObject *f = tb->tb_frame; Py_CLEAR(f->f_back); #endif } } static CYTHON_INLINE PyObject *__Pyx_Coroutine_MethodReturn(CYTHON_UNUSED PyObject* gen, PyObject *retval) { if (unlikely(!retval)) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (!__Pyx_PyErr_Occurred()) { PyObject *exc = PyExc_StopIteration; #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(gen)) exc = __Pyx_PyExc_StopAsyncIteration; #endif __Pyx_PyErr_SetNone(exc); } } return retval; } static CYTHON_INLINE PyObject *__Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen) { PyObject *ret; PyObject *val = NULL; __Pyx_Coroutine_Undelegate(gen); __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); ret = __Pyx_Coroutine_SendEx(gen, val, 0); Py_XDECREF(val); return ret; } static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { PyObject *retval; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; PyObject *yf = gen->yieldfrom; if (unlikely(gen->is_running)) return __Pyx_Coroutine_AlreadyRunningError(gen); if (yf) { PyObject *ret; gen->is_running = 1; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Coroutine_Send(yf, value); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { ret = __Pyx_Coroutine_Send(yf, value); } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { ret = __Pyx_async_gen_asend_send(yf, value); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) if (PyGen_CheckExact(yf)) { ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03050000 && defined(PyCoro_CheckExact) && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) if (PyCoro_CheckExact(yf)) { ret = _PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); } else #endif { if (value == Py_None) ret = Py_TYPE(yf)->tp_iternext(yf); else ret = __Pyx_PyObject_CallMethod1(yf, __pyx_n_s_send, value); } gen->is_running = 0; if (likely(ret)) { return ret; } retval = __Pyx_Coroutine_FinishDelegation(gen); } else { retval = __Pyx_Coroutine_SendEx(gen, value, 0); } return __Pyx_Coroutine_MethodReturn(self, retval); } static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { PyObject *retval = NULL; int err = 0; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { retval = __Pyx_Coroutine_Close(yf); if (!retval) return -1; } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { retval = __Pyx_Coroutine_Close(yf); if (!retval) return -1; } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { retval = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf, NULL); if (!retval) return -1; } else #endif #ifdef __Pyx_AsyncGen_USED if (__pyx_PyAsyncGenASend_CheckExact(yf)) { retval = __Pyx_async_gen_asend_close(yf, NULL); } else if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { retval = __Pyx_async_gen_athrow_close(yf, NULL); } else #endif { PyObject *meth; gen->is_running = 1; meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_close); if (unlikely(!meth)) { if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_WriteUnraisable(yf); } PyErr_Clear(); } else { retval = PyObject_CallFunction(meth, NULL); Py_DECREF(meth); if (!retval) err = -1; } gen->is_running = 0; } Py_XDECREF(retval); return err; } static PyObject *__Pyx_Generator_Next(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; PyObject *yf = gen->yieldfrom; if (unlikely(gen->is_running)) return __Pyx_Coroutine_AlreadyRunningError(gen); if (yf) { PyObject *ret; gen->is_running = 1; #ifdef __Pyx_Generator_USED if (__Pyx_Generator_CheckExact(yf)) { ret = __Pyx_Generator_Next(yf); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03030000 && (defined(__linux__) || PY_VERSION_HEX >= 0x030600B3) if (PyGen_CheckExact(yf)) { ret = _PyGen_Send((PyGenObject*)yf, NULL); } else #endif #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(yf)) { ret = __Pyx_Coroutine_Send(yf, Py_None); } else #endif ret = Py_TYPE(yf)->tp_iternext(yf); gen->is_running = 0; if (likely(ret)) { return ret; } return __Pyx_Coroutine_FinishDelegation(gen); } return __Pyx_Coroutine_SendEx(gen, Py_None, 0); } static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, CYTHON_UNUSED PyObject *arg) { return __Pyx_Coroutine_Close(self); } static PyObject *__Pyx_Coroutine_Close(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject *retval, *raised_exception; PyObject *yf = gen->yieldfrom; int err = 0; if (unlikely(gen->is_running)) return __Pyx_Coroutine_AlreadyRunningError(gen); if (yf) { Py_INCREF(yf); err = __Pyx_Coroutine_CloseIter(gen, yf); __Pyx_Coroutine_Undelegate(gen); Py_DECREF(yf); } if (err == 0) PyErr_SetNone(PyExc_GeneratorExit); retval = __Pyx_Coroutine_SendEx(gen, NULL, 1); if (unlikely(retval)) { const char *msg; Py_DECREF(retval); if ((0)) { #ifdef __Pyx_Coroutine_USED } else if (__Pyx_Coroutine_Check(self)) { msg = "coroutine ignored GeneratorExit"; #endif #ifdef __Pyx_AsyncGen_USED } else if (__Pyx_AsyncGen_CheckExact(self)) { #if PY_VERSION_HEX < 0x03060000 msg = "async generator ignored GeneratorExit - might require Python 3.6+ finalisation (PEP 525)"; #else msg = "async generator ignored GeneratorExit"; #endif #endif } else { msg = "generator ignored GeneratorExit"; } PyErr_SetString(PyExc_RuntimeError, msg); return NULL; } raised_exception = PyErr_Occurred(); if (likely(!raised_exception || __Pyx_PyErr_GivenExceptionMatches2(raised_exception, PyExc_GeneratorExit, PyExc_StopIteration))) { if (raised_exception) PyErr_Clear(); Py_INCREF(Py_None); return Py_None; } return NULL; } static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, PyObject *args, int close_on_genexit) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject *yf = gen->yieldfrom; if (unlikely(gen->is_running)) return __Pyx_Coroutine_AlreadyRunningError(gen); if (yf) { PyObject *ret; Py_INCREF(yf); if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { int err = __Pyx_Coroutine_CloseIter(gen, yf); Py_DECREF(yf); __Pyx_Coroutine_Undelegate(gen); if (err < 0) return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); goto throw_here; } gen->is_running = 1; if (0 #ifdef __Pyx_Generator_USED || __Pyx_Generator_CheckExact(yf) #endif #ifdef __Pyx_Coroutine_USED || __Pyx_Coroutine_Check(yf) #endif ) { ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); #ifdef __Pyx_Coroutine_USED } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); #endif } else { PyObject *meth = __Pyx_PyObject_GetAttrStr(yf, __pyx_n_s_throw); if (unlikely(!meth)) { Py_DECREF(yf); if (!PyErr_ExceptionMatches(PyExc_AttributeError)) { gen->is_running = 0; return NULL; } PyErr_Clear(); __Pyx_Coroutine_Undelegate(gen); gen->is_running = 0; goto throw_here; } if (likely(args)) { ret = PyObject_CallObject(meth, args); } else { ret = PyObject_CallFunctionObjArgs(meth, typ, val, tb, NULL); } Py_DECREF(meth); } gen->is_running = 0; Py_DECREF(yf); if (!ret) { ret = __Pyx_Coroutine_FinishDelegation(gen); } return __Pyx_Coroutine_MethodReturn(self, ret); } throw_here: __Pyx_Raise(typ, val, tb, NULL); return __Pyx_Coroutine_MethodReturn(self, __Pyx_Coroutine_SendEx(gen, NULL, 0)); } static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { PyObject *typ; PyObject *val = NULL; PyObject *tb = NULL; if (!PyArg_UnpackTuple(args, (char *)"throw", 1, 3, &typ, &val, &tb)) return NULL; return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1); } static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { Py_VISIT(exc_state->exc_type); Py_VISIT(exc_state->exc_value); Py_VISIT(exc_state->exc_traceback); return 0; } static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { Py_VISIT(gen->closure); Py_VISIT(gen->classobj); Py_VISIT(gen->yieldfrom); return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); } static int __Pyx_Coroutine_clear(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; Py_CLEAR(gen->closure); Py_CLEAR(gen->classobj); Py_CLEAR(gen->yieldfrom); __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); } #endif Py_CLEAR(gen->gi_code); Py_CLEAR(gen->gi_name); Py_CLEAR(gen->gi_qualname); Py_CLEAR(gen->gi_modulename); return 0; } static void __Pyx_Coroutine_dealloc(PyObject *self) { __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; PyObject_GC_UnTrack(gen); if (gen->gi_weakreflist != NULL) PyObject_ClearWeakRefs(self); if (gen->resume_label >= 0) { PyObject_GC_Track(self); #if PY_VERSION_HEX >= 0x030400a1 && CYTHON_USE_TP_FINALIZE if (PyObject_CallFinalizerFromDealloc(self)) #else Py_TYPE(gen)->tp_del(self); if (self->ob_refcnt > 0) #endif { return; } PyObject_GC_UnTrack(self); } #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { /* We have to handle this case for asynchronous generators right here, because this code has to be between UNTRACK and GC_Del. */ Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); } #endif __Pyx_Coroutine_clear(self); PyObject_GC_Del(gen); } static void __Pyx_Coroutine_del(PyObject *self) { PyObject *error_type, *error_value, *error_traceback; __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; __Pyx_PyThreadState_declare if (gen->resume_label < 0) { return; } #if !CYTHON_USE_TP_FINALIZE assert(self->ob_refcnt == 0); self->ob_refcnt = 1; #endif __Pyx_PyThreadState_assign __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); #ifdef __Pyx_AsyncGen_USED if (__Pyx_AsyncGen_CheckExact(self)) { __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; PyObject *finalizer = agen->ag_finalizer; if (finalizer && !agen->ag_closed) { PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); if (unlikely(!res)) { PyErr_WriteUnraisable(self); } else { Py_DECREF(res); } __Pyx_ErrRestore(error_type, error_value, error_traceback); return; } } #endif if (unlikely(gen->resume_label == 0 && !error_value)) { #ifdef __Pyx_Coroutine_USED #ifdef __Pyx_Generator_USED if (!__Pyx_Generator_CheckExact(self)) #endif { PyObject_GC_UnTrack(self); #if PY_MAJOR_VERSION >= 3 || defined(PyErr_WarnFormat) if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) PyErr_WriteUnraisable(self); #else {PyObject *msg; char *cmsg; #if CYTHON_COMPILING_IN_PYPY msg = NULL; cmsg = (char*) "coroutine was never awaited"; #else char *cname; PyObject *qualname; qualname = gen->gi_qualname; cname = PyString_AS_STRING(qualname); msg = PyString_FromFormat("coroutine '%.50s' was never awaited", cname); if (unlikely(!msg)) { PyErr_Clear(); cmsg = (char*) "coroutine was never awaited"; } else { cmsg = PyString_AS_STRING(msg); } #endif if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, cmsg, 1) < 0)) PyErr_WriteUnraisable(self); Py_XDECREF(msg);} #endif PyObject_GC_Track(self); } #endif } else { PyObject *res = __Pyx_Coroutine_Close(self); if (unlikely(!res)) { if (PyErr_Occurred()) PyErr_WriteUnraisable(self); } else { Py_DECREF(res); } } __Pyx_ErrRestore(error_type, error_value, error_traceback); #if !CYTHON_USE_TP_FINALIZE assert(self->ob_refcnt > 0); if (--self->ob_refcnt == 0) { return; } { Py_ssize_t refcnt = self->ob_refcnt; _Py_NewReference(self); self->ob_refcnt = refcnt; } #if CYTHON_COMPILING_IN_CPYTHON assert(PyType_IS_GC(self->ob_type) && _Py_AS_GC(self)->gc.gc_refs != _PyGC_REFS_UNTRACKED); _Py_DEC_REFTOTAL; #endif #ifdef COUNT_ALLOCS --Py_TYPE(self)->tp_frees; --Py_TYPE(self)->tp_allocs; #endif #endif } static PyObject * __Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) { PyObject *name = self->gi_name; if (unlikely(!name)) name = Py_None; Py_INCREF(name); return name; } static int __Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__name__ must be set to a string object"); return -1; } tmp = self->gi_name; Py_INCREF(value); self->gi_name = value; Py_XDECREF(tmp); return 0; } static PyObject * __Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, CYTHON_UNUSED void *context) { PyObject *name = self->gi_qualname; if (unlikely(!name)) name = Py_None; Py_INCREF(name); return name; } static int __Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, CYTHON_UNUSED void *context) { PyObject *tmp; #if PY_MAJOR_VERSION >= 3 if (unlikely(value == NULL || !PyUnicode_Check(value))) #else if (unlikely(value == NULL || !PyString_Check(value))) #endif { PyErr_SetString(PyExc_TypeError, "__qualname__ must be set to a string object"); return -1; } tmp = self->gi_qualname; Py_INCREF(value); self->gi_qualname = value; Py_XDECREF(tmp); return 0; } static __pyx_CoroutineObject *__Pyx__Coroutine_New( PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); if (unlikely(!gen)) return NULL; return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); } static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, PyObject *name, PyObject *qualname, PyObject *module_name) { gen->body = body; gen->closure = closure; Py_XINCREF(closure); gen->is_running = 0; gen->resume_label = 0; gen->classobj = NULL; gen->yieldfrom = NULL; gen->gi_exc_state.exc_type = NULL; gen->gi_exc_state.exc_value = NULL; gen->gi_exc_state.exc_traceback = NULL; #if CYTHON_USE_EXC_INFO_STACK gen->gi_exc_state.previous_item = NULL; #endif gen->gi_weakreflist = NULL; Py_XINCREF(qualname); gen->gi_qualname = qualname; Py_XINCREF(name); gen->gi_name = name; Py_XINCREF(module_name); gen->gi_modulename = module_name; Py_XINCREF(code); gen->gi_code = code; PyObject_GC_Track(gen); return gen; } /* PyObject_GenericGetAttrNoDict */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { PyErr_Format(PyExc_AttributeError, #if PY_MAJOR_VERSION >= 3 "'%.50s' object has no attribute '%U'", tp->tp_name, attr_name); #else "'%.50s' object has no attribute '%.400s'", tp->tp_name, PyString_AS_STRING(attr_name)); #endif return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { PyObject *descr; PyTypeObject *tp = Py_TYPE(obj); if (unlikely(!PyString_Check(attr_name))) { return PyObject_GenericGetAttr(obj, attr_name); } assert(!tp->tp_dictoffset); descr = _PyType_Lookup(tp, attr_name); if (unlikely(!descr)) { return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); } Py_INCREF(descr); #if PY_MAJOR_VERSION < 3 if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) #endif { descrgetfunc f = Py_TYPE(descr)->tp_descr_get; if (unlikely(f)) { PyObject *res = f(descr, obj, (PyObject *)tp); Py_DECREF(descr); return res; } } return descr; } #endif /* PatchModuleWithCoroutine */ static PyObject* __Pyx_Coroutine_patch_module(PyObject* module, const char* py_code) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) int result; PyObject *globals, *result_obj; globals = PyDict_New(); if (unlikely(!globals)) goto ignore; result = PyDict_SetItemString(globals, "_cython_coroutine_type", #ifdef __Pyx_Coroutine_USED (PyObject*)__pyx_CoroutineType); #else Py_None); #endif if (unlikely(result < 0)) goto ignore; result = PyDict_SetItemString(globals, "_cython_generator_type", #ifdef __Pyx_Generator_USED (PyObject*)__pyx_GeneratorType); #else Py_None); #endif if (unlikely(result < 0)) goto ignore; if (unlikely(PyDict_SetItemString(globals, "_module", module) < 0)) goto ignore; if (unlikely(PyDict_SetItemString(globals, "__builtins__", __pyx_b) < 0)) goto ignore; result_obj = PyRun_String(py_code, Py_file_input, globals, globals); if (unlikely(!result_obj)) goto ignore; Py_DECREF(result_obj); Py_DECREF(globals); return module; ignore: Py_XDECREF(globals); PyErr_WriteUnraisable(module); if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, "Cython module failed to patch module with custom type", 1) < 0)) { Py_DECREF(module); module = NULL; } #else py_code++; #endif return module; } /* PatchGeneratorABC */ #ifndef CYTHON_REGISTER_ABCS #define CYTHON_REGISTER_ABCS 1 #endif #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) static PyObject* __Pyx_patch_abc_module(PyObject *module); static PyObject* __Pyx_patch_abc_module(PyObject *module) { module = __Pyx_Coroutine_patch_module( module, "" "if _cython_generator_type is not None:\n" " try: Generator = _module.Generator\n" " except AttributeError: pass\n" " else: Generator.register(_cython_generator_type)\n" "if _cython_coroutine_type is not None:\n" " try: Coroutine = _module.Coroutine\n" " except AttributeError: pass\n" " else: Coroutine.register(_cython_coroutine_type)\n" ); return module; } #endif static int __Pyx_patch_abc(void) { #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED) static int abc_patched = 0; if (CYTHON_REGISTER_ABCS && !abc_patched) { PyObject *module; module = PyImport_ImportModule((PY_MAJOR_VERSION >= 3) ? "collections.abc" : "collections"); if (!module) { PyErr_WriteUnraisable(NULL); if (unlikely(PyErr_WarnEx(PyExc_RuntimeWarning, ((PY_MAJOR_VERSION >= 3) ? "Cython module failed to register with collections.abc module" : "Cython module failed to register with collections module"), 1) < 0)) { return -1; } } else { module = __Pyx_patch_abc_module(module); abc_patched = 1; if (unlikely(!module)) return -1; Py_DECREF(module); } module = PyImport_ImportModule("backports_abc"); if (module) { module = __Pyx_patch_abc_module(module); Py_XDECREF(module); } if (!module) { PyErr_Clear(); } } #else if ((0)) __Pyx_Coroutine_patch_module(NULL, NULL); #endif return 0; } /* Coroutine */ static void __Pyx_CoroutineAwait_dealloc(PyObject *self) { PyObject_GC_UnTrack(self); Py_CLEAR(((__pyx_CoroutineAwaitObject*)self)->coroutine); PyObject_GC_Del(self); } static int __Pyx_CoroutineAwait_traverse(__pyx_CoroutineAwaitObject *self, visitproc visit, void *arg) { Py_VISIT(self->coroutine); return 0; } static int __Pyx_CoroutineAwait_clear(__pyx_CoroutineAwaitObject *self) { Py_CLEAR(self->coroutine); return 0; } static PyObject *__Pyx_CoroutineAwait_Next(__pyx_CoroutineAwaitObject *self) { return __Pyx_Generator_Next(self->coroutine); } static PyObject *__Pyx_CoroutineAwait_Send(__pyx_CoroutineAwaitObject *self, PyObject *value) { return __Pyx_Coroutine_Send(self->coroutine, value); } static PyObject *__Pyx_CoroutineAwait_Throw(__pyx_CoroutineAwaitObject *self, PyObject *args) { return __Pyx_Coroutine_Throw(self->coroutine, args); } static PyObject *__Pyx_CoroutineAwait_Close(__pyx_CoroutineAwaitObject *self, CYTHON_UNUSED PyObject *arg) { return __Pyx_Coroutine_Close(self->coroutine); } static PyObject *__Pyx_CoroutineAwait_self(PyObject *self) { Py_INCREF(self); return self; } #if !CYTHON_COMPILING_IN_PYPY static PyObject *__Pyx_CoroutineAwait_no_new(CYTHON_UNUSED PyTypeObject *type, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwargs) { PyErr_SetString(PyExc_TypeError, "cannot instantiate type, use 'await coroutine' instead"); return NULL; } #endif static PyMethodDef __pyx_CoroutineAwait_methods[] = { {"send", (PyCFunction) __Pyx_CoroutineAwait_Send, METH_O, (char*) PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next yielded value or raise StopIteration.")}, {"throw", (PyCFunction) __Pyx_CoroutineAwait_Throw, METH_VARARGS, (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next yielded value or raise StopIteration.")}, {"close", (PyCFunction) __Pyx_CoroutineAwait_Close, METH_NOARGS, (char*) PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")}, {0, 0, 0, 0} }; static PyTypeObject __pyx_CoroutineAwaitType_type = { PyVarObject_HEAD_INIT(0, 0) "coroutine_wrapper", sizeof(__pyx_CoroutineAwaitObject), 0, (destructor) __Pyx_CoroutineAwait_dealloc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, PyDoc_STR("A wrapper object implementing __await__ for coroutines."), (traverseproc) __Pyx_CoroutineAwait_traverse, (inquiry) __Pyx_CoroutineAwait_clear, 0, 0, __Pyx_CoroutineAwait_self, (iternextfunc) __Pyx_CoroutineAwait_Next, __pyx_CoroutineAwait_methods, 0 , 0 , 0, 0, 0, 0, 0, 0, 0, #if !CYTHON_COMPILING_IN_PYPY __Pyx_CoroutineAwait_no_new, #else 0, #endif 0, 0, 0, 0, 0, 0, 0, 0, 0, #if PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif }; #if PY_VERSION_HEX < 0x030500B1 || defined(__Pyx_IterableCoroutine_USED) || CYTHON_USE_ASYNC_SLOTS static CYTHON_INLINE PyObject *__Pyx__Coroutine_await(PyObject *coroutine) { __pyx_CoroutineAwaitObject *await = PyObject_GC_New(__pyx_CoroutineAwaitObject, __pyx_CoroutineAwaitType); if (unlikely(!await)) return NULL; Py_INCREF(coroutine); await->coroutine = coroutine; PyObject_GC_Track(await); return (PyObject*)await; } #endif #if PY_VERSION_HEX < 0x030500B1 static PyObject *__Pyx_Coroutine_await_method(PyObject *coroutine, CYTHON_UNUSED PyObject *arg) { return __Pyx__Coroutine_await(coroutine); } #endif #if defined(__Pyx_IterableCoroutine_USED) || CYTHON_USE_ASYNC_SLOTS static PyObject *__Pyx_Coroutine_await(PyObject *coroutine) { if (unlikely(!coroutine || !__Pyx_Coroutine_Check(coroutine))) { PyErr_SetString(PyExc_TypeError, "invalid input, expected coroutine"); return NULL; } return __Pyx__Coroutine_await(coroutine); } #endif static PyObject * __Pyx_Coroutine_get_frame(CYTHON_UNUSED __pyx_CoroutineObject *self, CYTHON_UNUSED void *context) { Py_RETURN_NONE; } #if CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1 static PyObject *__Pyx_Coroutine_compare(PyObject *obj, PyObject *other, int op) { PyObject* result; switch (op) { case Py_EQ: result = (other == obj) ? Py_True : Py_False; break; case Py_NE: result = (other != obj) ? Py_True : Py_False; break; default: result = Py_NotImplemented; } Py_INCREF(result); return result; } #endif static PyMethodDef __pyx_Coroutine_methods[] = { {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, (char*) PyDoc_STR("send(arg) -> send 'arg' into coroutine,\nreturn next iterated value or raise StopIteration.")}, {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, (char*) PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in coroutine,\nreturn next iterated value or raise StopIteration.")}, {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, (char*) PyDoc_STR("close() -> raise GeneratorExit inside coroutine.")}, #if PY_VERSION_HEX < 0x030500B1 {"__await__", (PyCFunction) __Pyx_Coroutine_await_method, METH_NOARGS, (char*) PyDoc_STR("__await__() -> return an iterator to be used in await expression.")}, #endif {0, 0, 0, 0} }; static PyMemberDef __pyx_Coroutine_memberlist[] = { {(char *) "cr_running", T_BOOL, offsetof(__pyx_CoroutineObject, is_running), READONLY, NULL}, {(char*) "cr_await", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, (char*) PyDoc_STR("object being awaited, or None")}, {(char*) "cr_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), PY_WRITE_RESTRICTED, 0}, {0, 0, 0, 0, 0} }; static PyGetSetDef __pyx_Coroutine_getsets[] = { {(char *) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, (char*) PyDoc_STR("name of the coroutine"), 0}, {(char *) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, (char*) PyDoc_STR("qualified name of the coroutine"), 0}, {(char *) "cr_frame", (getter)__Pyx_Coroutine_get_frame, NULL, (char*) PyDoc_STR("Frame of the coroutine"), 0}, {0, 0, 0, 0, 0} }; #if CYTHON_USE_ASYNC_SLOTS static __Pyx_PyAsyncMethodsStruct __pyx_Coroutine_as_async = { __Pyx_Coroutine_await, 0, 0, }; #endif static PyTypeObject __pyx_CoroutineType_type = { PyVarObject_HEAD_INIT(0, 0) "coroutine", sizeof(__pyx_CoroutineObject), 0, (destructor) __Pyx_Coroutine_dealloc, 0, 0, 0, #if CYTHON_USE_ASYNC_SLOTS &__pyx_Coroutine_as_async, #else 0, #endif 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, 0, (traverseproc) __Pyx_Coroutine_traverse, 0, #if CYTHON_USE_ASYNC_SLOTS && CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1 __Pyx_Coroutine_compare, #else 0, #endif offsetof(__pyx_CoroutineObject, gi_weakreflist), 0, 0, __pyx_Coroutine_methods, __pyx_Coroutine_memberlist, __pyx_Coroutine_getsets, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, #if CYTHON_USE_TP_FINALIZE 0, #else __Pyx_Coroutine_del, #endif 0, #if CYTHON_USE_TP_FINALIZE __Pyx_Coroutine_del, #elif PY_VERSION_HEX >= 0x030400a1 0, #endif #if PY_VERSION_HEX >= 0x030800b1 0, #endif #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 0, #endif }; static int __pyx_Coroutine_init(void) { __pyx_CoroutineType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict; __pyx_CoroutineType = __Pyx_FetchCommonType(&__pyx_CoroutineType_type); if (unlikely(!__pyx_CoroutineType)) return -1; #ifdef __Pyx_IterableCoroutine_USED if (unlikely(__pyx_IterableCoroutine_init() == -1)) return -1; #endif __pyx_CoroutineAwaitType = __Pyx_FetchCommonType(&__pyx_CoroutineAwaitType_type); if (unlikely(!__pyx_CoroutineAwaitType)) return -1; return 0; } /* GetAwaitIter */ static CYTHON_INLINE PyObject *__Pyx_Coroutine_GetAwaitableIter(PyObject *o) { #ifdef __Pyx_Coroutine_USED if (__Pyx_Coroutine_Check(o)) { return __Pyx_NewRef(o); } #endif return __Pyx__Coroutine_GetAwaitableIter(o); } static void __Pyx_Coroutine_AwaitableIterError(PyObject *source) { #if PY_VERSION_HEX >= 0x030600B3 || defined(_PyErr_FormatFromCause) _PyErr_FormatFromCause( PyExc_TypeError, "'async for' received an invalid object " "from __anext__: %.100s", Py_TYPE(source)->tp_name); #elif PY_MAJOR_VERSION >= 3 PyObject *exc, *val, *val2, *tb; assert(PyErr_Occurred()); PyErr_Fetch(&exc, &val, &tb); PyErr_NormalizeException(&exc, &val, &tb); if (tb != NULL) { PyException_SetTraceback(val, tb); Py_DECREF(tb); } Py_DECREF(exc); assert(!PyErr_Occurred()); PyErr_Format( PyExc_TypeError, "'async for' received an invalid object " "from __anext__: %.100s", Py_TYPE(source)->tp_name); PyErr_Fetch(&exc, &val2, &tb); PyErr_NormalizeException(&exc, &val2, &tb); Py_INCREF(val); PyException_SetCause(val2, val); PyException_SetContext(val2, val); PyErr_Restore(exc, val2, tb); #else source++; #endif } static PyObject *__Pyx__Coroutine_GetAwaitableIter(PyObject *obj) { PyObject *res; #if CYTHON_USE_ASYNC_SLOTS __Pyx_PyAsyncMethodsStruct* am = __Pyx_PyType_AsAsync(obj); if (likely(am && am->am_await)) { res = (*am->am_await)(obj); } else #endif #if PY_VERSION_HEX >= 0x030500B2 || defined(PyCoro_CheckExact) if (PyCoro_CheckExact(obj)) { return __Pyx_NewRef(obj); } else #endif #if CYTHON_COMPILING_IN_CPYTHON && defined(CO_ITERABLE_COROUTINE) if (PyGen_CheckExact(obj) && ((PyGenObject*)obj)->gi_code && ((PyCodeObject *)((PyGenObject*)obj)->gi_code)->co_flags & CO_ITERABLE_COROUTINE) { return __Pyx_NewRef(obj); } else #endif { PyObject *method = NULL; int is_method = __Pyx_PyObject_GetMethod(obj, __pyx_n_s_await, &method); if (likely(is_method)) { res = __Pyx_PyObject_CallOneArg(method, obj); } else if (likely(method)) { res = __Pyx_PyObject_CallNoArg(method); } else goto slot_error; Py_DECREF(method); } if (unlikely(!res)) { __Pyx_Coroutine_AwaitableIterError(obj); goto bad; } if (unlikely(!PyIter_Check(res))) { PyErr_Format(PyExc_TypeError, "__await__() returned non-iterator of type '%.100s'", Py_TYPE(res)->tp_name); Py_CLEAR(res); } else { int is_coroutine = 0; #ifdef __Pyx_Coroutine_USED is_coroutine |= __Pyx_Coroutine_Check(res); #endif #if PY_VERSION_HEX >= 0x030500B2 || defined(PyCoro_CheckExact) is_coroutine |= PyCoro_CheckExact(res); #endif if (unlikely(is_coroutine)) { /* __await__ must return an *iterator*, not a coroutine or another awaitable (see PEP 492) */ PyErr_SetString(PyExc_TypeError, "__await__() returned a coroutine"); Py_CLEAR(res); } } return res; slot_error: PyErr_Format(PyExc_TypeError, "object %.100s can't be used in 'await' expression", Py_TYPE(obj)->tp_name); bad: return NULL; } /* CoroutineYieldFrom */ static PyObject* __Pyx__Coroutine_Yield_From_Generic(__pyx_CoroutineObject *gen, PyObject *source) { PyObject *retval; PyObject *source_gen = __Pyx__Coroutine_GetAwaitableIter(source); if (unlikely(!source_gen)) { return NULL; } if (__Pyx_Coroutine_Check(source_gen)) { retval = __Pyx_Generator_Next(source_gen); } else { #if CYTHON_USE_TYPE_SLOTS retval = Py_TYPE(source_gen)->tp_iternext(source_gen); #else retval = PyIter_Next(source_gen); #endif } if (retval) { gen->yieldfrom = source_gen; return retval; } Py_DECREF(source_gen); return NULL; } static CYTHON_INLINE PyObject* __Pyx_Coroutine_Yield_From(__pyx_CoroutineObject *gen, PyObject *source) { PyObject *retval; if (__Pyx_Coroutine_Check(source)) { if (unlikely(((__pyx_CoroutineObject*)source)->yieldfrom)) { PyErr_SetString( PyExc_RuntimeError, "coroutine is being awaited already"); return NULL; } retval = __Pyx_Generator_Next(source); #ifdef __Pyx_AsyncGen_USED } else if (__pyx_PyAsyncGenASend_CheckExact(source)) { retval = __Pyx_async_gen_asend_iternext(source); #endif } else { return __Pyx__Coroutine_Yield_From_Generic(gen, source); } if (retval) { Py_INCREF(source); gen->yieldfrom = source; } return retval; } /* ExtTypeTest */ static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { if (unlikely(!type)) { PyErr_SetString(PyExc_SystemError, "Missing type object"); return 0; } if (likely(__Pyx_TypeCheck(obj, type))) return 1; PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", Py_TYPE(obj)->tp_name, type->tp_name); return 0; } /* PyErrExceptionMatches */ #if CYTHON_FAST_THREAD_STATE static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; icurexc_type; if (exc_type == err) return 1; if (unlikely(!exc_type)) return 0; if (unlikely(PyTuple_Check(err))) return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); } #endif /* GetException */ #if CYTHON_FAST_THREAD_STATE static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) #else static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) #endif { PyObject *local_type, *local_value, *local_tb; #if CYTHON_FAST_THREAD_STATE PyObject *tmp_type, *tmp_value, *tmp_tb; local_type = tstate->curexc_type; local_value = tstate->curexc_value; local_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; #else PyErr_Fetch(&local_type, &local_value, &local_tb); #endif PyErr_NormalizeException(&local_type, &local_value, &local_tb); #if CYTHON_FAST_THREAD_STATE if (unlikely(tstate->curexc_type)) #else if (unlikely(PyErr_Occurred())) #endif goto bad; #if PY_MAJOR_VERSION >= 3 if (local_tb) { if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) goto bad; } #endif Py_XINCREF(local_tb); Py_XINCREF(local_type); Py_XINCREF(local_value); *type = local_type; *value = local_value; *tb = local_tb; #if CYTHON_FAST_THREAD_STATE #if CYTHON_USE_EXC_INFO_STACK { _PyErr_StackItem *exc_info = tstate->exc_info; tmp_type = exc_info->exc_type; tmp_value = exc_info->exc_value; tmp_tb = exc_info->exc_traceback; exc_info->exc_type = local_type; exc_info->exc_value = local_value; exc_info->exc_traceback = local_tb; } #else tmp_type = tstate->exc_type; tmp_value = tstate->exc_value; tmp_tb = tstate->exc_traceback; tstate->exc_type = local_type; tstate->exc_value = local_value; tstate->exc_traceback = local_tb; #endif Py_XDECREF(tmp_type); Py_XDECREF(tmp_value); Py_XDECREF(tmp_tb); #else PyErr_SetExcInfo(local_type, local_value, local_tb); #endif return 0; bad: *type = 0; *value = 0; *tb = 0; Py_XDECREF(local_type); Py_XDECREF(local_value); Py_XDECREF(local_tb); return -1; } /* BytesEquals */ static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else if (s1 == s2) { return (equals == Py_EQ); } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { const char *ps1, *ps2; Py_ssize_t length = PyBytes_GET_SIZE(s1); if (length != PyBytes_GET_SIZE(s2)) return (equals == Py_NE); ps1 = PyBytes_AS_STRING(s1); ps2 = PyBytes_AS_STRING(s2); if (ps1[0] != ps2[0]) { return (equals == Py_NE); } else if (length == 1) { return (equals == Py_EQ); } else { int result; #if CYTHON_USE_UNICODE_INTERNALS Py_hash_t hash1, hash2; hash1 = ((PyBytesObject*)s1)->ob_shash; hash2 = ((PyBytesObject*)s2)->ob_shash; if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { return (equals == Py_NE); } #endif result = memcmp(ps1, ps2, (size_t)length); return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { return (equals == Py_NE); } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { return (equals == Py_NE); } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } #endif } /* UnicodeEquals */ static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { #if CYTHON_COMPILING_IN_PYPY return PyObject_RichCompareBool(s1, s2, equals); #else #if PY_MAJOR_VERSION < 3 PyObject* owned_ref = NULL; #endif int s1_is_unicode, s2_is_unicode; if (s1 == s2) { goto return_eq; } s1_is_unicode = PyUnicode_CheckExact(s1); s2_is_unicode = PyUnicode_CheckExact(s2); #if PY_MAJOR_VERSION < 3 if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { owned_ref = PyUnicode_FromObject(s2); if (unlikely(!owned_ref)) return -1; s2 = owned_ref; s2_is_unicode = 1; } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { owned_ref = PyUnicode_FromObject(s1); if (unlikely(!owned_ref)) return -1; s1 = owned_ref; s1_is_unicode = 1; } else if (((!s2_is_unicode) & (!s1_is_unicode))) { return __Pyx_PyBytes_Equals(s1, s2, equals); } #endif if (s1_is_unicode & s2_is_unicode) { Py_ssize_t length; int kind; void *data1, *data2; if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) return -1; length = __Pyx_PyUnicode_GET_LENGTH(s1); if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { goto return_ne; } #if CYTHON_USE_UNICODE_INTERNALS { Py_hash_t hash1, hash2; #if CYTHON_PEP393_ENABLED hash1 = ((PyASCIIObject*)s1)->hash; hash2 = ((PyASCIIObject*)s2)->hash; #else hash1 = ((PyUnicodeObject*)s1)->hash; hash2 = ((PyUnicodeObject*)s2)->hash; #endif if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { goto return_ne; } } #endif kind = __Pyx_PyUnicode_KIND(s1); if (kind != __Pyx_PyUnicode_KIND(s2)) { goto return_ne; } data1 = __Pyx_PyUnicode_DATA(s1); data2 = __Pyx_PyUnicode_DATA(s2); if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { goto return_ne; } else if (length == 1) { goto return_eq; } else { int result = memcmp(data1, data2, (size_t)(length * kind)); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ) ? (result == 0) : (result != 0); } } else if ((s1 == Py_None) & s2_is_unicode) { goto return_ne; } else if ((s2 == Py_None) & s1_is_unicode) { goto return_ne; } else { int result; PyObject* py_result = PyObject_RichCompare(s1, s2, equals); #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif if (!py_result) return -1; result = __Pyx_PyObject_IsTrue(py_result); Py_DECREF(py_result); return result; } return_eq: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_EQ); return_ne: #if PY_MAJOR_VERSION < 3 Py_XDECREF(owned_ref); #endif return (equals == Py_NE); #endif } /* StringJoin */ #if !CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyBytes_Join(PyObject* sep, PyObject* values) { return PyObject_CallMethodObjArgs(sep, __pyx_n_s_join, values, NULL); } #endif /* GetItemInt */ static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { PyObject *r; if (!j) return NULL; r = PyObject_GetItem(o, j); Py_DECREF(j); return r; } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyList_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { PyObject *r = PyList_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS Py_ssize_t wrapped_i = i; if (wraparound & unlikely(i < 0)) { wrapped_i += PyTuple_GET_SIZE(o); } if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); Py_INCREF(r); return r; } return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); #else return PySequence_GetItem(o, i); #endif } static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) { #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS if (is_list || PyList_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { PyObject *r = PyList_GET_ITEM(o, n); Py_INCREF(r); return r; } } else if (PyTuple_CheckExact(o)) { Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { PyObject *r = PyTuple_GET_ITEM(o, n); Py_INCREF(r); return r; } } else { PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; if (likely(m && m->sq_item)) { if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { Py_ssize_t l = m->sq_length(o); if (likely(l >= 0)) { i += l; } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) return NULL; PyErr_Clear(); } } return m->sq_item(o, i); } } #else if (is_list || PySequence_Check(o)) { return PySequence_GetItem(o, i); } #endif return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); } /* RaiseTooManyValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { PyErr_Format(PyExc_ValueError, "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); } /* RaiseNeedMoreValuesToUnpack */ static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { PyErr_Format(PyExc_ValueError, "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", index, (index == 1) ? "" : "s"); } /* IterFinish */ static CYTHON_INLINE int __Pyx_IterFinish(void) { #if CYTHON_FAST_THREAD_STATE PyThreadState *tstate = __Pyx_PyThreadState_Current; PyObject* exc_type = tstate->curexc_type; if (unlikely(exc_type)) { if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) { PyObject *exc_value, *exc_tb; exc_value = tstate->curexc_value; exc_tb = tstate->curexc_traceback; tstate->curexc_type = 0; tstate->curexc_value = 0; tstate->curexc_traceback = 0; Py_DECREF(exc_type); Py_XDECREF(exc_value); Py_XDECREF(exc_tb); return 0; } else { return -1; } } return 0; #else if (unlikely(PyErr_Occurred())) { if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { PyErr_Clear(); return 0; } else { return -1; } } return 0; #endif } /* UnpackItemEndCheck */ static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { if (unlikely(retval)) { Py_DECREF(retval); __Pyx_RaiseTooManyValuesError(expected); return -1; } else { return __Pyx_IterFinish(); } return 0; } /* KeywordStringCheck */ static int __Pyx_CheckKeywordStrings( PyObject *kwdict, const char* function_name, int kw_allowed) { PyObject* key = 0; Py_ssize_t pos = 0; #if CYTHON_COMPILING_IN_PYPY if (!kw_allowed && PyDict_Next(kwdict, &pos, &key, 0)) goto invalid_keyword; return 1; #else while (PyDict_Next(kwdict, &pos, &key, 0)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyString_Check(key))) #endif if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; } if ((!kw_allowed) && unlikely(key)) goto invalid_keyword; return 1; invalid_keyword_type: PyErr_Format(PyExc_TypeError, "%.200s() keywords must be strings", function_name); return 0; #endif invalid_keyword: PyErr_Format(PyExc_TypeError, #if PY_MAJOR_VERSION < 3 "%.200s() got an unexpected keyword argument '%.200s'", function_name, PyString_AsString(key)); #else "%s() got an unexpected keyword argument '%U'", function_name, key); #endif return 0; } /* GetAttr */ static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { #if CYTHON_USE_TYPE_SLOTS #if PY_MAJOR_VERSION >= 3 if (likely(PyUnicode_Check(n))) #else if (likely(PyString_Check(n))) #endif return __Pyx_PyObject_GetAttrStr(o, n); #endif return PyObject_GetAttr(o, n); } /* GetAttr3 */ static PyObject *__Pyx_GetAttr3Default(PyObject *d) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) return NULL; __Pyx_PyErr_Clear(); Py_INCREF(d); return d; } static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { PyObject *r = __Pyx_GetAttr(o, n); return (likely(r)) ? r : __Pyx_GetAttr3Default(d); } /* ReturnWithStopIteration */ static void __Pyx__ReturnWithStopIteration(PyObject* value) { PyObject *exc, *args; #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_PYSTON __Pyx_PyThreadState_declare if ((PY_VERSION_HEX >= 0x03030000 && PY_VERSION_HEX < 0x030500B1) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { args = PyTuple_New(1); if (unlikely(!args)) return; Py_INCREF(value); PyTuple_SET_ITEM(args, 0, value); exc = PyType_Type.tp_call(PyExc_StopIteration, args, NULL); Py_DECREF(args); if (!exc) return; } else { Py_INCREF(value); exc = value; } #if CYTHON_FAST_THREAD_STATE __Pyx_PyThreadState_assign #if CYTHON_USE_EXC_INFO_STACK if (!__pyx_tstate->exc_info->exc_type) #else if (!__pyx_tstate->exc_type) #endif { Py_INCREF(PyExc_StopIteration); __Pyx_ErrRestore(PyExc_StopIteration, exc, NULL); return; } #endif #else args = PyTuple_Pack(1, value); if (unlikely(!args)) return; exc = PyObject_Call(PyExc_StopIteration, args, NULL); Py_DECREF(args); if (unlikely(!exc)) return; #endif PyErr_SetObject(PyExc_StopIteration, exc); Py_DECREF(exc); } /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { a = a->tp_base; if (a == b) return 1; } return b == &PyBaseObject_Type; } static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { PyObject *mro; if (a == b) return 1; mro = a->tp_mro; if (likely(mro)) { Py_ssize_t i, n; n = PyTuple_GET_SIZE(mro); for (i = 0; i < n; i++) { if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) return 1; } return 0; } return __Pyx_InBases(a, b); } #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; int res; __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign __Pyx_ErrFetch(&exception, &value, &tb); res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } if (!res) { res = PyObject_IsSubclass(err, exc_type2); if (unlikely(res == -1)) { PyErr_WriteUnraisable(err); res = 0; } } __Pyx_ErrRestore(exception, value, tb); return res; } #else static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; if (!res) { res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { Py_ssize_t i, n; assert(PyExceptionClass_Check(exc_type)); n = PyTuple_GET_SIZE(tuple); #if PY_MAJOR_VERSION >= 3 for (i=0; itp_iternext; value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; Py_DECREF(iter); *pvalue1 = value1; *pvalue2 = value2; return 0; unpacking_failed: if (!has_known_size && __Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); bad: Py_XDECREF(iter); Py_XDECREF(value1); Py_XDECREF(value2); if (decref_tuple) { Py_XDECREF(tuple); } return -1; } /* dict_iter */ static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, Py_ssize_t* p_orig_length, int* p_source_is_dict) { is_dict = is_dict || likely(PyDict_CheckExact(iterable)); *p_source_is_dict = is_dict; if (is_dict) { #if !CYTHON_COMPILING_IN_PYPY *p_orig_length = PyDict_Size(iterable); Py_INCREF(iterable); return iterable; #elif PY_MAJOR_VERSION >= 3 static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; PyObject **pp = NULL; if (method_name) { const char *name = PyUnicode_AsUTF8(method_name); if (strcmp(name, "iteritems") == 0) pp = &py_items; else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; else if (strcmp(name, "itervalues") == 0) pp = &py_values; if (pp) { if (!*pp) { *pp = PyUnicode_FromString(name + 4); if (!*pp) return NULL; } method_name = *pp; } } #endif } *p_orig_length = 0; if (method_name) { PyObject* iter; iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); if (!iterable) return NULL; #if !CYTHON_COMPILING_IN_PYPY if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) return iterable; #endif iter = PyObject_GetIter(iterable); Py_DECREF(iterable); return iter; } return PyObject_GetIter(iterable); } static CYTHON_INLINE int __Pyx_dict_iter_next( PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { PyObject* next_item; #if !CYTHON_COMPILING_IN_PYPY if (source_is_dict) { PyObject *key, *value; if (unlikely(orig_length != PyDict_Size(iter_obj))) { PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); return -1; } if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { return 0; } if (pitem) { PyObject* tuple = PyTuple_New(2); if (unlikely(!tuple)) { return -1; } Py_INCREF(key); Py_INCREF(value); PyTuple_SET_ITEM(tuple, 0, key); PyTuple_SET_ITEM(tuple, 1, value); *pitem = tuple; } else { if (pkey) { Py_INCREF(key); *pkey = key; } if (pvalue) { Py_INCREF(value); *pvalue = value; } } return 1; } else if (PyTuple_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyTuple_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else if (PyList_CheckExact(iter_obj)) { Py_ssize_t pos = *ppos; if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0; *ppos = pos + 1; next_item = PyList_GET_ITEM(iter_obj, pos); Py_INCREF(next_item); } else #endif { next_item = PyIter_Next(iter_obj); if (unlikely(!next_item)) { return __Pyx_IterFinish(); } } if (pitem) { *pitem = next_item; } else if (pkey && pvalue) { if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) return -1; } else if (pkey) { *pkey = next_item; } else { *pvalue = next_item; } return 1; } /* PyObjectSetAttrStr */ #if CYTHON_USE_TYPE_SLOTS static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_setattro)) return tp->tp_setattro(obj, attr_name, value); #if PY_MAJOR_VERSION < 3 if (likely(tp->tp_setattr)) return tp->tp_setattr(obj, PyString_AS_STRING(attr_name), value); #endif return PyObject_SetAttr(obj, attr_name, value); } #endif /* None */ static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); } /* SliceObject */ static CYTHON_INLINE PyObject* __Pyx_PyObject_GetSlice(PyObject* obj, Py_ssize_t cstart, Py_ssize_t cstop, PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { #if CYTHON_USE_TYPE_SLOTS PyMappingMethods* mp; #if PY_MAJOR_VERSION < 3 PySequenceMethods* ms = Py_TYPE(obj)->tp_as_sequence; if (likely(ms && ms->sq_slice)) { if (!has_cstart) { if (_py_start && (*_py_start != Py_None)) { cstart = __Pyx_PyIndex_AsSsize_t(*_py_start); if ((cstart == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstart = 0; } if (!has_cstop) { if (_py_stop && (*_py_stop != Py_None)) { cstop = __Pyx_PyIndex_AsSsize_t(*_py_stop); if ((cstop == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; } else cstop = PY_SSIZE_T_MAX; } if (wraparound && unlikely((cstart < 0) | (cstop < 0)) && likely(ms->sq_length)) { Py_ssize_t l = ms->sq_length(obj); if (likely(l >= 0)) { if (cstop < 0) { cstop += l; if (cstop < 0) cstop = 0; } if (cstart < 0) { cstart += l; if (cstart < 0) cstart = 0; } } else { if (!PyErr_ExceptionMatches(PyExc_OverflowError)) goto bad; PyErr_Clear(); } } return ms->sq_slice(obj, cstart, cstop); } #endif mp = Py_TYPE(obj)->tp_as_mapping; if (likely(mp && mp->mp_subscript)) #endif { PyObject* result; PyObject *py_slice, *py_start, *py_stop; if (_py_slice) { py_slice = *_py_slice; } else { PyObject* owned_start = NULL; PyObject* owned_stop = NULL; if (_py_start) { py_start = *_py_start; } else { if (has_cstart) { owned_start = py_start = PyInt_FromSsize_t(cstart); if (unlikely(!py_start)) goto bad; } else py_start = Py_None; } if (_py_stop) { py_stop = *_py_stop; } else { if (has_cstop) { owned_stop = py_stop = PyInt_FromSsize_t(cstop); if (unlikely(!py_stop)) { Py_XDECREF(owned_start); goto bad; } } else py_stop = Py_None; } py_slice = PySlice_New(py_start, py_stop, Py_None); Py_XDECREF(owned_start); Py_XDECREF(owned_stop); if (unlikely(!py_slice)) goto bad; } #if CYTHON_USE_TYPE_SLOTS result = mp->mp_subscript(obj, py_slice); #else result = PyObject_GetItem(obj, py_slice); #endif if (!_py_slice) { Py_DECREF(py_slice); } return result; } PyErr_Format(PyExc_TypeError, "'%.200s' object is unsliceable", Py_TYPE(obj)->tp_name); bad: return NULL; } /* Import */ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { PyObject *empty_list = 0; PyObject *module = 0; PyObject *global_dict = 0; PyObject *empty_dict = 0; PyObject *list; #if PY_MAJOR_VERSION < 3 PyObject *py_import; py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); if (!py_import) goto bad; #endif if (from_list) list = from_list; else { empty_list = PyList_New(0); if (!empty_list) goto bad; list = empty_list; } global_dict = PyModule_GetDict(__pyx_m); if (!global_dict) goto bad; empty_dict = PyDict_New(); if (!empty_dict) goto bad; { #if PY_MAJOR_VERSION >= 3 if (level == -1) { if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, 1); if (!module) { if (!PyErr_ExceptionMatches(PyExc_ImportError)) goto bad; PyErr_Clear(); } } level = 0; } #endif if (!module) { #if PY_MAJOR_VERSION < 3 PyObject *py_level = PyInt_FromLong(level); if (!py_level) goto bad; module = PyObject_CallFunctionObjArgs(py_import, name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); Py_DECREF(py_level); #else module = PyImport_ImportModuleLevelObject( name, global_dict, empty_dict, list, level); #endif } } bad: #if PY_MAJOR_VERSION < 3 Py_XDECREF(py_import); #endif Py_XDECREF(empty_list); Py_XDECREF(empty_dict); return module; } /* ImportFrom */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { PyErr_Format(PyExc_ImportError, #if PY_MAJOR_VERSION < 3 "cannot import name %.230s", PyString_AS_STRING(name)); #else "cannot import name %S", name); #endif } return value; } /* HasAttr */ static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { PyObject *r; if (unlikely(!__Pyx_PyBaseString_Check(n))) { PyErr_SetString(PyExc_TypeError, "hasattr(): attribute name must be string"); return -1; } r = __Pyx_GetAttr(o, n); if (unlikely(!r)) { PyErr_Clear(); return 0; } else { Py_DECREF(r); return 1; } } /* PyObject_GenericGetAttr */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { return PyObject_GenericGetAttr(obj, attr_name); } return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #endif /* PyObjectGetAttrStrNoError */ static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { __Pyx_PyThreadState_declare __Pyx_PyThreadState_assign if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) __Pyx_PyErr_Clear(); } static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { PyObject *result; #if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 PyTypeObject* tp = Py_TYPE(obj); if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); } #endif result = __Pyx_PyObject_GetAttrStr(obj, attr_name); if (unlikely(!result)) { __Pyx_PyObject_GetAttrStr_ClearAttributeError(); } return result; } /* SetupReduce */ static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { int ret; PyObject *name_attr; name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); if (likely(name_attr)) { ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); } else { ret = -1; } if (unlikely(ret < 0)) { PyErr_Clear(); ret = 0; } Py_XDECREF(name_attr); return ret; } static int __Pyx_setup_reduce(PyObject* type_obj) { int ret = 0; PyObject *object_reduce = NULL; PyObject *object_reduce_ex = NULL; PyObject *reduce = NULL; PyObject *reduce_ex = NULL; PyObject *reduce_cython = NULL; PyObject *setstate = NULL; PyObject *setstate_cython = NULL; #if CYTHON_USE_PYTYPE_LOOKUP if (_PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; #else if (PyObject_HasAttr(type_obj, __pyx_n_s_getstate)) goto __PYX_GOOD; #endif #if CYTHON_USE_PYTYPE_LOOKUP object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #else object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; if (reduce_ex == object_reduce_ex) { #if CYTHON_USE_PYTYPE_LOOKUP object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #else object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #endif reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); if (likely(reduce_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (reduce == object_reduce || PyErr_Occurred()) { goto __PYX_BAD; } setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); if (!setstate) PyErr_Clear(); if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); if (likely(setstate_cython)) { ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; } else if (!setstate || PyErr_Occurred()) { goto __PYX_BAD; } } PyType_Modified((PyTypeObject*)type_obj); } } goto __PYX_GOOD; __PYX_BAD: if (!PyErr_Occurred()) PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); ret = -1; __PYX_GOOD: #if !CYTHON_USE_PYTYPE_LOOKUP Py_XDECREF(object_reduce); Py_XDECREF(object_reduce_ex); #endif Py_XDECREF(reduce); Py_XDECREF(reduce_ex); Py_XDECREF(reduce_cython); Py_XDECREF(setstate); Py_XDECREF(setstate_cython); return ret; } /* SetVTable */ static int __Pyx_SetVtable(PyObject *dict, void *vtable) { #if PY_VERSION_HEX >= 0x02070000 PyObject *ob = PyCapsule_New(vtable, 0, 0); #else PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); #endif if (!ob) goto bad; if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) goto bad; Py_DECREF(ob); return 0; bad: Py_XDECREF(ob); return -1; } /* TypeImport */ #ifndef __PYX_HAVE_RT_ImportType #define __PYX_HAVE_RT_ImportType static PyTypeObject *__Pyx_ImportType(PyObject *module, const char *module_name, const char *class_name, size_t size, enum __Pyx_ImportType_CheckSize check_size) { PyObject *result = 0; char warning[200]; Py_ssize_t basicsize; #ifdef Py_LIMITED_API PyObject *py_basicsize; #endif result = PyObject_GetAttrString(module, class_name); if (!result) goto bad; if (!PyType_Check(result)) { PyErr_Format(PyExc_TypeError, "%.200s.%.200s is not a type object", module_name, class_name); goto bad; } #ifndef Py_LIMITED_API basicsize = ((PyTypeObject *)result)->tp_basicsize; #else py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); if (!py_basicsize) goto bad; basicsize = PyLong_AsSsize_t(py_basicsize); Py_DECREF(py_basicsize); py_basicsize = 0; if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) goto bad; #endif if ((size_t)basicsize < size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } if (check_size == __Pyx_ImportType_CheckSize_Error && (size_t)basicsize != size) { PyErr_Format(PyExc_ValueError, "%.200s.%.200s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); goto bad; } else if (check_size == __Pyx_ImportType_CheckSize_Warn && (size_t)basicsize > size) { PyOS_snprintf(warning, sizeof(warning), "%s.%s size changed, may indicate binary incompatibility. " "Expected %zd from C header, got %zd from PyObject", module_name, class_name, size, basicsize); if (PyErr_WarnEx(NULL, warning, 0) < 0) goto bad; } return (PyTypeObject *)result; bad: Py_XDECREF(result); return NULL; } #endif /* decode_c_string */ static CYTHON_INLINE PyObject* __Pyx_decode_c_string( const char* cstring, Py_ssize_t start, Py_ssize_t stop, const char* encoding, const char* errors, PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { Py_ssize_t length; if (unlikely((start < 0) | (stop < 0))) { size_t slen = strlen(cstring); if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { PyErr_SetString(PyExc_OverflowError, "c-string too long to convert to Python"); return NULL; } length = (Py_ssize_t) slen; if (start < 0) { start += length; if (start < 0) start = 0; } if (stop < 0) stop += length; } if (unlikely(stop <= start)) return __Pyx_NewRef(__pyx_empty_unicode); length = stop - start; cstring += start; if (decode_func) { return decode_func(cstring, length, errors); } else { return PyUnicode_Decode(cstring, length, encoding, errors); } } /* Globals */ static PyObject* __Pyx_Globals(void) { Py_ssize_t i; PyObject *names; PyObject *globals = __pyx_d; Py_INCREF(globals); names = PyObject_Dir(__pyx_m); if (!names) goto bad; for (i = PyList_GET_SIZE(names)-1; i >= 0; i--) { #if CYTHON_COMPILING_IN_PYPY PyObject* name = PySequence_ITEM(names, i); if (!name) goto bad; #else PyObject* name = PyList_GET_ITEM(names, i); #endif if (!PyDict_Contains(globals, name)) { PyObject* value = __Pyx_GetAttr(__pyx_m, name); if (!value) { #if CYTHON_COMPILING_IN_PYPY Py_DECREF(name); #endif goto bad; } if (PyDict_SetItem(globals, name, value) < 0) { #if CYTHON_COMPILING_IN_PYPY Py_DECREF(name); #endif Py_DECREF(value); goto bad; } } #if CYTHON_COMPILING_IN_PYPY Py_DECREF(name); #endif } Py_DECREF(names); return globals; bad: Py_XDECREF(names); Py_XDECREF(globals); return NULL; } /* pyfrozenset_new */ static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it) { if (it) { PyObject* result; #if CYTHON_COMPILING_IN_PYPY PyObject* args; args = PyTuple_Pack(1, it); if (unlikely(!args)) return NULL; result = PyObject_Call((PyObject*)&PyFrozenSet_Type, args, NULL); Py_DECREF(args); return result; #else if (PyFrozenSet_CheckExact(it)) { Py_INCREF(it); return it; } result = PyFrozenSet_New(it); if (unlikely(!result)) return NULL; if (likely(PySet_GET_SIZE(result))) return result; Py_DECREF(result); #endif } #if CYTHON_USE_TYPE_SLOTS return PyFrozenSet_Type.tp_new(&PyFrozenSet_Type, __pyx_empty_tuple, NULL); #else return PyObject_Call((PyObject*)&PyFrozenSet_Type, __pyx_empty_tuple, NULL); #endif } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif if (unlikely(!__pyx_cython_runtime)) { return c_line; } __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); #if CYTHON_COMPILING_IN_CPYTHON cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); if (likely(cython_runtime_dict)) { __PYX_PY_DICT_LOOKUP_IF_MODIFIED( use_cline, *cython_runtime_dict, __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) } else #endif { PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); if (use_cline_obj) { use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; Py_DECREF(use_cline_obj); } else { PyErr_Clear(); use_cline = NULL; } } if (!use_cline) { c_line = 0; PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); } else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { c_line = 0; } __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); return c_line; } #endif /* CodeObjectCache */ static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { int start = 0, mid = 0, end = count - 1; if (end >= 0 && code_line > entries[end].code_line) { return count; } while (start < end) { mid = start + (end - start) / 2; if (code_line < entries[mid].code_line) { end = mid; } else if (code_line > entries[mid].code_line) { start = mid + 1; } else { return mid; } } if (code_line <= entries[mid].code_line) { return mid; } else { return mid + 1; } } static PyCodeObject *__pyx_find_code_object(int code_line) { PyCodeObject* code_object; int pos; if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { return NULL; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { return NULL; } code_object = __pyx_code_cache.entries[pos].code_object; Py_INCREF(code_object); return code_object; } static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { int pos, i; __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; if (unlikely(!code_line)) { return; } if (unlikely(!entries)) { entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); if (likely(entries)) { __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = 64; __pyx_code_cache.count = 1; entries[0].code_line = code_line; entries[0].code_object = code_object; Py_INCREF(code_object); } return; } pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { PyCodeObject* tmp = entries[pos].code_object; entries[pos].code_object = code_object; Py_DECREF(tmp); return; } if (__pyx_code_cache.count == __pyx_code_cache.max_count) { int new_max = __pyx_code_cache.max_count + 64; entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); if (unlikely(!entries)) { return; } __pyx_code_cache.entries = entries; __pyx_code_cache.max_count = new_max; } for (i=__pyx_code_cache.count; i>pos; i--) { entries[i] = entries[i-1]; } entries[pos].code_line = code_line; entries[pos].code_object = code_object; __pyx_code_cache.count++; Py_INCREF(code_object); } /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyObject *py_srcfile = 0; PyObject *py_funcname = 0; #if PY_MAJOR_VERSION < 3 py_srcfile = PyString_FromString(filename); #else py_srcfile = PyUnicode_FromString(filename); #endif if (!py_srcfile) goto bad; if (c_line) { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #else py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); #endif } else { #if PY_MAJOR_VERSION < 3 py_funcname = PyString_FromString(funcname); #else py_funcname = PyUnicode_FromString(funcname); #endif } if (!py_funcname) goto bad; py_code = __Pyx_PyCode_New( 0, 0, 0, 0, 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ __pyx_empty_tuple, /*PyObject *varnames,*/ __pyx_empty_tuple, /*PyObject *freevars,*/ __pyx_empty_tuple, /*PyObject *cellvars,*/ py_srcfile, /*PyObject *filename,*/ py_funcname, /*PyObject *name,*/ py_line, __pyx_empty_bytes /*PyObject *lnotab*/ ); Py_DECREF(py_srcfile); Py_DECREF(py_funcname); return py_code; bad: Py_XDECREF(py_srcfile); Py_XDECREF(py_funcname); return NULL; } static void __Pyx_AddTraceback(const char *funcname, int c_line, int py_line, const char *filename) { PyCodeObject *py_code = 0; PyFrameObject *py_frame = 0; PyThreadState *tstate = __Pyx_PyThreadState_Current; if (c_line) { c_line = __Pyx_CLineForTraceback(tstate, c_line); } py_code = __pyx_find_code_object(c_line ? -c_line : py_line); if (!py_code) { py_code = __Pyx_CreateCodeObjectForTraceback( funcname, c_line, py_line, filename); if (!py_code) goto bad; __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); } py_frame = PyFrame_New( tstate, /*PyThreadState *tstate,*/ py_code, /*PyCodeObject *code,*/ __pyx_d, /*PyObject *globals,*/ 0 /*PyObject *locals*/ ); if (!py_frame) goto bad; __Pyx_PyFrame_SetLineNumber(py_frame, py_line); PyTraceBack_Here(py_frame); bad: Py_XDECREF(py_code); Py_XDECREF(py_frame); } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); } } /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ {\ func_type value = func_value;\ if (sizeof(target_type) < sizeof(func_type)) {\ if (unlikely(value != (func_type) (target_type) value)) {\ func_type zero = 0;\ if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ return (target_type) -1;\ if (is_unsigned && unlikely(value < zero))\ goto raise_neg_overflow;\ else\ goto raise_overflow;\ }\ }\ return (target_type) value;\ } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_gid_t(gid_t value) { const gid_t neg_one = (gid_t) ((gid_t) 0 - (gid_t) 1), const_zero = (gid_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(gid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(gid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(gid_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(gid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(gid_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(gid_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_pid_t(pid_t value) { const pid_t neg_one = (pid_t) ((pid_t) 0 - (pid_t) 1), const_zero = (pid_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(pid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(pid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(pid_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(pid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(pid_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(pid_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uid_t(uid_t value) { const uid_t neg_one = (uid_t) ((uid_t) 0 - (uid_t) 1), const_zero = (uid_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uid_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uid_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uid_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(uid_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uid_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uid_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_mode_t(mode_t value) { const mode_t neg_one = (mode_t) ((mode_t) 0 - (mode_t) 1), const_zero = (mode_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(mode_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(mode_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(mode_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(mode_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(mode_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(mode_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { const unsigned int neg_one = (unsigned int) ((unsigned int) 0 - (unsigned int) 1), const_zero = (unsigned int) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned int) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned int) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(unsigned int) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(unsigned int), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fuse_ino_t(fuse_ino_t value) { const fuse_ino_t neg_one = (fuse_ino_t) ((fuse_ino_t) 0 - (fuse_ino_t) 1), const_zero = (fuse_ino_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(fuse_ino_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fuse_ino_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(fuse_ino_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(fuse_ino_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(fuse_ino_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(fuse_ino_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_uint64_t(uint64_t value) { const uint64_t neg_one = (uint64_t) ((uint64_t) 0 - (uint64_t) 1), const_zero = (uint64_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(uint64_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(uint64_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(uint64_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(uint64_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_dev_t(dev_t value) { const dev_t neg_one = (dev_t) ((dev_t) 0 - (dev_t) 1), const_zero = (dev_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(dev_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(dev_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(dev_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(dev_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(dev_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(dev_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_off_t(off_t value) { const off_t neg_one = (off_t) ((off_t) 0 - (off_t) 1), const_zero = (off_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(off_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(off_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(off_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(off_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(off_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(off_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_nlink_t(nlink_t value) { const nlink_t neg_one = (nlink_t) ((nlink_t) 0 - (nlink_t) 1), const_zero = (nlink_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(nlink_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(nlink_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(nlink_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(nlink_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(nlink_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(nlink_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_blkcnt_t(blkcnt_t value) { const blkcnt_t neg_one = (blkcnt_t) ((blkcnt_t) 0 - (blkcnt_t) 1), const_zero = (blkcnt_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(blkcnt_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(blkcnt_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(blkcnt_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(blkcnt_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(blkcnt_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(blkcnt_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_blksize_t(blksize_t value) { const blksize_t neg_one = (blksize_t) ((blksize_t) 0 - (blksize_t) 1), const_zero = (blksize_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(blksize_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(blksize_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(blksize_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(blksize_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(blksize_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(blksize_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_time_t(time_t value) { const time_t neg_one = (time_t) ((time_t) 0 - (time_t) 1), const_zero = (time_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(time_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(time_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(time_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(time_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(time_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(time_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long value) { const unsigned long neg_one = (unsigned long) ((unsigned long) 0 - (unsigned long) 1), const_zero = (unsigned long) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(unsigned long) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(unsigned long) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(unsigned long) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned long) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(unsigned long), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fsblkcnt_t(fsblkcnt_t value) { const fsblkcnt_t neg_one = (fsblkcnt_t) ((fsblkcnt_t) 0 - (fsblkcnt_t) 1), const_zero = (fsblkcnt_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(fsblkcnt_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fsblkcnt_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(fsblkcnt_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(fsblkcnt_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(fsblkcnt_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(fsblkcnt_t), little, !is_unsigned); } } /* CIntToPy */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_fsfilcnt_t(fsfilcnt_t value) { const fsfilcnt_t neg_one = (fsfilcnt_t) ((fsfilcnt_t) 0 - (fsfilcnt_t) 1), const_zero = (fsfilcnt_t) 0; const int is_unsigned = neg_one > const_zero; if (is_unsigned) { if (sizeof(fsfilcnt_t) < sizeof(long)) { return PyInt_FromLong((long) value); } else if (sizeof(fsfilcnt_t) <= sizeof(unsigned long)) { return PyLong_FromUnsignedLong((unsigned long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(fsfilcnt_t) <= sizeof(unsigned PY_LONG_LONG)) { return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); #endif } } else { if (sizeof(fsfilcnt_t) <= sizeof(long)) { return PyInt_FromLong((long) value); #ifdef HAVE_LONG_LONG } else if (sizeof(fsfilcnt_t) <= sizeof(PY_LONG_LONG)) { return PyLong_FromLongLong((PY_LONG_LONG) value); #endif } } { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; return _PyLong_FromByteArray(bytes, sizeof(fsfilcnt_t), little, !is_unsigned); } } /* CIntFromPy */ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int neg_one = (int) ((int) 0 - (int) 1), const_zero = (int) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(int) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (int) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (int) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(int) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (int) 0; case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) case -2: if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 2: if (8 * sizeof(int) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -3: if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 3: if (8 * sizeof(int) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case -4: if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; case 4: if (8 * sizeof(int) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); } } break; } #endif if (sizeof(int) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (int) -1; } } else { int val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (int) -1; val = __Pyx_PyInt_As_int(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to int"); return (int) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to int"); return (int) -1; } /* CIntFromPy */ static CYTHON_INLINE gid_t __Pyx_PyInt_As_gid_t(PyObject *x) { const gid_t neg_one = (gid_t) ((gid_t) 0 - (gid_t) 1), const_zero = (gid_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(gid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(gid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (gid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (gid_t) 0; case 1: __PYX_VERIFY_RETURN_INT(gid_t, digit, digits[0]) case 2: if (8 * sizeof(gid_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) >= 2 * PyLong_SHIFT) { return (gid_t) (((((gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0])); } } break; case 3: if (8 * sizeof(gid_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) >= 3 * PyLong_SHIFT) { return (gid_t) (((((((gid_t)digits[2]) << PyLong_SHIFT) | (gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0])); } } break; case 4: if (8 * sizeof(gid_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) >= 4 * PyLong_SHIFT) { return (gid_t) (((((((((gid_t)digits[3]) << PyLong_SHIFT) | (gid_t)digits[2]) << PyLong_SHIFT) | (gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (gid_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(gid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(gid_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(gid_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(gid_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (gid_t) 0; case -1: __PYX_VERIFY_RETURN_INT(gid_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(gid_t, digit, +digits[0]) case -2: if (8 * sizeof(gid_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) - 1 > 2 * PyLong_SHIFT) { return (gid_t) (((gid_t)-1)*(((((gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0]))); } } break; case 2: if (8 * sizeof(gid_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) - 1 > 2 * PyLong_SHIFT) { return (gid_t) ((((((gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0]))); } } break; case -3: if (8 * sizeof(gid_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) - 1 > 3 * PyLong_SHIFT) { return (gid_t) (((gid_t)-1)*(((((((gid_t)digits[2]) << PyLong_SHIFT) | (gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0]))); } } break; case 3: if (8 * sizeof(gid_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) - 1 > 3 * PyLong_SHIFT) { return (gid_t) ((((((((gid_t)digits[2]) << PyLong_SHIFT) | (gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0]))); } } break; case -4: if (8 * sizeof(gid_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) - 1 > 4 * PyLong_SHIFT) { return (gid_t) (((gid_t)-1)*(((((((((gid_t)digits[3]) << PyLong_SHIFT) | (gid_t)digits[2]) << PyLong_SHIFT) | (gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0]))); } } break; case 4: if (8 * sizeof(gid_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(gid_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(gid_t) - 1 > 4 * PyLong_SHIFT) { return (gid_t) ((((((((((gid_t)digits[3]) << PyLong_SHIFT) | (gid_t)digits[2]) << PyLong_SHIFT) | (gid_t)digits[1]) << PyLong_SHIFT) | (gid_t)digits[0]))); } } break; } #endif if (sizeof(gid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(gid_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(gid_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(gid_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else gid_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (gid_t) -1; } } else { gid_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (gid_t) -1; val = __Pyx_PyInt_As_gid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to gid_t"); return (gid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to gid_t"); return (gid_t) -1; } /* CIntFromPy */ static CYTHON_INLINE pid_t __Pyx_PyInt_As_pid_t(PyObject *x) { const pid_t neg_one = (pid_t) ((pid_t) 0 - (pid_t) 1), const_zero = (pid_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(pid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(pid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (pid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (pid_t) 0; case 1: __PYX_VERIFY_RETURN_INT(pid_t, digit, digits[0]) case 2: if (8 * sizeof(pid_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) >= 2 * PyLong_SHIFT) { return (pid_t) (((((pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0])); } } break; case 3: if (8 * sizeof(pid_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) >= 3 * PyLong_SHIFT) { return (pid_t) (((((((pid_t)digits[2]) << PyLong_SHIFT) | (pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0])); } } break; case 4: if (8 * sizeof(pid_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) >= 4 * PyLong_SHIFT) { return (pid_t) (((((((((pid_t)digits[3]) << PyLong_SHIFT) | (pid_t)digits[2]) << PyLong_SHIFT) | (pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (pid_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(pid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(pid_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(pid_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(pid_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (pid_t) 0; case -1: __PYX_VERIFY_RETURN_INT(pid_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(pid_t, digit, +digits[0]) case -2: if (8 * sizeof(pid_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) - 1 > 2 * PyLong_SHIFT) { return (pid_t) (((pid_t)-1)*(((((pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0]))); } } break; case 2: if (8 * sizeof(pid_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) - 1 > 2 * PyLong_SHIFT) { return (pid_t) ((((((pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0]))); } } break; case -3: if (8 * sizeof(pid_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) - 1 > 3 * PyLong_SHIFT) { return (pid_t) (((pid_t)-1)*(((((((pid_t)digits[2]) << PyLong_SHIFT) | (pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0]))); } } break; case 3: if (8 * sizeof(pid_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) - 1 > 3 * PyLong_SHIFT) { return (pid_t) ((((((((pid_t)digits[2]) << PyLong_SHIFT) | (pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0]))); } } break; case -4: if (8 * sizeof(pid_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) - 1 > 4 * PyLong_SHIFT) { return (pid_t) (((pid_t)-1)*(((((((((pid_t)digits[3]) << PyLong_SHIFT) | (pid_t)digits[2]) << PyLong_SHIFT) | (pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0]))); } } break; case 4: if (8 * sizeof(pid_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(pid_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(pid_t) - 1 > 4 * PyLong_SHIFT) { return (pid_t) ((((((((((pid_t)digits[3]) << PyLong_SHIFT) | (pid_t)digits[2]) << PyLong_SHIFT) | (pid_t)digits[1]) << PyLong_SHIFT) | (pid_t)digits[0]))); } } break; } #endif if (sizeof(pid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(pid_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(pid_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(pid_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else pid_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (pid_t) -1; } } else { pid_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (pid_t) -1; val = __Pyx_PyInt_As_pid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to pid_t"); return (pid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to pid_t"); return (pid_t) -1; } /* CIntFromPy */ static CYTHON_INLINE uid_t __Pyx_PyInt_As_uid_t(PyObject *x) { const uid_t neg_one = (uid_t) ((uid_t) 0 - (uid_t) 1), const_zero = (uid_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uid_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uid_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uid_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (uid_t) 0; case 1: __PYX_VERIFY_RETURN_INT(uid_t, digit, digits[0]) case 2: if (8 * sizeof(uid_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) >= 2 * PyLong_SHIFT) { return (uid_t) (((((uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0])); } } break; case 3: if (8 * sizeof(uid_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) >= 3 * PyLong_SHIFT) { return (uid_t) (((((((uid_t)digits[2]) << PyLong_SHIFT) | (uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0])); } } break; case 4: if (8 * sizeof(uid_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) >= 4 * PyLong_SHIFT) { return (uid_t) (((((((((uid_t)digits[3]) << PyLong_SHIFT) | (uid_t)digits[2]) << PyLong_SHIFT) | (uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (uid_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(uid_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(uid_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(uid_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(uid_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (uid_t) 0; case -1: __PYX_VERIFY_RETURN_INT(uid_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(uid_t, digit, +digits[0]) case -2: if (8 * sizeof(uid_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) - 1 > 2 * PyLong_SHIFT) { return (uid_t) (((uid_t)-1)*(((((uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0]))); } } break; case 2: if (8 * sizeof(uid_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) - 1 > 2 * PyLong_SHIFT) { return (uid_t) ((((((uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0]))); } } break; case -3: if (8 * sizeof(uid_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) - 1 > 3 * PyLong_SHIFT) { return (uid_t) (((uid_t)-1)*(((((((uid_t)digits[2]) << PyLong_SHIFT) | (uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0]))); } } break; case 3: if (8 * sizeof(uid_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) - 1 > 3 * PyLong_SHIFT) { return (uid_t) ((((((((uid_t)digits[2]) << PyLong_SHIFT) | (uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0]))); } } break; case -4: if (8 * sizeof(uid_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) - 1 > 4 * PyLong_SHIFT) { return (uid_t) (((uid_t)-1)*(((((((((uid_t)digits[3]) << PyLong_SHIFT) | (uid_t)digits[2]) << PyLong_SHIFT) | (uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0]))); } } break; case 4: if (8 * sizeof(uid_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uid_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uid_t) - 1 > 4 * PyLong_SHIFT) { return (uid_t) ((((((((((uid_t)digits[3]) << PyLong_SHIFT) | (uid_t)digits[2]) << PyLong_SHIFT) | (uid_t)digits[1]) << PyLong_SHIFT) | (uid_t)digits[0]))); } } break; } #endif if (sizeof(uid_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(uid_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(uid_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(uid_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uid_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uid_t) -1; } } else { uid_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (uid_t) -1; val = __Pyx_PyInt_As_uid_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uid_t"); return (uid_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uid_t"); return (uid_t) -1; } /* CIntFromPy */ static CYTHON_INLINE mode_t __Pyx_PyInt_As_mode_t(PyObject *x) { const mode_t neg_one = (mode_t) ((mode_t) 0 - (mode_t) 1), const_zero = (mode_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(mode_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(mode_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (mode_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (mode_t) 0; case 1: __PYX_VERIFY_RETURN_INT(mode_t, digit, digits[0]) case 2: if (8 * sizeof(mode_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) >= 2 * PyLong_SHIFT) { return (mode_t) (((((mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0])); } } break; case 3: if (8 * sizeof(mode_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) >= 3 * PyLong_SHIFT) { return (mode_t) (((((((mode_t)digits[2]) << PyLong_SHIFT) | (mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0])); } } break; case 4: if (8 * sizeof(mode_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) >= 4 * PyLong_SHIFT) { return (mode_t) (((((((((mode_t)digits[3]) << PyLong_SHIFT) | (mode_t)digits[2]) << PyLong_SHIFT) | (mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (mode_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(mode_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(mode_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(mode_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(mode_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (mode_t) 0; case -1: __PYX_VERIFY_RETURN_INT(mode_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(mode_t, digit, +digits[0]) case -2: if (8 * sizeof(mode_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) - 1 > 2 * PyLong_SHIFT) { return (mode_t) (((mode_t)-1)*(((((mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0]))); } } break; case 2: if (8 * sizeof(mode_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) - 1 > 2 * PyLong_SHIFT) { return (mode_t) ((((((mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0]))); } } break; case -3: if (8 * sizeof(mode_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) - 1 > 3 * PyLong_SHIFT) { return (mode_t) (((mode_t)-1)*(((((((mode_t)digits[2]) << PyLong_SHIFT) | (mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0]))); } } break; case 3: if (8 * sizeof(mode_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) - 1 > 3 * PyLong_SHIFT) { return (mode_t) ((((((((mode_t)digits[2]) << PyLong_SHIFT) | (mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0]))); } } break; case -4: if (8 * sizeof(mode_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) - 1 > 4 * PyLong_SHIFT) { return (mode_t) (((mode_t)-1)*(((((((((mode_t)digits[3]) << PyLong_SHIFT) | (mode_t)digits[2]) << PyLong_SHIFT) | (mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0]))); } } break; case 4: if (8 * sizeof(mode_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(mode_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(mode_t) - 1 > 4 * PyLong_SHIFT) { return (mode_t) ((((((((((mode_t)digits[3]) << PyLong_SHIFT) | (mode_t)digits[2]) << PyLong_SHIFT) | (mode_t)digits[1]) << PyLong_SHIFT) | (mode_t)digits[0]))); } } break; } #endif if (sizeof(mode_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(mode_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(mode_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(mode_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else mode_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (mode_t) -1; } } else { mode_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (mode_t) -1; val = __Pyx_PyInt_As_mode_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to mode_t"); return (mode_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to mode_t"); return (mode_t) -1; } /* CIntFromPy */ static CYTHON_INLINE size_t __Pyx_PyInt_As_size_t(PyObject *x) { const size_t neg_one = (size_t) ((size_t) 0 - (size_t) 1), const_zero = (size_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(size_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(size_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (size_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (size_t) 0; case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, digits[0]) case 2: if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) >= 2 * PyLong_SHIFT) { return (size_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } } break; case 3: if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) >= 3 * PyLong_SHIFT) { return (size_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } } break; case 4: if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) >= 4 * PyLong_SHIFT) { return (size_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (size_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(size_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(size_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(size_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (size_t) 0; case -1: __PYX_VERIFY_RETURN_INT(size_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(size_t, digit, +digits[0]) case -2: if (8 * sizeof(size_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { return (size_t) (((size_t)-1)*(((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case 2: if (8 * sizeof(size_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { return (size_t) ((((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case -3: if (8 * sizeof(size_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { return (size_t) (((size_t)-1)*(((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case 3: if (8 * sizeof(size_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { return (size_t) ((((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case -4: if (8 * sizeof(size_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { return (size_t) (((size_t)-1)*(((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; case 4: if (8 * sizeof(size_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(size_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(size_t) - 1 > 4 * PyLong_SHIFT) { return (size_t) ((((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0]))); } } break; } #endif if (sizeof(size_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(size_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(size_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(size_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else size_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (size_t) -1; } } else { size_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (size_t) -1; val = __Pyx_PyInt_As_size_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to size_t"); return (size_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to size_t"); return (size_t) -1; } /* CIntFromPy */ static CYTHON_INLINE fuse_ino_t __Pyx_PyInt_As_fuse_ino_t(PyObject *x) { const fuse_ino_t neg_one = (fuse_ino_t) ((fuse_ino_t) 0 - (fuse_ino_t) 1), const_zero = (fuse_ino_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fuse_ino_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fuse_ino_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (fuse_ino_t) 0; case 1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, digit, digits[0]) case 2: if (8 * sizeof(fuse_ino_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) >= 2 * PyLong_SHIFT) { return (fuse_ino_t) (((((fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0])); } } break; case 3: if (8 * sizeof(fuse_ino_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) >= 3 * PyLong_SHIFT) { return (fuse_ino_t) (((((((fuse_ino_t)digits[2]) << PyLong_SHIFT) | (fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0])); } } break; case 4: if (8 * sizeof(fuse_ino_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) >= 4 * PyLong_SHIFT) { return (fuse_ino_t) (((((((((fuse_ino_t)digits[3]) << PyLong_SHIFT) | (fuse_ino_t)digits[2]) << PyLong_SHIFT) | (fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (fuse_ino_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(fuse_ino_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(fuse_ino_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(fuse_ino_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(fuse_ino_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (fuse_ino_t) 0; case -1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(fuse_ino_t, digit, +digits[0]) case -2: if (8 * sizeof(fuse_ino_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) - 1 > 2 * PyLong_SHIFT) { return (fuse_ino_t) (((fuse_ino_t)-1)*(((((fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0]))); } } break; case 2: if (8 * sizeof(fuse_ino_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) - 1 > 2 * PyLong_SHIFT) { return (fuse_ino_t) ((((((fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0]))); } } break; case -3: if (8 * sizeof(fuse_ino_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) - 1 > 3 * PyLong_SHIFT) { return (fuse_ino_t) (((fuse_ino_t)-1)*(((((((fuse_ino_t)digits[2]) << PyLong_SHIFT) | (fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0]))); } } break; case 3: if (8 * sizeof(fuse_ino_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) - 1 > 3 * PyLong_SHIFT) { return (fuse_ino_t) ((((((((fuse_ino_t)digits[2]) << PyLong_SHIFT) | (fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0]))); } } break; case -4: if (8 * sizeof(fuse_ino_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) - 1 > 4 * PyLong_SHIFT) { return (fuse_ino_t) (((fuse_ino_t)-1)*(((((((((fuse_ino_t)digits[3]) << PyLong_SHIFT) | (fuse_ino_t)digits[2]) << PyLong_SHIFT) | (fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0]))); } } break; case 4: if (8 * sizeof(fuse_ino_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fuse_ino_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fuse_ino_t) - 1 > 4 * PyLong_SHIFT) { return (fuse_ino_t) ((((((((((fuse_ino_t)digits[3]) << PyLong_SHIFT) | (fuse_ino_t)digits[2]) << PyLong_SHIFT) | (fuse_ino_t)digits[1]) << PyLong_SHIFT) | (fuse_ino_t)digits[0]))); } } break; } #endif if (sizeof(fuse_ino_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(fuse_ino_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(fuse_ino_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(fuse_ino_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fuse_ino_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fuse_ino_t) -1; } } else { fuse_ino_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (fuse_ino_t) -1; val = __Pyx_PyInt_As_fuse_ino_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fuse_ino_t"); return (fuse_ino_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fuse_ino_t"); return (fuse_ino_t) -1; } /* CIntFromPy */ static CYTHON_INLINE off_t __Pyx_PyInt_As_off_t(PyObject *x) { const off_t neg_one = (off_t) ((off_t) 0 - (off_t) 1), const_zero = (off_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(off_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(off_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (off_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (off_t) 0; case 1: __PYX_VERIFY_RETURN_INT(off_t, digit, digits[0]) case 2: if (8 * sizeof(off_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) >= 2 * PyLong_SHIFT) { return (off_t) (((((off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0])); } } break; case 3: if (8 * sizeof(off_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) >= 3 * PyLong_SHIFT) { return (off_t) (((((((off_t)digits[2]) << PyLong_SHIFT) | (off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0])); } } break; case 4: if (8 * sizeof(off_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) >= 4 * PyLong_SHIFT) { return (off_t) (((((((((off_t)digits[3]) << PyLong_SHIFT) | (off_t)digits[2]) << PyLong_SHIFT) | (off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (off_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(off_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(off_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(off_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(off_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (off_t) 0; case -1: __PYX_VERIFY_RETURN_INT(off_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(off_t, digit, +digits[0]) case -2: if (8 * sizeof(off_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) - 1 > 2 * PyLong_SHIFT) { return (off_t) (((off_t)-1)*(((((off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0]))); } } break; case 2: if (8 * sizeof(off_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) - 1 > 2 * PyLong_SHIFT) { return (off_t) ((((((off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0]))); } } break; case -3: if (8 * sizeof(off_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) - 1 > 3 * PyLong_SHIFT) { return (off_t) (((off_t)-1)*(((((((off_t)digits[2]) << PyLong_SHIFT) | (off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0]))); } } break; case 3: if (8 * sizeof(off_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) - 1 > 3 * PyLong_SHIFT) { return (off_t) ((((((((off_t)digits[2]) << PyLong_SHIFT) | (off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0]))); } } break; case -4: if (8 * sizeof(off_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) - 1 > 4 * PyLong_SHIFT) { return (off_t) (((off_t)-1)*(((((((((off_t)digits[3]) << PyLong_SHIFT) | (off_t)digits[2]) << PyLong_SHIFT) | (off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0]))); } } break; case 4: if (8 * sizeof(off_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(off_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(off_t) - 1 > 4 * PyLong_SHIFT) { return (off_t) ((((((((((off_t)digits[3]) << PyLong_SHIFT) | (off_t)digits[2]) << PyLong_SHIFT) | (off_t)digits[1]) << PyLong_SHIFT) | (off_t)digits[0]))); } } break; } #endif if (sizeof(off_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(off_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(off_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(off_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else off_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (off_t) -1; } } else { off_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (off_t) -1; val = __Pyx_PyInt_As_off_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to off_t"); return (off_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to off_t"); return (off_t) -1; } /* CIntFromPy */ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const long neg_one = (long) ((long) 0 - (long) 1), const_zero = (long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (long) 0; case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) case -2: if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 2: if (8 * sizeof(long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -3: if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 3: if (8 * sizeof(long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case -4: if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; case 4: if (8 * sizeof(long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); } } break; } #endif if (sizeof(long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (long) -1; } } else { long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (long) -1; val = __Pyx_PyInt_As_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to long"); return (long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to long"); return (long) -1; } /* CIntFromPy */ static CYTHON_INLINE uint64_t __Pyx_PyInt_As_uint64_t(PyObject *x) { const uint64_t neg_one = (uint64_t) ((uint64_t) 0 - (uint64_t) 1), const_zero = (uint64_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(uint64_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(uint64_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (uint64_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (uint64_t) 0; case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, digits[0]) case 2: if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) >= 2 * PyLong_SHIFT) { return (uint64_t) (((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); } } break; case 3: if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) >= 3 * PyLong_SHIFT) { return (uint64_t) (((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); } } break; case 4: if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) >= 4 * PyLong_SHIFT) { return (uint64_t) (((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (uint64_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(uint64_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(uint64_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(uint64_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (uint64_t) 0; case -1: __PYX_VERIFY_RETURN_INT(uint64_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(uint64_t, digit, +digits[0]) case -2: if (8 * sizeof(uint64_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) { return (uint64_t) (((uint64_t)-1)*(((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); } } break; case 2: if (8 * sizeof(uint64_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) { return (uint64_t) ((((((uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); } } break; case -3: if (8 * sizeof(uint64_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) { return (uint64_t) (((uint64_t)-1)*(((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); } } break; case 3: if (8 * sizeof(uint64_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) { return (uint64_t) ((((((((uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); } } break; case -4: if (8 * sizeof(uint64_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT) { return (uint64_t) (((uint64_t)-1)*(((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); } } break; case 4: if (8 * sizeof(uint64_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(uint64_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(uint64_t) - 1 > 4 * PyLong_SHIFT) { return (uint64_t) ((((((((((uint64_t)digits[3]) << PyLong_SHIFT) | (uint64_t)digits[2]) << PyLong_SHIFT) | (uint64_t)digits[1]) << PyLong_SHIFT) | (uint64_t)digits[0]))); } } break; } #endif if (sizeof(uint64_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(uint64_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(uint64_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(uint64_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else uint64_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (uint64_t) -1; } } else { uint64_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (uint64_t) -1; val = __Pyx_PyInt_As_uint64_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to uint64_t"); return (uint64_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to uint64_t"); return (uint64_t) -1; } /* CIntFromPy */ static CYTHON_INLINE ino_t __Pyx_PyInt_As_ino_t(PyObject *x) { const ino_t neg_one = (ino_t) ((ino_t) 0 - (ino_t) 1), const_zero = (ino_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(ino_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(ino_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (ino_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (ino_t) 0; case 1: __PYX_VERIFY_RETURN_INT(ino_t, digit, digits[0]) case 2: if (8 * sizeof(ino_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) >= 2 * PyLong_SHIFT) { return (ino_t) (((((ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0])); } } break; case 3: if (8 * sizeof(ino_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) >= 3 * PyLong_SHIFT) { return (ino_t) (((((((ino_t)digits[2]) << PyLong_SHIFT) | (ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0])); } } break; case 4: if (8 * sizeof(ino_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) >= 4 * PyLong_SHIFT) { return (ino_t) (((((((((ino_t)digits[3]) << PyLong_SHIFT) | (ino_t)digits[2]) << PyLong_SHIFT) | (ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (ino_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(ino_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(ino_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(ino_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(ino_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (ino_t) 0; case -1: __PYX_VERIFY_RETURN_INT(ino_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(ino_t, digit, +digits[0]) case -2: if (8 * sizeof(ino_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) - 1 > 2 * PyLong_SHIFT) { return (ino_t) (((ino_t)-1)*(((((ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0]))); } } break; case 2: if (8 * sizeof(ino_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) - 1 > 2 * PyLong_SHIFT) { return (ino_t) ((((((ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0]))); } } break; case -3: if (8 * sizeof(ino_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) - 1 > 3 * PyLong_SHIFT) { return (ino_t) (((ino_t)-1)*(((((((ino_t)digits[2]) << PyLong_SHIFT) | (ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0]))); } } break; case 3: if (8 * sizeof(ino_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) - 1 > 3 * PyLong_SHIFT) { return (ino_t) ((((((((ino_t)digits[2]) << PyLong_SHIFT) | (ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0]))); } } break; case -4: if (8 * sizeof(ino_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) - 1 > 4 * PyLong_SHIFT) { return (ino_t) (((ino_t)-1)*(((((((((ino_t)digits[3]) << PyLong_SHIFT) | (ino_t)digits[2]) << PyLong_SHIFT) | (ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0]))); } } break; case 4: if (8 * sizeof(ino_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(ino_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(ino_t) - 1 > 4 * PyLong_SHIFT) { return (ino_t) ((((((((((ino_t)digits[3]) << PyLong_SHIFT) | (ino_t)digits[2]) << PyLong_SHIFT) | (ino_t)digits[1]) << PyLong_SHIFT) | (ino_t)digits[0]))); } } break; } #endif if (sizeof(ino_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(ino_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(ino_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(ino_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else ino_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (ino_t) -1; } } else { ino_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (ino_t) -1; val = __Pyx_PyInt_As_ino_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to ino_t"); return (ino_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to ino_t"); return (ino_t) -1; } /* CIntFromPy */ static CYTHON_INLINE nlink_t __Pyx_PyInt_As_nlink_t(PyObject *x) { const nlink_t neg_one = (nlink_t) ((nlink_t) 0 - (nlink_t) 1), const_zero = (nlink_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(nlink_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(nlink_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (nlink_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (nlink_t) 0; case 1: __PYX_VERIFY_RETURN_INT(nlink_t, digit, digits[0]) case 2: if (8 * sizeof(nlink_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) >= 2 * PyLong_SHIFT) { return (nlink_t) (((((nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0])); } } break; case 3: if (8 * sizeof(nlink_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) >= 3 * PyLong_SHIFT) { return (nlink_t) (((((((nlink_t)digits[2]) << PyLong_SHIFT) | (nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0])); } } break; case 4: if (8 * sizeof(nlink_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) >= 4 * PyLong_SHIFT) { return (nlink_t) (((((((((nlink_t)digits[3]) << PyLong_SHIFT) | (nlink_t)digits[2]) << PyLong_SHIFT) | (nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (nlink_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(nlink_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(nlink_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(nlink_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(nlink_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (nlink_t) 0; case -1: __PYX_VERIFY_RETURN_INT(nlink_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(nlink_t, digit, +digits[0]) case -2: if (8 * sizeof(nlink_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) - 1 > 2 * PyLong_SHIFT) { return (nlink_t) (((nlink_t)-1)*(((((nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0]))); } } break; case 2: if (8 * sizeof(nlink_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) - 1 > 2 * PyLong_SHIFT) { return (nlink_t) ((((((nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0]))); } } break; case -3: if (8 * sizeof(nlink_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) - 1 > 3 * PyLong_SHIFT) { return (nlink_t) (((nlink_t)-1)*(((((((nlink_t)digits[2]) << PyLong_SHIFT) | (nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0]))); } } break; case 3: if (8 * sizeof(nlink_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) - 1 > 3 * PyLong_SHIFT) { return (nlink_t) ((((((((nlink_t)digits[2]) << PyLong_SHIFT) | (nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0]))); } } break; case -4: if (8 * sizeof(nlink_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) - 1 > 4 * PyLong_SHIFT) { return (nlink_t) (((nlink_t)-1)*(((((((((nlink_t)digits[3]) << PyLong_SHIFT) | (nlink_t)digits[2]) << PyLong_SHIFT) | (nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0]))); } } break; case 4: if (8 * sizeof(nlink_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(nlink_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(nlink_t) - 1 > 4 * PyLong_SHIFT) { return (nlink_t) ((((((((((nlink_t)digits[3]) << PyLong_SHIFT) | (nlink_t)digits[2]) << PyLong_SHIFT) | (nlink_t)digits[1]) << PyLong_SHIFT) | (nlink_t)digits[0]))); } } break; } #endif if (sizeof(nlink_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(nlink_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(nlink_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(nlink_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else nlink_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (nlink_t) -1; } } else { nlink_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (nlink_t) -1; val = __Pyx_PyInt_As_nlink_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to nlink_t"); return (nlink_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to nlink_t"); return (nlink_t) -1; } /* CIntFromPy */ static CYTHON_INLINE dev_t __Pyx_PyInt_As_dev_t(PyObject *x) { const dev_t neg_one = (dev_t) ((dev_t) 0 - (dev_t) 1), const_zero = (dev_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(dev_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(dev_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (dev_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (dev_t) 0; case 1: __PYX_VERIFY_RETURN_INT(dev_t, digit, digits[0]) case 2: if (8 * sizeof(dev_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) >= 2 * PyLong_SHIFT) { return (dev_t) (((((dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0])); } } break; case 3: if (8 * sizeof(dev_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) >= 3 * PyLong_SHIFT) { return (dev_t) (((((((dev_t)digits[2]) << PyLong_SHIFT) | (dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0])); } } break; case 4: if (8 * sizeof(dev_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) >= 4 * PyLong_SHIFT) { return (dev_t) (((((((((dev_t)digits[3]) << PyLong_SHIFT) | (dev_t)digits[2]) << PyLong_SHIFT) | (dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (dev_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(dev_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(dev_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(dev_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(dev_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (dev_t) 0; case -1: __PYX_VERIFY_RETURN_INT(dev_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(dev_t, digit, +digits[0]) case -2: if (8 * sizeof(dev_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) - 1 > 2 * PyLong_SHIFT) { return (dev_t) (((dev_t)-1)*(((((dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0]))); } } break; case 2: if (8 * sizeof(dev_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) - 1 > 2 * PyLong_SHIFT) { return (dev_t) ((((((dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0]))); } } break; case -3: if (8 * sizeof(dev_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) - 1 > 3 * PyLong_SHIFT) { return (dev_t) (((dev_t)-1)*(((((((dev_t)digits[2]) << PyLong_SHIFT) | (dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0]))); } } break; case 3: if (8 * sizeof(dev_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) - 1 > 3 * PyLong_SHIFT) { return (dev_t) ((((((((dev_t)digits[2]) << PyLong_SHIFT) | (dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0]))); } } break; case -4: if (8 * sizeof(dev_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) - 1 > 4 * PyLong_SHIFT) { return (dev_t) (((dev_t)-1)*(((((((((dev_t)digits[3]) << PyLong_SHIFT) | (dev_t)digits[2]) << PyLong_SHIFT) | (dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0]))); } } break; case 4: if (8 * sizeof(dev_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(dev_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(dev_t) - 1 > 4 * PyLong_SHIFT) { return (dev_t) ((((((((((dev_t)digits[3]) << PyLong_SHIFT) | (dev_t)digits[2]) << PyLong_SHIFT) | (dev_t)digits[1]) << PyLong_SHIFT) | (dev_t)digits[0]))); } } break; } #endif if (sizeof(dev_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(dev_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(dev_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(dev_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else dev_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (dev_t) -1; } } else { dev_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (dev_t) -1; val = __Pyx_PyInt_As_dev_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to dev_t"); return (dev_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to dev_t"); return (dev_t) -1; } /* CIntFromPy */ static CYTHON_INLINE blkcnt_t __Pyx_PyInt_As_blkcnt_t(PyObject *x) { const blkcnt_t neg_one = (blkcnt_t) ((blkcnt_t) 0 - (blkcnt_t) 1), const_zero = (blkcnt_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(blkcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (blkcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (blkcnt_t) 0; case 1: __PYX_VERIFY_RETURN_INT(blkcnt_t, digit, digits[0]) case 2: if (8 * sizeof(blkcnt_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) >= 2 * PyLong_SHIFT) { return (blkcnt_t) (((((blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0])); } } break; case 3: if (8 * sizeof(blkcnt_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) >= 3 * PyLong_SHIFT) { return (blkcnt_t) (((((((blkcnt_t)digits[2]) << PyLong_SHIFT) | (blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0])); } } break; case 4: if (8 * sizeof(blkcnt_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) >= 4 * PyLong_SHIFT) { return (blkcnt_t) (((((((((blkcnt_t)digits[3]) << PyLong_SHIFT) | (blkcnt_t)digits[2]) << PyLong_SHIFT) | (blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (blkcnt_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(blkcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(blkcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(blkcnt_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(blkcnt_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (blkcnt_t) 0; case -1: __PYX_VERIFY_RETURN_INT(blkcnt_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(blkcnt_t, digit, +digits[0]) case -2: if (8 * sizeof(blkcnt_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) - 1 > 2 * PyLong_SHIFT) { return (blkcnt_t) (((blkcnt_t)-1)*(((((blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0]))); } } break; case 2: if (8 * sizeof(blkcnt_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) - 1 > 2 * PyLong_SHIFT) { return (blkcnt_t) ((((((blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0]))); } } break; case -3: if (8 * sizeof(blkcnt_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) - 1 > 3 * PyLong_SHIFT) { return (blkcnt_t) (((blkcnt_t)-1)*(((((((blkcnt_t)digits[2]) << PyLong_SHIFT) | (blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0]))); } } break; case 3: if (8 * sizeof(blkcnt_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) - 1 > 3 * PyLong_SHIFT) { return (blkcnt_t) ((((((((blkcnt_t)digits[2]) << PyLong_SHIFT) | (blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0]))); } } break; case -4: if (8 * sizeof(blkcnt_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) - 1 > 4 * PyLong_SHIFT) { return (blkcnt_t) (((blkcnt_t)-1)*(((((((((blkcnt_t)digits[3]) << PyLong_SHIFT) | (blkcnt_t)digits[2]) << PyLong_SHIFT) | (blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0]))); } } break; case 4: if (8 * sizeof(blkcnt_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blkcnt_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blkcnt_t) - 1 > 4 * PyLong_SHIFT) { return (blkcnt_t) ((((((((((blkcnt_t)digits[3]) << PyLong_SHIFT) | (blkcnt_t)digits[2]) << PyLong_SHIFT) | (blkcnt_t)digits[1]) << PyLong_SHIFT) | (blkcnt_t)digits[0]))); } } break; } #endif if (sizeof(blkcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(blkcnt_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(blkcnt_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(blkcnt_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else blkcnt_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (blkcnt_t) -1; } } else { blkcnt_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (blkcnt_t) -1; val = __Pyx_PyInt_As_blkcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to blkcnt_t"); return (blkcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to blkcnt_t"); return (blkcnt_t) -1; } /* CIntFromPy */ static CYTHON_INLINE blksize_t __Pyx_PyInt_As_blksize_t(PyObject *x) { const blksize_t neg_one = (blksize_t) ((blksize_t) 0 - (blksize_t) 1), const_zero = (blksize_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(blksize_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(blksize_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (blksize_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (blksize_t) 0; case 1: __PYX_VERIFY_RETURN_INT(blksize_t, digit, digits[0]) case 2: if (8 * sizeof(blksize_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) >= 2 * PyLong_SHIFT) { return (blksize_t) (((((blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0])); } } break; case 3: if (8 * sizeof(blksize_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) >= 3 * PyLong_SHIFT) { return (blksize_t) (((((((blksize_t)digits[2]) << PyLong_SHIFT) | (blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0])); } } break; case 4: if (8 * sizeof(blksize_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) >= 4 * PyLong_SHIFT) { return (blksize_t) (((((((((blksize_t)digits[3]) << PyLong_SHIFT) | (blksize_t)digits[2]) << PyLong_SHIFT) | (blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (blksize_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(blksize_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(blksize_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(blksize_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(blksize_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (blksize_t) 0; case -1: __PYX_VERIFY_RETURN_INT(blksize_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(blksize_t, digit, +digits[0]) case -2: if (8 * sizeof(blksize_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) - 1 > 2 * PyLong_SHIFT) { return (blksize_t) (((blksize_t)-1)*(((((blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0]))); } } break; case 2: if (8 * sizeof(blksize_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) - 1 > 2 * PyLong_SHIFT) { return (blksize_t) ((((((blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0]))); } } break; case -3: if (8 * sizeof(blksize_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) - 1 > 3 * PyLong_SHIFT) { return (blksize_t) (((blksize_t)-1)*(((((((blksize_t)digits[2]) << PyLong_SHIFT) | (blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0]))); } } break; case 3: if (8 * sizeof(blksize_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) - 1 > 3 * PyLong_SHIFT) { return (blksize_t) ((((((((blksize_t)digits[2]) << PyLong_SHIFT) | (blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0]))); } } break; case -4: if (8 * sizeof(blksize_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) - 1 > 4 * PyLong_SHIFT) { return (blksize_t) (((blksize_t)-1)*(((((((((blksize_t)digits[3]) << PyLong_SHIFT) | (blksize_t)digits[2]) << PyLong_SHIFT) | (blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0]))); } } break; case 4: if (8 * sizeof(blksize_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(blksize_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(blksize_t) - 1 > 4 * PyLong_SHIFT) { return (blksize_t) ((((((((((blksize_t)digits[3]) << PyLong_SHIFT) | (blksize_t)digits[2]) << PyLong_SHIFT) | (blksize_t)digits[1]) << PyLong_SHIFT) | (blksize_t)digits[0]))); } } break; } #endif if (sizeof(blksize_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(blksize_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(blksize_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(blksize_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else blksize_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (blksize_t) -1; } } else { blksize_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (blksize_t) -1; val = __Pyx_PyInt_As_blksize_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to blksize_t"); return (blksize_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to blksize_t"); return (blksize_t) -1; } /* CIntFromPy */ static CYTHON_INLINE time_t __Pyx_PyInt_As_time_t(PyObject *x) { const time_t neg_one = (time_t) ((time_t) 0 - (time_t) 1), const_zero = (time_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(time_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(time_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (time_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (time_t) 0; case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, digits[0]) case 2: if (8 * sizeof(time_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) >= 2 * PyLong_SHIFT) { return (time_t) (((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])); } } break; case 3: if (8 * sizeof(time_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) >= 3 * PyLong_SHIFT) { return (time_t) (((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])); } } break; case 4: if (8 * sizeof(time_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) >= 4 * PyLong_SHIFT) { return (time_t) (((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (time_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(time_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(time_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(time_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (time_t) 0; case -1: __PYX_VERIFY_RETURN_INT(time_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(time_t, digit, +digits[0]) case -2: if (8 * sizeof(time_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) { return (time_t) (((time_t)-1)*(((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); } } break; case 2: if (8 * sizeof(time_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) { return (time_t) ((((((time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); } } break; case -3: if (8 * sizeof(time_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) { return (time_t) (((time_t)-1)*(((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); } } break; case 3: if (8 * sizeof(time_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) { return (time_t) ((((((((time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); } } break; case -4: if (8 * sizeof(time_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT) { return (time_t) (((time_t)-1)*(((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); } } break; case 4: if (8 * sizeof(time_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(time_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(time_t) - 1 > 4 * PyLong_SHIFT) { return (time_t) ((((((((((time_t)digits[3]) << PyLong_SHIFT) | (time_t)digits[2]) << PyLong_SHIFT) | (time_t)digits[1]) << PyLong_SHIFT) | (time_t)digits[0]))); } } break; } #endif if (sizeof(time_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(time_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(time_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(time_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else time_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (time_t) -1; } } else { time_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (time_t) -1; val = __Pyx_PyInt_As_time_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to time_t"); return (time_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to time_t"); return (time_t) -1; } /* CIntFromPy */ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) { const unsigned long neg_one = (unsigned long) ((unsigned long) 0 - (unsigned long) 1), const_zero = (unsigned long) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(unsigned long) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (unsigned long) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned long) 0; case 1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, digits[0]) case 2: if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) >= 2 * PyLong_SHIFT) { return (unsigned long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); } } break; case 3: if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) >= 3 * PyLong_SHIFT) { return (unsigned long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); } } break; case 4: if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) >= 4 * PyLong_SHIFT) { return (unsigned long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (unsigned long) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(unsigned long) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned long) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (unsigned long) 0; case -1: __PYX_VERIFY_RETURN_INT(unsigned long, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(unsigned long, digit, +digits[0]) case -2: if (8 * sizeof(unsigned long) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) { return (unsigned long) (((unsigned long)-1)*(((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))); } } break; case 2: if (8 * sizeof(unsigned long) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) { return (unsigned long) ((((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))); } } break; case -3: if (8 * sizeof(unsigned long) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) { return (unsigned long) (((unsigned long)-1)*(((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))); } } break; case 3: if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) { return (unsigned long) ((((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))); } } break; case -4: if (8 * sizeof(unsigned long) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) { return (unsigned long) (((unsigned long)-1)*(((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))); } } break; case 4: if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(unsigned long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(unsigned long) - 1 > 4 * PyLong_SHIFT) { return (unsigned long) ((((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))); } } break; } #endif if (sizeof(unsigned long) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned long, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(unsigned long) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(unsigned long, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else unsigned long val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (unsigned long) -1; } } else { unsigned long val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (unsigned long) -1; val = __Pyx_PyInt_As_unsigned_long(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to unsigned long"); return (unsigned long) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to unsigned long"); return (unsigned long) -1; } /* CIntFromPy */ static CYTHON_INLINE fsblkcnt_t __Pyx_PyInt_As_fsblkcnt_t(PyObject *x) { const fsblkcnt_t neg_one = (fsblkcnt_t) ((fsblkcnt_t) 0 - (fsblkcnt_t) 1), const_zero = (fsblkcnt_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fsblkcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fsblkcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (fsblkcnt_t) 0; case 1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, digit, digits[0]) case 2: if (8 * sizeof(fsblkcnt_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) >= 2 * PyLong_SHIFT) { return (fsblkcnt_t) (((((fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0])); } } break; case 3: if (8 * sizeof(fsblkcnt_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) >= 3 * PyLong_SHIFT) { return (fsblkcnt_t) (((((((fsblkcnt_t)digits[2]) << PyLong_SHIFT) | (fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0])); } } break; case 4: if (8 * sizeof(fsblkcnt_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) >= 4 * PyLong_SHIFT) { return (fsblkcnt_t) (((((((((fsblkcnt_t)digits[3]) << PyLong_SHIFT) | (fsblkcnt_t)digits[2]) << PyLong_SHIFT) | (fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (fsblkcnt_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(fsblkcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(fsblkcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(fsblkcnt_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(fsblkcnt_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (fsblkcnt_t) 0; case -1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(fsblkcnt_t, digit, +digits[0]) case -2: if (8 * sizeof(fsblkcnt_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) - 1 > 2 * PyLong_SHIFT) { return (fsblkcnt_t) (((fsblkcnt_t)-1)*(((((fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0]))); } } break; case 2: if (8 * sizeof(fsblkcnt_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) - 1 > 2 * PyLong_SHIFT) { return (fsblkcnt_t) ((((((fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0]))); } } break; case -3: if (8 * sizeof(fsblkcnt_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) - 1 > 3 * PyLong_SHIFT) { return (fsblkcnt_t) (((fsblkcnt_t)-1)*(((((((fsblkcnt_t)digits[2]) << PyLong_SHIFT) | (fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0]))); } } break; case 3: if (8 * sizeof(fsblkcnt_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) - 1 > 3 * PyLong_SHIFT) { return (fsblkcnt_t) ((((((((fsblkcnt_t)digits[2]) << PyLong_SHIFT) | (fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0]))); } } break; case -4: if (8 * sizeof(fsblkcnt_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) - 1 > 4 * PyLong_SHIFT) { return (fsblkcnt_t) (((fsblkcnt_t)-1)*(((((((((fsblkcnt_t)digits[3]) << PyLong_SHIFT) | (fsblkcnt_t)digits[2]) << PyLong_SHIFT) | (fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0]))); } } break; case 4: if (8 * sizeof(fsblkcnt_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsblkcnt_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsblkcnt_t) - 1 > 4 * PyLong_SHIFT) { return (fsblkcnt_t) ((((((((((fsblkcnt_t)digits[3]) << PyLong_SHIFT) | (fsblkcnt_t)digits[2]) << PyLong_SHIFT) | (fsblkcnt_t)digits[1]) << PyLong_SHIFT) | (fsblkcnt_t)digits[0]))); } } break; } #endif if (sizeof(fsblkcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(fsblkcnt_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(fsblkcnt_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(fsblkcnt_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fsblkcnt_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fsblkcnt_t) -1; } } else { fsblkcnt_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (fsblkcnt_t) -1; val = __Pyx_PyInt_As_fsblkcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fsblkcnt_t"); return (fsblkcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fsblkcnt_t"); return (fsblkcnt_t) -1; } /* CIntFromPy */ static CYTHON_INLINE fsfilcnt_t __Pyx_PyInt_As_fsfilcnt_t(PyObject *x) { const fsfilcnt_t neg_one = (fsfilcnt_t) ((fsfilcnt_t) 0 - (fsfilcnt_t) 1), const_zero = (fsfilcnt_t) 0; const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { if (sizeof(fsfilcnt_t) < sizeof(long)) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); if (is_unsigned && unlikely(val < 0)) { goto raise_neg_overflow; } return (fsfilcnt_t) val; } } else #endif if (likely(PyLong_Check(x))) { if (is_unsigned) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (fsfilcnt_t) 0; case 1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, digit, digits[0]) case 2: if (8 * sizeof(fsfilcnt_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) >= 2 * PyLong_SHIFT) { return (fsfilcnt_t) (((((fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0])); } } break; case 3: if (8 * sizeof(fsfilcnt_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) >= 3 * PyLong_SHIFT) { return (fsfilcnt_t) (((((((fsfilcnt_t)digits[2]) << PyLong_SHIFT) | (fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0])); } } break; case 4: if (8 * sizeof(fsfilcnt_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) >= 4 * PyLong_SHIFT) { return (fsfilcnt_t) (((((((((fsfilcnt_t)digits[3]) << PyLong_SHIFT) | (fsfilcnt_t)digits[2]) << PyLong_SHIFT) | (fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0])); } } break; } #endif #if CYTHON_COMPILING_IN_CPYTHON if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } #else { int result = PyObject_RichCompareBool(x, Py_False, Py_LT); if (unlikely(result < 0)) return (fsfilcnt_t) -1; if (unlikely(result == 1)) goto raise_neg_overflow; } #endif if (sizeof(fsfilcnt_t) <= sizeof(unsigned long)) { __PYX_VERIFY_RETURN_INT_EXC(fsfilcnt_t, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(fsfilcnt_t) <= sizeof(unsigned PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(fsfilcnt_t, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) #endif } } else { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)x)->ob_digit; switch (Py_SIZE(x)) { case 0: return (fsfilcnt_t) 0; case -1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, sdigit, (sdigit) (-(sdigit)digits[0])) case 1: __PYX_VERIFY_RETURN_INT(fsfilcnt_t, digit, +digits[0]) case -2: if (8 * sizeof(fsfilcnt_t) - 1 > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) - 1 > 2 * PyLong_SHIFT) { return (fsfilcnt_t) (((fsfilcnt_t)-1)*(((((fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0]))); } } break; case 2: if (8 * sizeof(fsfilcnt_t) > 1 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) - 1 > 2 * PyLong_SHIFT) { return (fsfilcnt_t) ((((((fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0]))); } } break; case -3: if (8 * sizeof(fsfilcnt_t) - 1 > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) - 1 > 3 * PyLong_SHIFT) { return (fsfilcnt_t) (((fsfilcnt_t)-1)*(((((((fsfilcnt_t)digits[2]) << PyLong_SHIFT) | (fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0]))); } } break; case 3: if (8 * sizeof(fsfilcnt_t) > 2 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) - 1 > 3 * PyLong_SHIFT) { return (fsfilcnt_t) ((((((((fsfilcnt_t)digits[2]) << PyLong_SHIFT) | (fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0]))); } } break; case -4: if (8 * sizeof(fsfilcnt_t) - 1 > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) - 1 > 4 * PyLong_SHIFT) { return (fsfilcnt_t) (((fsfilcnt_t)-1)*(((((((((fsfilcnt_t)digits[3]) << PyLong_SHIFT) | (fsfilcnt_t)digits[2]) << PyLong_SHIFT) | (fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0]))); } } break; case 4: if (8 * sizeof(fsfilcnt_t) > 3 * PyLong_SHIFT) { if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { __PYX_VERIFY_RETURN_INT(fsfilcnt_t, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) } else if (8 * sizeof(fsfilcnt_t) - 1 > 4 * PyLong_SHIFT) { return (fsfilcnt_t) ((((((((((fsfilcnt_t)digits[3]) << PyLong_SHIFT) | (fsfilcnt_t)digits[2]) << PyLong_SHIFT) | (fsfilcnt_t)digits[1]) << PyLong_SHIFT) | (fsfilcnt_t)digits[0]))); } } break; } #endif if (sizeof(fsfilcnt_t) <= sizeof(long)) { __PYX_VERIFY_RETURN_INT_EXC(fsfilcnt_t, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG } else if (sizeof(fsfilcnt_t) <= sizeof(PY_LONG_LONG)) { __PYX_VERIFY_RETURN_INT_EXC(fsfilcnt_t, PY_LONG_LONG, PyLong_AsLongLong(x)) #endif } } { #if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) PyErr_SetString(PyExc_RuntimeError, "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); #else fsfilcnt_t val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); #if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } #endif if (likely(v)) { int one = 1; int is_little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&val; int ret = _PyLong_AsByteArray((PyLongObject *)v, bytes, sizeof(val), is_little, !is_unsigned); Py_DECREF(v); if (likely(!ret)) return val; } #endif return (fsfilcnt_t) -1; } } else { fsfilcnt_t val; PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); if (!tmp) return (fsfilcnt_t) -1; val = __Pyx_PyInt_As_fsfilcnt_t(tmp); Py_DECREF(tmp); return val; } raise_overflow: PyErr_SetString(PyExc_OverflowError, "value too large to convert to fsfilcnt_t"); return (fsfilcnt_t) -1; raise_neg_overflow: PyErr_SetString(PyExc_OverflowError, "can't convert negative value to fsfilcnt_t"); return (fsfilcnt_t) -1; } /* CheckBinaryVersion */ static int __Pyx_check_binary_version(void) { char ctversion[4], rtversion[4]; PyOS_snprintf(ctversion, 4, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); PyOS_snprintf(rtversion, 4, "%s", Py_GetVersion()); if (ctversion[0] != rtversion[0] || ctversion[2] != rtversion[2]) { char message[200]; PyOS_snprintf(message, sizeof(message), "compiletime version %s of module '%.100s' " "does not match runtime version %s", ctversion, __Pyx_MODULE_NAME, rtversion); return PyErr_WarnEx(NULL, message, 1); } return 0; } /* InitStrings */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { #if PY_MAJOR_VERSION < 3 if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { *t->p = PyString_InternFromString(t->s); } else { *t->p = PyString_FromStringAndSize(t->s, t->n - 1); } #else if (t->is_unicode | t->is_str) { if (t->intern) { *t->p = PyUnicode_InternFromString(t->s); } else if (t->encoding) { *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); } else { *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); } } else { *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); } #endif if (!*t->p) return -1; if (PyObject_Hash(*t->p) == -1) return -1; ++t; } return 0; } static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; return __Pyx_PyObject_AsStringAndSize(o, &ignore); } #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT #if !CYTHON_PEP393_ENABLED static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { char* defenc_c; PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); if (!defenc) return NULL; defenc_c = PyBytes_AS_STRING(defenc); #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII { char* end = defenc_c + PyBytes_GET_SIZE(defenc); char* c; for (c = defenc_c; c < end; c++) { if ((unsigned char) (*c) >= 128) { PyUnicode_AsASCIIString(o); return NULL; } } } #endif *length = PyBytes_GET_SIZE(defenc); return defenc_c; } #else static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII if (likely(PyUnicode_IS_ASCII(o))) { *length = PyUnicode_GET_LENGTH(o); return PyUnicode_AsUTF8(o); } else { PyUnicode_AsASCIIString(o); return NULL; } #else return PyUnicode_AsUTF8AndSize(o, length); #endif } #endif #endif static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT if ( #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII __Pyx_sys_getdefaultencoding_not_ascii && #endif PyUnicode_Check(o)) { return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif #if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); } else #endif { char* result; int r = PyBytes_AsStringAndSize(o, &result, length); if (unlikely(r < 0)) { return NULL; } else { return result; } } } static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { int is_true = x == Py_True; if (is_true | (x == Py_False) | (x == Py_None)) return is_true; else return PyObject_IsTrue(x); } static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { int retval; if (unlikely(!x)) return -1; retval = __Pyx_PyObject_IsTrue(x); Py_DECREF(x); return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { #if PY_MAJOR_VERSION >= 3 if (PyLong_Check(result)) { if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, "__int__ returned non-int (type %.200s). " "The ability to return an instance of a strict subclass of int " "is deprecated, and may be removed in a future version of Python.", Py_TYPE(result)->tp_name)) { Py_DECREF(result); return NULL; } return result; } #endif PyErr_Format(PyExc_TypeError, "__%.4s__ returned non-%.4s (type %.200s)", type_name, type_name, Py_TYPE(result)->tp_name); Py_DECREF(result); return NULL; } static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { #if CYTHON_USE_TYPE_SLOTS PyNumberMethods *m; #endif const char *name = NULL; PyObject *res = NULL; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x) || PyLong_Check(x))) #else if (likely(PyLong_Check(x))) #endif return __Pyx_NewRef(x); #if CYTHON_USE_TYPE_SLOTS m = Py_TYPE(x)->tp_as_number; #if PY_MAJOR_VERSION < 3 if (m && m->nb_int) { name = "int"; res = m->nb_int(x); } else if (m && m->nb_long) { name = "long"; res = m->nb_long(x); } #else if (likely(m && m->nb_int)) { name = "int"; res = m->nb_int(x); } #endif #else if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { res = PyNumber_Int(x); } #endif if (likely(res)) { #if PY_MAJOR_VERSION < 3 if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { #else if (unlikely(!PyLong_CheckExact(res))) { #endif return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); } } else if (!PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "an integer is required"); } return res; } static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { Py_ssize_t ival; PyObject *x; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_CheckExact(b))) { if (sizeof(Py_ssize_t) >= sizeof(long)) return PyInt_AS_LONG(b); else return PyInt_AsSsize_t(b); } #endif if (likely(PyLong_CheckExact(b))) { #if CYTHON_USE_PYLONG_INTERNALS const digit* digits = ((PyLongObject*)b)->ob_digit; const Py_ssize_t size = Py_SIZE(b); if (likely(__Pyx_sst_abs(size) <= 1)) { ival = likely(size) ? digits[0] : 0; if (size == -1) ival = -ival; return ival; } else { switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -3: if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case 4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; case -4: if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); } break; } } #endif return PyLong_AsSsize_t(b); } x = PyNumber_Index(b); if (!x) return -1; ival = PyInt_AsSsize_t(x); Py_DECREF(x); return ival; } static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); } static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { return PyInt_FromSize_t(ival); } #endif /* Py_PYTHON_H */ pyfuse3-3.2.0/src/pyfuse3.egg-info/0000775000175000017500000000000013773156367020477 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/src/pyfuse3.egg-info/PKG-INFO0000664000175000017500000000550513773156367021601 0ustar nikrationikratio00000000000000Metadata-Version: 1.2 Name: pyfuse3 Version: 3.2.0 Summary: Python 3 bindings for libfuse 3 with async I/O support Home-page: https://github.com/libfuse/pyfuse3 Author: Nikolaus Rath Author-email: Nikolaus@rath.org License: LGPL Description: .. NOTE: We cannot use sophisticated ReST syntax (like e.g. :file:`foo`) here because this isn't rendered correctly by PyPi and/or BitBucket. The pyfuse3 Module ================== .. start-intro pyfuse3 is a set of Python 3 bindings for `libfuse 3`_. It provides an asynchronous API compatible with Trio_ and asyncio_, and enables you to easily write a full-featured Linux filesystem in Python. pyfuse3 releases can be downloaded from PyPi_. The documentation can be `read online`__ and is also included in the ``doc/html`` directory of the pyfuse3 tarball. Getting Help ------------ Please report any bugs on the `issue tracker`_. For discussion and questions, please use the general `FUSE mailing list`_. A searchable `mailing list archive`_ is kindly provided by Gmane_. Development Status ------------------ pyfuse3 is in beta. Bugs are likely. pyfuse3 uses semantic versioning. This means backwards incompatible changes in the API will be reflected in an increase of the major version number. Contributing ------------ The pyfuse3 source code is available on GitHub_. .. __: http://www.rath.org/pyfuse3-docs/ .. _libfuse 3: http://github.com/libfuse/libfuse .. _FUSE mailing list: https://lists.sourceforge.net/lists/listinfo/fuse-devel .. _issue tracker: https://github.com/libfuse/pyfuse3/issues .. _mailing list archive: http://dir.gmane.org/gmane.comp.file-systems.fuse.devel .. _Gmane: http://www.gmane.org/ .. _PyPi: https://pypi.python.org/pypi/pyfuse3/ .. _GitHub: https://github.com/libfuse/pyfuse3 .. _Trio: https://github.com/python-trio/trio .. _asyncio: https://docs.python.org/3/library/asyncio.html Keywords: FUSE,python Platform: Linux Classifier: Development Status :: 4 - Beta Classifier: Intended Audience :: Developers Classifier: Programming Language :: Python Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Filesystems Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL) Classifier: Operating System :: POSIX :: Linux Classifier: Operating System :: MacOS :: MacOS X Classifier: Operating System :: POSIX :: BSD :: FreeBSD Provides: pyfuse3 Requires-Python: >=3.5 pyfuse3-3.2.0/src/pyfuse3.egg-info/SOURCES.txt0000664000175000017500000000532313773156367022366 0ustar nikrationikratio00000000000000Changes.rst LICENSE README.rst setup.cfg setup.py Include/fuse_common.pxd Include/fuse_lowlevel.pxd Include/fuse_opt.pxd Include/libc_extra.pxd doc/html/.buildinfo doc/html/about.html doc/html/asyncio.html doc/html/changes.html doc/html/data.html doc/html/example.html doc/html/fuse_api.html doc/html/general.html doc/html/genindex.html doc/html/gotchas.html doc/html/index.html doc/html/install.html doc/html/objects.inv doc/html/operations.html doc/html/py-modindex.html doc/html/search.html doc/html/searchindex.js doc/html/util.html doc/html/_sources/about.rst.txt doc/html/_sources/asyncio.rst.txt doc/html/_sources/changes.rst.txt doc/html/_sources/data.rst.txt doc/html/_sources/example.rst.txt doc/html/_sources/fuse_api.rst.txt doc/html/_sources/general.rst.txt doc/html/_sources/gotchas.rst.txt doc/html/_sources/index.rst.txt doc/html/_sources/install.rst.txt doc/html/_sources/operations.rst.txt doc/html/_sources/util.rst.txt doc/html/_static/ajax-loader.gif doc/html/_static/basic.css doc/html/_static/classic.css doc/html/_static/comment-bright.png doc/html/_static/comment-close.png doc/html/_static/comment.png doc/html/_static/default.css doc/html/_static/doctools.js doc/html/_static/documentation_options.js doc/html/_static/down-pressed.png doc/html/_static/down.png doc/html/_static/file.png doc/html/_static/jquery.js doc/html/_static/language_data.js doc/html/_static/minus.png doc/html/_static/plus.png doc/html/_static/pygments.css doc/html/_static/searchtools.js doc/html/_static/sidebar.js doc/html/_static/underscore.js doc/html/_static/up-pressed.png doc/html/_static/up.png doc/html/_static/websupport.js examples/hello.py examples/hello_asyncio.py examples/passthroughfs.py examples/tmpfs.py rst/about.rst rst/asyncio.rst rst/changes.rst rst/conf.py rst/data.rst rst/example.rst rst/fuse_api.rst rst/general.rst rst/gotchas.rst rst/index.rst rst/install.rst rst/operations.rst rst/util.rst rst/_static/.placeholder rst/_templates/localtoc.html src/_pyfuse3.py src/darwin_compat.c src/darwin_compat.h src/gettime.h src/handlers.pxi src/internal.pxi src/macros.c src/macros.pxd src/pyfuse3.c src/pyfuse3.h src/pyfuse3.pyx src/pyfuse3_asyncio.py src/xattr.h src/pyfuse3.egg-info/PKG-INFO src/pyfuse3.egg-info/SOURCES.txt src/pyfuse3.egg-info/dependency_links.txt src/pyfuse3.egg-info/requires.txt src/pyfuse3.egg-info/top_level.txt src/pyfuse3.egg-info/zip-safe test/conftest.py test/pytest.ini test/pytest_checklogs.py test/test_api.py test/test_examples.py test/test_fs.py test/test_rounding.py test/travis-install.sh test/travis-test.sh test/util.py test/.pytest_cache/.gitignore test/.pytest_cache/README.md test/.pytest_cache/v/cache/lastfailed test/.pytest_cache/v/cache/nodeids test/.pytest_cache/v/cache/stepwise util/sphinx_cython.pypyfuse3-3.2.0/src/pyfuse3.egg-info/dependency_links.txt0000664000175000017500000000000113773156367024545 0ustar nikrationikratio00000000000000 pyfuse3-3.2.0/src/pyfuse3.egg-info/requires.txt0000664000175000017500000000001313773156367023071 0ustar nikrationikratio00000000000000trio>=0.15 pyfuse3-3.2.0/src/pyfuse3.egg-info/top_level.txt0000664000175000017500000000004113773156367023224 0ustar nikrationikratio00000000000000_pyfuse3 pyfuse3 pyfuse3_asyncio pyfuse3-3.2.0/src/pyfuse3.egg-info/zip-safe0000664000175000017500000000000113737137453022122 0ustar nikrationikratio00000000000000 pyfuse3-3.2.0/src/pyfuse3.h0000664000175000017500000000146513350426564017152 0ustar nikrationikratio00000000000000/* pyfuse3.h Copyright © 2013 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. */ #define PLATFORM_LINUX 1 #define PLATFORM_BSD 2 #define PLATFORM_DARWIN 3 #ifdef __linux__ #define PLATFORM PLATFORM_LINUX #elif __FreeBSD_kernel__&&__GLIBC__ #define PLATFORM PLATFORM_LINUX #elif __FreeBSD__ #define PLATFORM PLATFORM_BSD #elif __NetBSD__ #define PLATFORM PLATFORM_BSD #elif __APPLE__ && __MACH__ #define PLATFORM PLATFORM_DARWIN #else #error "Unable to determine system (Linux/FreeBSD/NetBSD/Darwin)" #endif #if PLATFORM == PLATFORM_DARWIN #include "darwin_compat.h" #else /* See also: Include/pthreads.pxd */ #include #endif #include #if FUSE_VERSION < 32 #error FUSE version too old, 3.2.0 or newer required #endif pyfuse3-3.2.0/src/pyfuse3.pyx0000664000175000017500000007671713772376256017571 0ustar nikrationikratio00000000000000''' pyfuse3.pxy Copyright © 2013 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' cdef extern from "pyfuse3.h": int PLATFORM enum: PLATFORM_LINUX PLATFORM_BSD PLATFORM_DARWIN ########### # C IMPORTS ########### from fuse_lowlevel cimport * from macros cimport * from posix.stat cimport struct_stat, S_IFMT, S_IFDIR, S_IFREG from posix.types cimport mode_t, dev_t, off_t from libc.stdint cimport uint32_t from libc.stdlib cimport const_char from libc cimport stdlib, string, errno from posix cimport unistd from libc.errno cimport EACCES, ETIMEDOUT, EPROTO, EINVAL, ENOMSG, ENOATTR from posix.unistd cimport getpid from posix.time cimport timespec from cpython.bytes cimport (PyBytes_AsStringAndSize, PyBytes_FromStringAndSize, PyBytes_AsString, PyBytes_FromString, PyBytes_AS_STRING) from cpython.buffer cimport (PyObject_GetBuffer, PyBuffer_Release, PyBUF_CONTIG_RO, PyBUF_CONTIG) cimport cpython.exc cimport cython cimport libc_extra ######################## # EXTERNAL DEFINITIONS # ######################## cdef extern from "" nogil: enum: RENAME_EXCHANGE RENAME_NOREPLACE cdef extern from "Python.h" nogil: int PY_SSIZE_T_MAX # Actually passed as -D to cc (and defined in setup.py) cdef extern from *: char* PYFUSE3_VERSION ################ # PYTHON IMPORTS ################ from pickle import PicklingError from queue import Queue import logging import os import os.path import sys import trio import threading import _pyfuse3 _pyfuse3.FUSEError = FUSEError from _pyfuse3 import Operations, async_wrapper ################## # GLOBAL VARIABLES ################## log = logging.getLogger("pyfuse3") fse = sys.getfilesystemencoding() cdef object operations cdef object mountpoint_b cdef fuse_session* session = NULL cdef fuse_lowlevel_ops fuse_ops cdef int session_fd cdef object py_retval cdef object _notify_queue = None ROOT_INODE = FUSE_ROOT_ID __version__ = PYFUSE3_VERSION.decode('utf-8') _NANOS_PER_SEC = 1000000000 # In the Cython source, we want the names to refer to the # C constants. Therefore, we assign through globals(). g = globals() g['ENOATTR'] = ENOATTR g['RENAME_EXCHANGE'] = RENAME_EXCHANGE g['RENAME_NOREPLACE'] = RENAME_NOREPLACE trio_token = None ####################### # FUSE REQUEST HANDLERS ####################### include "handlers.pxi" ######################################## # INTERNAL FUNCTIONS & DATA STRUCTURES # ######################################## include "internal.pxi" ###################### # EXTERNAL API # ###################### @cython.freelist(10) cdef class RequestContext: ''' Instances of this class are passed to some `Operations` methods to provide information about the caller of the syscall that initiated the request. ''' cdef readonly uid_t uid cdef readonly pid_t pid cdef readonly gid_t gid cdef readonly mode_t umask def __getstate__(self): raise PicklingError("RequestContext instances can't be pickled") @cython.freelist(10) cdef class SetattrFields: ''' `SetattrFields` instances are passed to the `~Operations.setattr` handler to specify which attributes should be updated. ''' cdef readonly object update_atime cdef readonly object update_mtime cdef readonly object update_ctime cdef readonly object update_mode cdef readonly object update_uid cdef readonly object update_gid cdef readonly object update_size def __cinit__(self): self.update_atime = False self.update_mtime = False self.update_ctime = False self.update_mode = False self.update_uid = False self.update_gid = False self.update_size = False def __getstate__(self): raise PicklingError("SetattrFields instances can't be pickled") @cython.freelist(30) cdef class EntryAttributes: ''' Instances of this class store attributes of directory entries. Most of the attributes correspond to the elements of the ``stat`` C struct as returned by e.g. ``fstat`` and should be self-explanatory. ''' # Attributes are documented in rst/data.rst cdef fuse_entry_param fuse_param cdef struct_stat *attr def __cinit__(self): string.memset(&self.fuse_param, 0, sizeof(fuse_entry_param)) self.attr = &self.fuse_param.attr self.fuse_param.generation = 0 self.fuse_param.entry_timeout = 300 self.fuse_param.attr_timeout = 300 self.attr.st_mode = S_IFREG self.attr.st_blksize = 4096 self.attr.st_nlink = 1 @property def st_ino(self): return self.fuse_param.ino @st_ino.setter def st_ino(self, val): self.fuse_param.ino = val self.attr.st_ino = val @property def generation(self): '''The inode generation number''' return self.fuse_param.generation @generation.setter def generation(self, val): self.fuse_param.generation = val @property def attr_timeout(self): '''Validity timeout for the attributes of the directory entry Floating point numbers may be used. Units are seconds. ''' return self.fuse_param.attr_timeout @attr_timeout.setter def attr_timeout(self, val): self.fuse_param.attr_timeout = val @property def entry_timeout(self): '''Validity timeout for the name/existence of the directory entry Floating point numbers may be used. Units are seconds. ''' return self.fuse_param.entry_timeout @entry_timeout.setter def entry_timeout(self, val): self.fuse_param.entry_timeout = val @property def st_mode(self): return self.attr.st_mode @st_mode.setter def st_mode(self, val): self.attr.st_mode = val @property def st_nlink(self): return self.attr.st_nlink @st_nlink.setter def st_nlink(self, val): self.attr.st_nlink = val @property def st_uid(self): return self.attr.st_uid @st_uid.setter def st_uid(self, val): self.attr.st_uid = val @property def st_gid(self): return self.attr.st_gid @st_gid.setter def st_gid(self, val): self.attr.st_gid = val @property def st_rdev(self): return self.attr.st_rdev @st_rdev.setter def st_rdev(self, val): self.attr.st_rdev = val @property def st_size(self): return self.attr.st_size @st_size.setter def st_size(self, val): self.attr.st_size = val @property def st_blocks(self): return self.attr.st_blocks @st_blocks.setter def st_blocks(self, val): self.attr.st_blocks = val @property def st_blksize(self): return self.attr.st_blksize @st_blksize.setter def st_blksize(self, val): self.attr.st_blksize = val @property def st_atime_ns(self): '''Time of last access in (integer) nanoseconds''' return (int(self.attr.st_atime) * _NANOS_PER_SEC + GET_ATIME_NS(self.attr)) @st_atime_ns.setter def st_atime_ns(self, val): self.attr.st_atime = val // _NANOS_PER_SEC SET_ATIME_NS(self.attr, val % _NANOS_PER_SEC) @property def st_mtime_ns(self): '''Time of last modification in (integer) nanoseconds''' return (int(self.attr.st_mtime) * _NANOS_PER_SEC + GET_MTIME_NS(self.attr)) @st_mtime_ns.setter def st_mtime_ns(self, val): self.attr.st_mtime = val // _NANOS_PER_SEC SET_MTIME_NS(self.attr, val % _NANOS_PER_SEC) @property def st_ctime_ns(self): '''Time of last inode modification in (integer) nanoseconds''' return (int(self.attr.st_ctime) * _NANOS_PER_SEC + GET_CTIME_NS(self.attr)) @st_ctime_ns.setter def st_ctime_ns(self, val): self.attr.st_ctime = val // _NANOS_PER_SEC SET_CTIME_NS(self.attr, val % _NANOS_PER_SEC) @property def st_birthtime_ns(self): '''Time of inode creation in (integer) nanoseconds. Only available under BSD and OS X. Will be zero on Linux. ''' # Use C macro to prevent compiler error on Linux # (where st_birthtime does not exist) return int(GET_BIRTHTIME(self.attr) * _NANOS_PER_SEC + GET_BIRTHTIME_NS(self.attr)) @st_birthtime_ns.setter def st_birthtime_ns(self, val): # Use C macro to prevent compiler error on Linux # (where st_birthtime does not exist) SET_BIRTHTIME(self.attr, val // _NANOS_PER_SEC) SET_BIRTHTIME_NS(self.attr, val % _NANOS_PER_SEC) # Pickling and copy support def __getstate__(self): state = dict() for k in ('st_ino', 'generation', 'entry_timeout', 'attr_timeout', 'st_mode', 'st_nlink', 'st_uid', 'st_gid', 'st_rdev', 'st_size', 'st_blksize', 'st_blocks', 'st_atime_ns', 'st_ctime_ns', 'st_mtime_ns', 'st_birthtime_ns'): state[k] = getattr(self, k) return state def __setstate__(self, state): for (k,v) in state.items(): setattr(self, k, v) @cython.freelist(10) cdef class FileInfo: ''' Instances of this class store options and data that `Operations.open` returns. The attributes correspond to the elements of the ``fuse_file_info`` struct that are relevant to the `Operations.open` function. ''' cdef public uint64_t fh cdef public bint direct_io cdef public bint keep_cache cdef public bint nonseekable def __cinit__(self, fh=0, direct_io=0, keep_cache=1, nonseekable=0): self.fh = fh self.direct_io = direct_io self.keep_cache = keep_cache self.nonseekable = nonseekable cdef _copy_to_fuse(self, fuse_file_info *out): out.fh = self.fh # Due to how Cython generates its C code, GCC will complain about # assigning to the bitfields in the fuse_file_info struct. # This is the workaround. if self.direct_io: out.direct_io = 1 else: out.direct_io = 0 if self.keep_cache: out.keep_cache = 1 else: out.keep_cache = 0 if self.nonseekable: out.nonseekable = 1 else: out.nonseekable = 0 @cython.freelist(1) cdef class StatvfsData: ''' Instances of this class store information about the file system. The attributes correspond to the elements of the ``statvfs`` struct, see :manpage:`statvfs(2)` for details. ''' cdef statvfs stat def __cinit__(self): string.memset(&self.stat, 0, sizeof(statvfs)) @property def f_bsize(self): return self.stat.f_bsize @f_bsize.setter def f_bsize(self, val): self.stat.f_bsize = val @property def f_frsize(self): return self.stat.f_frsize @f_frsize.setter def f_frsize(self, val): self.stat.f_frsize = val @property def f_blocks(self): return self.stat.f_blocks @f_blocks.setter def f_blocks(self, val): self.stat.f_blocks = val @property def f_bfree(self): return self.stat.f_bfree @f_bfree.setter def f_bfree(self, val): self.stat.f_bfree = val @property def f_bavail(self): return self.stat.f_bavail @f_bavail.setter def f_bavail(self, val): self.stat.f_bavail = val @property def f_files(self): return self.stat.f_files @f_files.setter def f_files(self, val): self.stat.f_files = val @property def f_ffree(self): return self.stat.f_ffree @f_ffree.setter def f_ffree(self, val): self.stat.f_ffree = val @property def f_favail(self): return self.stat.f_favail @f_favail.setter def f_favail(self, val): self.stat.f_favail = val @property def f_namemax(self): return self.stat.f_namemax @f_namemax.setter def f_namemax(self, val): self.stat.f_namemax = val # Pickling and copy support def __getstate__(self): state = dict() for k in ('f_bsize', 'f_frsize', 'f_blocks', 'f_bfree', 'f_bavail', 'f_files', 'f_ffree', 'f_favail', 'f_namemax'): state[k] = getattr(self, k) return state def __setstate__(self, state): for (k,v) in state.items(): setattr(self, k, v) # As of Cython 0.28.1, @cython.freelist cannot be used for # classes that derive from a builtin type. cdef class FUSEError(Exception): ''' This exception may be raised by request handlers to indicate that the requested operation could not be carried out. The system call that resulted in the request (if any) will then fail with error code *errno_*. ''' # If we call this variable "errno", we will get syntax errors # during C compilation (maybe something else declares errno as # a macro?) cdef readonly int errno_ @property def errno(self): '''Error code to return to client process''' return self.errno_ def __cinit__(self, errno): self.errno_ = errno def __str__(self): return strerror(self.errno_) def listdir(path): '''Like `os.listdir`, but releases the GIL. This function returns an iterator over the directory entries in *path*. The returned values are of type :ref:`str `. Surrogate escape coding (cf. `PEP 383 `_) is used for directory names that do not have a string representation. ''' if not isinstance(path, str): raise TypeError('*path* argument must be of type str') cdef libc_extra.DIR* dirp cdef libc_extra.dirent* res cdef char* buf path_b = str2bytes(path) buf = path_b with nogil: dirp = libc_extra.opendir(buf) if dirp == NULL: raise OSError(errno.errno, strerror(errno.errno), path) names = list() while True: errno.errno = 0 with nogil: res = libc_extra.readdir(dirp) if res is NULL: if errno.errno != 0: raise OSError(errno.errno, strerror(errno.errno), path) else: break if string.strcmp(res.d_name, b'.') == 0 or \ string.strcmp(res.d_name, b'..') == 0: continue names.append(bytes2str(PyBytes_FromString(res.d_name))) with nogil: libc_extra.closedir(dirp) return names def syncfs(path): '''Sync filesystem mounted at *path* This is a Python interface to the syncfs(2) system call. There is no particular relation to libfuse, it is provided by pyfuse3 as a convience. ''' cdef int ret fd = os.open(path, flags=os.O_DIRECTORY) try: ret = libc_extra.syncfs(fd) if ret != 0: raise OSError(errno.errno, strerror(errno.errno), path) finally: os.close(fd) def setxattr(path, name, bytes value, namespace='user'): '''Set extended attribute *path* and *name* have to be of type `str`. In Python 3.x, they may contain surrogates. *value* has to be of type `bytes`. Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to select the namespace for the extended attribute. For other platforms, this parameter is ignored. In contrast to the `os.setxattr` function from the standard library, the method provided by pyfuse3 is also available for non-Linux systems. ''' if not isinstance(path, str): raise TypeError('*path* argument must be of type str') if not isinstance(name, str): raise TypeError('*name* argument must be of type str') if namespace not in ('system', 'user'): raise ValueError('*namespace* parameter must be "system" or "user", not %s' % namespace) cdef int ret cdef Py_ssize_t len_ cdef char *cvalue cdef char *cpath cdef char *cname cdef int cnamespace if namespace == 'system': cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM else: cnamespace = libc_extra.EXTATTR_NAMESPACE_USER path_b = str2bytes(path) name_b = str2bytes(name) PyBytes_AsStringAndSize(value, &cvalue, &len_) cpath = path_b cname = name_b with nogil: # len_ is guaranteed positive ret = libc_extra.setxattr_p( cpath, cname, cvalue, len_, cnamespace) if ret != 0: raise OSError(errno.errno, strerror(errno.errno), path) def getxattr(path, name, size_t size_guess=128, namespace='user'): '''Get extended attribute *path* and *name* have to be of type `str`. In Python 3.x, they may contain surrogates. Returns a value of type `bytes`. If the caller knows the approximate size of the attribute value, it should be supplied in *size_guess*. If the guess turns out to be wrong, the system call has to be carried out three times (the first call will fail, the second determines the size and the third finally gets the value). Under FreeBSD, the *namespace* parameter may be set to *system* or *user* to select the namespace for the extended attribute. For other platforms, this parameter is ignored. In contrast to the `os.getxattr` function from the standard library, the method provided by pyfuse3 is also available for non-Linux systems. ''' if not isinstance(path, str): raise TypeError('*path* argument must be of type str') if not isinstance(name, str): raise TypeError('*name* argument must be of type str') if namespace not in ('system', 'user'): raise ValueError('*namespace* parameter must be "system" or "user", not %s' % namespace) cdef ssize_t ret cdef char *buf cdef char *cpath cdef char *cname cdef size_t bufsize cdef int cnamespace if namespace == 'system': cnamespace = libc_extra.EXTATTR_NAMESPACE_SYSTEM else: cnamespace = libc_extra.EXTATTR_NAMESPACE_USER path_b = str2bytes(path) name_b = str2bytes(name) cpath = path_b cname = name_b bufsize = size_guess buf = stdlib.malloc(bufsize * sizeof(char)) if buf is NULL: cpython.exc.PyErr_NoMemory() try: with nogil: ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) if ret < 0 and errno.errno == errno.ERANGE: with nogil: ret = libc_extra.getxattr_p(cpath, cname, NULL, 0, cnamespace) if ret < 0: raise OSError(errno.errno, strerror(errno.errno), path) bufsize = ret stdlib.free(buf) buf = stdlib.malloc(bufsize * sizeof(char)) if buf is NULL: cpython.exc.PyErr_NoMemory() with nogil: ret = libc_extra.getxattr_p(cpath, cname, buf, bufsize, cnamespace) if ret < 0: raise OSError(errno.errno, strerror(errno.errno), path) return PyBytes_FromStringAndSize(buf, ret) finally: stdlib.free(buf) default_options = frozenset(('default_permissions',)) def init(ops, mountpoint, options=default_options): '''Initialize and mount FUSE file system *ops* has to be an instance of the `Operations` class (or another class defining the same methods). *args* has to be a set of strings. `default_options` provides some reasonable defaults. It is recommended to use these options as a basis and add or remove options as necessary. For example:: my_opts = set(pyfuse3.default_options) my_opts.add('allow_other') my_opts.discard('default_permissions') pyfuse3.init(ops, mountpoint, my_opts) Valid options are listed under ``struct fuse_opt fuse_mount_opts[]`` (in `mount.c `_) and ``struct fuse_opt fuse_ll_opts[]`` (in `fuse_lowlevel_c `_). ''' log.debug('Initializing pyfuse3') cdef fuse_args f_args cdef int res if not isinstance(mountpoint, str): raise TypeError('*mountpoint_* argument must be of type str') global operations global fuse_ops global mountpoint_b global session global session_fd global worker_data worker_data = _WorkerData() mountpoint_b = str2bytes(os.path.abspath(mountpoint)) operations = ops make_fuse_args(options, &f_args) log.debug('Calling fuse_session_new') init_fuse_ops() session = fuse_session_new(&f_args, &fuse_ops, sizeof(fuse_ops), NULL) if not session: raise RuntimeError("fuse_session_new() failed") log.debug('Calling fuse_session_mount') res = fuse_session_mount(session, mountpoint_b) if res != 0: raise RuntimeError('fuse_session_mount failed') session_fd = fuse_session_fd(session) @async_wrapper async def main(int min_tasks=1, int max_tasks=99): '''Run FUSE main loop''' if session == NULL: raise RuntimeError('Need to call init() before main()') global trio_token trio_token = trio.lowlevel.current_trio_token() try: async with trio.open_nursery() as nursery: worker_data.task_count = 1 worker_data.task_serial = 1 nursery.start_soon(_session_loop, nursery, min_tasks, max_tasks, name=worker_data.get_name()) finally: trio_token = None if _notify_queue is not None: _notify_queue.put(None) def terminate(): '''Terminate FUSE main loop. This function gracefully terminates the FUSE main loop (resulting in the call to main() to return). When called by a thread different from the one that runs the main loop, the call must be wrapped with `trio.from_thread.run_sync`. The necessary *trio_token* argument can (for convience) be retrieved from the `trio_token` module attribute. ''' fuse_session_exit(session) trio.lowlevel.notify_closing(session_fd) def close(unmount=True): '''Clean up and ensure filesystem is unmounted If *unmount* is False, only clean up operations are peformed, but the file system is not explicitly unmounted. Normally, the filesystem is unmounted by the user calling umount(8) or fusermount(1), which then terminates the FUSE main loop. However, the loop may also terminate as a result of an exception or a signal. In this case the filesystem remains mounted, but any attempt to access it will block (while the filesystem process is still running) or (after the filesystem process has terminated) return an error. If *unmount* is True, this function will ensure that the filesystem is properly unmounted. Note: if the connection to the kernel is terminated via the ``/sys/fs/fuse/connections/`` interface, this function will *not* unmount the filesystem even if *unmount* is True. ''' global mountpoint_b global session if unmount: log.debug('Calling fuse_session_unmount') fuse_session_unmount(session) log.debug('Calling fuse_session_destroy') fuse_session_destroy(session) mountpoint_b = None session = NULL def invalidate_inode(fuse_ino_t inode, attr_only=False): '''Invalidate cache for *inode* Instructs the FUSE kernel module to forgot cached attributes and data (unless *attr_only* is True) for *inode*. **This operation may block** if writeback caching is active and there is dirty data for the inode that is to be invalidated. Unfortunately there is no way to return control to the event loop until writeback is complete (leading to a deadlock if the necessary write() requests cannot be processed by the filesystem). Unless writeback caching is disabled, this function should therefore be called from a separate thread. If the operation is not supported by the kernel, raises `OSError` with errno ENOSYS. ''' cdef int ret if attr_only: with nogil: ret = fuse_lowlevel_notify_inval_inode(session, inode, -1, 0) else: with nogil: ret = fuse_lowlevel_notify_inval_inode(session, inode, 0, 0) if ret != 0: raise OSError(-ret, 'fuse_lowlevel_notify_inval_inode returned: ' + strerror(-ret)) def invalidate_entry(fuse_ino_t inode_p, bytes name, fuse_ino_t deleted=0): '''Invalidate directory entry Instructs the FUSE kernel module to forget about the directory entry *name* in the directory with inode *inode_p*. If the inode passed as *deleted* matches the inode that is currently associated with *name* by the kernel, any inotify watchers of this inode are informed that the entry has been deleted. If there is a pending filesystem operation that is related to the parent directory or directory entry, this function will block until that operation has completed. Therefore, to avoid a deadlock this function must not be called while handling a related request, nor while holding a lock that could be needed for handling such a request. As for kernel 4.18, a "related operation" is a `~Operations.lookup`, `~Operations.symlink`, `~Operations.mknod`, `~Operations.mkdir`, `~Operations.unlink`, `~Operations.rename`, `~Operations.link` or `~Operations.create` request for the parent, and a `~Operations.setattr`, `~Operations.unlink`, `~Operations.rmdir`, `~Operations.rename`, `~Operations.setxattr`, `~Operations.removexattr` or `~Operations.readdir` request for the inode itself. For technical reasons, this function can also not return control to the main event loop but will actually block. To return control to the event loop while this function is running, call it in a separate thread using `trio.run_sync_in_worker_thread `_. A less complicated alternative is to use the `invalidate_entry_async` function instead. ''' cdef char *cname cdef ssize_t slen cdef size_t len_ cdef int ret PyBytes_AsStringAndSize(name, &cname, &slen) # len_ is guaranteed positive len_ = slen if deleted: with nogil: # might block! ret = fuse_lowlevel_notify_delete(session, inode_p, deleted, cname, len_) if ret != 0: raise OSError(-ret, 'fuse_lowlevel_notify_delete returned: ' + strerror(-ret)) else: with nogil: # might block! ret = fuse_lowlevel_notify_inval_entry(session, inode_p, cname, len_) if ret != 0: raise OSError(-ret, 'fuse_lowlevel_notify_inval_entry returned: ' + strerror(-ret)) def invalidate_entry_async(inode_p, name, deleted=0, ignore_enoent=False): '''Asynchronously invalidate directory entry This function performs the same operation as `invalidate_entry`, but does so asynchronously in a separate thread. This avoids the deadlocks that may occur when using `invalidate_entry` from within a request handler, but means that the function generally returns before the kernel has actually invalidated the entry, and that no errors can be reported (they will be logged though). The directory entries that are to be invalidated are put in an unbounded queue which is processed by a single thread. This means that if the entry at the beginning of the queue cannot be invalidated yet because a related file system operation is still in progress, none of the other entries will be processed and repeated calls to this function will result in continued growth of the queue. If there are errors, an exception is logged using the `logging` module. If *ignore_enoent* is True, ignore ENOENT errors (which occur if the kernel doesn't actually have knowledge of the entry that is to be removed). ''' global _notify_queue if _notify_queue is None: log.debug('Starting notify worker.') _notify_queue = Queue() t = threading.Thread(target=_notify_loop) t.daemon = True t.start() _notify_queue.put((inode_p, name, deleted, ignore_enoent)) def notify_store(inode, offset, data): '''Store data in kernel page cache Sends *data* for the kernel to store it in the page cache for *inode* at *offset*. If this provides data beyond the current file size, the file is automatically extended. If this function raises an exception, the store may still have completed partially. If the operation is not supported by the kernel, raises `OSError` with errno ENOSYS. ''' # This should not block, but the kernel may need to do some work so release # the GIL to give other threads a chance to run. cdef int ret cdef fuse_ino_t ino cdef off_t off cdef Py_buffer pybuf cdef fuse_bufvec bufvec cdef fuse_buf *buf PyObject_GetBuffer(data, &pybuf, PyBUF_CONTIG_RO) bufvec.count = 1 bufvec.idx = 0 bufvec.off = 0 buf = bufvec.buf buf[0].flags = 0 buf[0].mem = pybuf.buf buf[0].size = pybuf.len # guaranteed positive ino = inode off = offset with nogil: ret = fuse_lowlevel_notify_store(session, ino, off, &bufvec, 0) PyBuffer_Release(&pybuf) if ret != 0: raise OSError(-ret, 'fuse_lowlevel_notify_store returned: ' + strerror(-ret)) def get_sup_groups(pid): '''Return supplementary group ids of *pid* This function is relatively expensive because it has to read the group ids from ``/proc/[pid]/status``. For the same reason, it will also not work on systems that do not provide a ``/proc`` file system. Returns a set. ''' with open('/proc/%d/status' % pid, 'r') as fh: for line in fh: if line.startswith('Groups:'): break else: raise RuntimeError("Unable to parse %s" % fh.name) gids = set() for x in line.split()[1:]: gids.add(int(x)) return gids def readdir_reply(ReaddirToken token, name, EntryAttributes attr, off_t next_id): '''Report a directory entry in response to a `~Operations.readdir` request. This function should be called by the `~Operations.readdir` handler to provide the list of directory entries. The function should be called once for each directory entry, until it returns False. *token* must be the token received by the `~Operations.readdir` handler. *name* and must be the name of the directory entry and *attr* an `EntryAttributes` instance holding its attributes. *next_id* must be a 64-bit integer value that uniquely identifies the current position in the list of directory entries. It may be passed back to a later `~Operations.readdir` call to start another listing at the right position. This value should be robust in the presence of file removals and creations, i.e. if files are created or removed after a call to `~Operations.readdir` and `~Operations.readdir` is called again with *start_id* set to any previously supplied *next_id* values, under no circumstances must any file be reported twice or skipped over. ''' cdef char *cname if token.buf_start == NULL: token.buf_start = calloc_or_raise(token.size, sizeof(char)) token.buf = token.buf_start cname = PyBytes_AsString(name) len_ = fuse_add_direntry_plus(token.req, token.buf, token.size, cname, &attr.fuse_param, next_id) if len_ > token.size: return False token.size -= len_ token.buf = &token.buf[len_] return True pyfuse3-3.2.0/src/pyfuse3_asyncio.py0000664000175000017500000000466213772375557021117 0ustar nikrationikratio00000000000000''' pyfuse3_asyncio.py asyncio compatibility layer for pyfuse3 Copyright © 2018 Nikolaus Rath Copyright © 2018 JustAnotherArchivist This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' import asyncio import pyfuse3 import sys import collections Lock = asyncio.Lock def enable(): '''Switch pyfuse3 to asyncio mode.''' fake_trio = sys.modules['pyfuse3_asyncio'] fake_trio.lowlevel = fake_trio fake_trio.from_thread = fake_trio pyfuse3.trio = fake_trio def disable(): '''Switch pyfuse3 to default (trio) mode.''' pyfuse3.trio = sys.modules['trio'] def current_trio_token(): return 'asyncio' _read_futures = collections.defaultdict(set) async def wait_readable(fd): future = asyncio.Future() _read_futures[fd].add(future) try: loop = asyncio.get_event_loop() loop.add_reader(fd, future.set_result, None) future.add_done_callback(lambda f: loop.remove_reader(fd)) await future finally: _read_futures[fd].remove(future) if not _read_futures[fd]: del _read_futures[fd] def notify_closing(fd): for f in _read_futures[fd]: f.set_exception(ClosedResourceError()) class ClosedResourceError(Exception): pass def current_task(): if sys.version_info < (3, 7): return asyncio.Task.current_task() else: return asyncio.current_task() class _Nursery: async def __aenter__(self): self.tasks = set() return self def start_soon(self, func, *args, name = None): if sys.version_info < (3, 7): task = asyncio.ensure_future(func(*args)) else: task = asyncio.create_task(func(*args)) task.name = name self.tasks.add(task) async def __aexit__(self, exc_type, exc_value, traceback): # Wait for tasks to finish while len(self.tasks): # Create a copy of the task list to ensure that it's not a problem # when self.tasks is modified done, pending = await asyncio.wait(tuple(self.tasks)) for task in done: self.tasks.discard(task) # We waited for ALL_COMPLETED (default value of 'when' arg to # asyncio.wait), so all tasks should be completed. If that's not the # case, something's seriously wrong. assert len(pending) == 0 def open_nursery(): return _Nursery() pyfuse3-3.2.0/src/xattr.h0000664000175000017500000000664613347530014016714 0ustar nikrationikratio00000000000000/* * xattr.h * * Platform-independent interface to extended attributes * * Copyright © 2015 Nikolaus Rath * * This file is part of pyfuse3. This work may be distributed under the * terms of the GNU LGPL. */ #ifndef UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) # define UNUSED __attribute__ ((__unused__)) # else # define UNUSED # endif # else # define UNUSED # endif #endif /* * Linux */ #if PLATFORM == PLATFORM_LINUX #include /* * Newer versions of attr deprecate attr/xattr.h which defines ENOATTR as a * synonym for ENODATA. To keep compatibility with the old style and the new, * define this ourselves. */ #ifndef ENOATTR #define ENOATTR ENODATA #endif #define EXTATTR_NAMESPACE_USER 0 #define EXTATTR_NAMESPACE_SYSTEM 0 #define XATTR_NOFOLLOW 0 #define XATTR_NODEFAULT 0 #define XATTR_NOSECURITY 0 static ssize_t getxattr_p (char *path, char *name, void *value, size_t size, UNUSED int namespace) { return getxattr(path, name, value, size); } static int setxattr_p (char *path, char *name, void *value, size_t size, UNUSED int namespace) { return setxattr(path, name, value, size, 0); } /* * FreeBSD & NetBSD */ #elif PLATFORM == PLATFORM_BSD #include #include #include #include #define XATTR_NOFOLLOW 0 #define XATTR_NODEFAULT 0 #define XATTR_NOSECURITY 0 /* FreeBSD doesn't have on operation to only set the attribute if it already exists (XATTR_REPLACE), or only if it does not yet exist (XATTR_CREATE). Setting these values to zero ensures that we can never test positively for them */ #define XATTR_CREATE 0 #define XATTR_REPLACE 0 static ssize_t getxattr_p (char *path, char *name, void *value, size_t size, int namespace) { /* If size > SSIZE_MAX, we cannot determine if we got all the data (because the return value doesn't fit into ssize_t) */ if (size >= SSIZE_MAX) { errno = EINVAL; return -1; } ssize_t ret; ret = extattr_get_file(path, namespace, name, value, size); if (ret > 0 && (size_t) ret == size) { errno = ERANGE; return -1; } return ret; } static int setxattr_p (char *path, char *name, void *value, size_t size, int namespace) { if (size >= SSIZE_MAX) { errno = EINVAL; return -1; } ssize_t ret; ret = extattr_set_file(path, namespace, name, value, size); if (ret < 0) { /* Errno values really ought to fit into int, but better safe than sorry */ if (ret < INT_MIN) return -EOVERFLOW; else return (int) ret; } if ((size_t)ret != size) { errno = ENOSPC; return -1; } return 0; } /* * Darwin */ #elif PLATFORM == PLATFORM_DARWIN #include #define EXTATTR_NAMESPACE_USER 0 #define EXTATTR_NAMESPACE_SYSTEM 0 static ssize_t getxattr_p (char *path, char *name, void *value, size_t size, UNUSED int namespace) { return getxattr(path, name, value, size, 0, 0); } static int setxattr_p (char *path, char *name, void *value, size_t size, UNUSED int namespace) { return setxattr(path, name, value, size, 0, 0); } /* * Unknown system */ #else #error This should not happen #endif pyfuse3-3.2.0/test/0000775000175000017500000000000013773156367015577 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/test/.pytest_cache/0000775000175000017500000000000013773156367020330 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/test/.pytest_cache/.gitignore0000664000175000017500000000006213655322114022276 0ustar nikrationikratio00000000000000# created by pytest automatically, do not change *pyfuse3-3.2.0/test/.pytest_cache/README.md0000664000175000017500000000044713655321366021604 0ustar nikrationikratio00000000000000# pytest cache directory # This directory contains data from the pytest's cache plugin, which provides the `--lf` and `--ff` options, as well as the `cache` fixture. **Do not** commit this to version control. See [the docs](https://docs.pytest.org/en/latest/cache.html) for more information. pyfuse3-3.2.0/test/.pytest_cache/v/0000775000175000017500000000000013773156367020575 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/test/.pytest_cache/v/cache/0000775000175000017500000000000013773156367021640 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/test/.pytest_cache/v/cache/lastfailed0000664000175000017500000000036413772375600023666 0ustar nikrationikratio00000000000000{ "test_foo.py::test_fd1_error": true, "test_foo.py::test_fd2_error": true, "test_foo.py::test_log_error": true, "test_foo.py::test_log_warning": true, "test_foo.py::test_stderr_error": true, "test_foo.py::test_stdout_error": true }pyfuse3-3.2.0/test/.pytest_cache/v/cache/nodeids0000664000175000017500000000165613772376444023217 0ustar nikrationikratio00000000000000[ "test_api.py::test_listdir", "test_api.py::test_sup_groups", "test_api.py::test_syncfs", "test_api.py::test_entry_res", "test_api.py::test_xattr", "test_api.py::test_copy", "test_examples.py::test_hello[hello.py]", "test_examples.py::test_hello[hello_asyncio.py]", "test_examples.py::test_tmpfs", "test_examples.py::test_passthroughfs", "test_fs.py::test_invalidate_entry", "test_fs.py::test_invalidate_inode", "test_fs.py::test_notify_store", "test_fs.py::test_entry_timeout", "test_fs.py::test_attr_timeout", "test_foo.py::test_ok", "test_foo.py::test_log_info", "test_foo.py::test_log_warning", "test_foo.py::test_log_error", "test_foo.py::test_stdout_ok", "test_foo.py::test_stderr_ok", "test_foo.py::test_stdout_error", "test_foo.py::test_stderr_error", "test_foo.py::test_fd1_error", "test_foo.py::test_fd2_error", "test_fs.py::test_terminate", "test_rounding.py::test_rounding" ]pyfuse3-3.2.0/test/.pytest_cache/v/cache/stepwise0000664000175000017500000000000213772376444023415 0ustar nikrationikratio00000000000000[]pyfuse3-3.2.0/test/conftest.py0000664000175000017500000000710713347530014017761 0ustar nikrationikratio00000000000000import sys import os.path import logging import pytest import time import gc # Enable output checks pytest_plugins = ('pytest_checklogs') # Register false positives @pytest.fixture(autouse=True) def register_false_checklog_pos(reg_output): # DeprecationWarnings are unfortunately quite often a result of indirect # imports via third party modules, so we can't actually fix them. reg_output(r'(Pending)?DeprecationWarning', count=0) # Valgrind output reg_output(r'^==\d+== Memcheck, a memory error detector$') reg_output(r'^==\d+== For counts of detected and suppressed errors, rerun with: -v') reg_output(r'^==\d+== ERROR SUMMARY: 0 errors from 0 contexts') def pytest_addoption(parser): group = parser.getgroup("general") group._addoption("--installed", action="store_true", default=False, help="Test the installed package.") group = parser.getgroup("terminal reporting") group._addoption("--logdebug", action="append", metavar='', help="Activate debugging output from for tests. Use `all` " "to get debug messages from all modules. This option can be " "specified multiple times.") # If a test fails, wait a moment before retrieving the captured # stdout/stderr. When using a server process, this makes sure that we capture # any potential output of the server that comes *after* a test has failed. For # example, if a request handler raises an exception, the server first signals an # error to FUSE (causing the test to fail), and then logs the exception. Without # the extra delay, the exception will go into nowhere. @pytest.mark.hookwrapper def pytest_pyfunc_call(pyfuncitem): outcome = yield failed = outcome.excinfo is not None if failed: time.sleep(1) def pytest_configure(config): # If we are running from the source directory, make sure that we load # modules from here basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) if not config.getoption('installed'): pyfuse3_path = os.path.join(basedir, 'src') if (os.path.exists(os.path.join(basedir, 'setup.py')) and os.path.exists(os.path.join(basedir, 'src', 'pyfuse3.pyx'))): sys.path.insert(0, pyfuse3_path) # Make sure that called processes use the same path pp = os.environ.get('PYTHONPATH', None) if pp: pp = '%s:%s' % (pyfuse3_path, pp) else: pp = pyfuse3_path os.environ['PYTHONPATH'] = pp try: import faulthandler except ImportError: pass else: faulthandler.enable() # When running from VCS repo, enable all warnings if os.path.exists(os.path.join(basedir, 'MANIFEST.in')): import warnings warnings.resetwarnings() warnings.simplefilter('default') # Configure logging. We don't set a default handler but rely on # the catchlog pytest plugin. logdebug = config.getoption('logdebug') root_logger = logging.getLogger() if logdebug is not None: logging.disable(logging.NOTSET) if 'all' in logdebug: root_logger.setLevel(logging.DEBUG) else: for module in logdebug: logging.getLogger(module).setLevel(logging.DEBUG) else: root_logger.setLevel(logging.INFO) logging.disable(logging.DEBUG) logging.captureWarnings(capture=True) # Run gc.collect() at the end of every test, so that we get ResourceWarnings # as early as possible. def pytest_runtest_teardown(item, nextitem): gc.collect() pyfuse3-3.2.0/test/pytest.ini0000664000175000017500000000012113756177115017615 0ustar nikrationikratio00000000000000[pytest] addopts = --verbose --assert=rewrite --tb=native -x markers = uses_fuse pyfuse3-3.2.0/test/pytest_checklogs.py0000664000175000017500000000745513756200206021515 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 ''' pytest_checklogs.py - this file is part of S3QL. Copyright (C) 2008 Nikolaus Rath This work can be distributed under the terms of the GNU GPLv3. py.test plugin to look for suspicious phrases in messages emitted on stdout/stderr or via the logging module. False positives can be registered via a new `reg_output` fixture (for messages to stdout/stderr), and a `assert_logs` function (for logging messages). ''' import pytest import re import functools import sys import logging from contextlib import contextmanager class CountMessagesHandler(logging.Handler): def __init__(self, level=logging.NOTSET): super().__init__(level) self.count = 0 def emit(self, record): self.count += 1 @contextmanager def assert_logs(pattern, level=logging.WARNING, count=None): '''Assert that suite emits specified log message *pattern* is matched against the *unformatted* log message, i.e. before any arguments are merged. If *count* is not None, raise an exception unless exactly *count* matching messages are caught. Matched log records will also be flagged so that the caplog fixture does not generate exceptions for them (no matter their severity). ''' def filter(record): if (record.levelno == level and re.search(pattern, record.msg)): record.checklogs_ignore = True return True return False handler = CountMessagesHandler() handler.setLevel(level) handler.addFilter(filter) logger = logging.getLogger() logger.addHandler(handler) try: yield finally: logger.removeHandler(handler) if count is not None and handler.count != count: pytest.fail('Expected to catch %d %r messages, but got only %d' % (count, pattern, handler.count)) def check_test_output(capfd, item): (stdout, stderr) = capfd.readouterr() # Strip out false positives try: false_pos = item.checklogs_fp except AttributeError: false_pos = () for (pattern, flags, count) in false_pos: cp = re.compile(pattern, flags) (stdout, cnt) = cp.subn('', stdout, count=count) if count == 0 or count - cnt > 0: stderr = cp.sub('', stderr, count=count - cnt) for pattern in ('exception', 'error', 'warning', 'fatal', 'traceback', 'fault', 'crash(?:ed)?', 'abort(?:ed)', 'fishy'): cp = re.compile(r'\b{}\b'.format(pattern), re.IGNORECASE | re.MULTILINE) hit = cp.search(stderr) if hit: pytest.fail('Suspicious output to stderr (matched "%s")' % hit.group(0)) hit = cp.search(stdout) if hit: pytest.fail('Suspicious output to stdout (matched "%s")' % hit.group(0)) def register_output(item, pattern, count=1, flags=re.MULTILINE): '''Register *pattern* as false positive for output checking This prevents the test from failing because the output otherwise appears suspicious. ''' item.checklogs_fp.append((pattern, flags, count)) @pytest.fixture() def reg_output(request): assert not hasattr(request.node, 'checklogs_fp') request.node.checklogs_fp = [] return functools.partial(register_output, request.node) # Autouse fixtures are instantiated before explicitly used fixtures, this should also # catch log messages emitted when e.g. initializing resources in other fixtures. @pytest.fixture(autouse=True) def check_output(caplog, capfd, request): yield for when in ("setup", "call", "teardown"): for record in caplog.get_records(when): if (record.levelno >= logging.WARNING and not getattr(record, 'checklogs_ignore', False)): pytest.fail('Logger received warning messages.') check_test_output(capfd, request.node) pyfuse3-3.2.0/test/test_api.py0000775000175000017500000000530113354207541017745 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' test_api.py - Unit tests for pyfuse3. Copyright © 2015 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' if __name__ == '__main__': import pytest import sys sys.exit(pytest.main([__file__] + sys.argv[1:])) import pyfuse3 import tempfile import os import errno import pytest from copy import copy from pickle import PicklingError def test_listdir(): # There is a race-condition here if /usr/bin is modified while the test # runs - but hopefully this is sufficiently rare. list1 = set(os.listdir('/usr/bin')) list2 = set(pyfuse3.listdir('/usr/bin')) assert list1 == list2 def test_sup_groups(): gids = pyfuse3.get_sup_groups(os.getpid()) gids2 = set(os.getgroups()) assert gids == gids2 def test_syncfs(): pyfuse3.syncfs('.') def _getxattr_helper(path, name): try: value = pyfuse3.getxattr(path, name) except OSError as exc: errno = exc.errno value = None if not hasattr(os, 'getxattr'): return value try: value2 = os.getxattr(path, name) except OSError as exc: assert exc.errno == errno else: assert value2 is not None assert value2 == value return value def test_entry_res(): a = pyfuse3.EntryAttributes() val = 1000.2735 a.st_atime_ns = val*1e9 assert a.st_atime_ns / 1e9 == val def test_xattr(): with tempfile.NamedTemporaryFile() as fh: key = 'user.new_attribute' assert _getxattr_helper(fh.name, key) is None value = b'a nice little bytestring' try: pyfuse3.setxattr(fh.name, key, value) except OSError as exc: if exc.errno == errno.ENOTSUP: pytest.skip('ACLs not supported for %s' % fh.name) raise assert _getxattr_helper(fh.name, key) == value if not hasattr(os, 'setxattr'): return key = 'user.another_new_attribute' assert _getxattr_helper(fh.name, key) is None value = b'a nice little bytestring, but slightly modified' os.setxattr(fh.name, key, value) assert _getxattr_helper(fh.name, key) == value def test_copy(): for obj in (pyfuse3.SetattrFields(), pyfuse3.RequestContext()): pytest.raises(PicklingError, copy, obj) for (inst, attr) in ((pyfuse3.EntryAttributes(), 'st_mode'), (pyfuse3.StatvfsData(), 'f_files')): setattr(inst, attr, 42) inst_copy = copy(inst) assert getattr(inst, attr) == getattr(inst_copy, attr) inst = pyfuse3.FUSEError(10) assert inst.errno == copy(inst).errno pyfuse3-3.2.0/test/test_examples.py0000775000175000017500000003212113772360360021015 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' test_examples.py - Unit tests for pyfuse3. Copyright © 2015 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' if __name__ == '__main__': import pytest import sys sys.exit(pytest.main([__file__] + sys.argv[1:])) import subprocess import os import sys import pytest import stat import shutil import filecmp import errno from tempfile import NamedTemporaryFile from util import fuse_test_marker, wait_for_mount, umount, cleanup from pyfuse3 import _NANOS_PER_SEC basename = os.path.join(os.path.dirname(__file__), '..') TEST_FILE = __file__ pytestmark = fuse_test_marker() with open(TEST_FILE, 'rb') as fh: TEST_DATA = fh.read() def name_generator(__ctr=[0]): __ctr[0] += 1 return 'testfile_%d' % __ctr[0] @pytest.mark.parametrize('filename', ('hello.py', 'hello_asyncio.py')) def test_hello(tmpdir, filename): mnt_dir = str(tmpdir) cmdline = [sys.executable, os.path.join(basename, 'examples', filename), mnt_dir ] mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True) try: wait_for_mount(mount_process, mnt_dir) assert os.listdir(mnt_dir) == [ 'message' ] filename = os.path.join(mnt_dir, 'message') with open(filename, 'r') as fh: assert fh.read() == 'hello world\n' with pytest.raises(IOError) as exc_info: open(filename, 'r+') assert exc_info.value.errno == errno.EACCES with pytest.raises(IOError) as exc_info: open(filename + 'does-not-exist', 'r+') assert exc_info.value.errno == errno.ENOENT except: cleanup(mount_process, mnt_dir) raise else: umount(mount_process, mnt_dir) def test_tmpfs(tmpdir): mnt_dir = str(tmpdir) cmdline = [sys.executable, os.path.join(basename, 'examples', 'tmpfs.py'), mnt_dir ] mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True) try: wait_for_mount(mount_process, mnt_dir) tst_write(mnt_dir) tst_mkdir(mnt_dir) tst_symlink(mnt_dir) tst_mknod(mnt_dir) tst_chown(mnt_dir) tst_chmod(mnt_dir) tst_utimens(mnt_dir) tst_rounding(mnt_dir) tst_link(mnt_dir) tst_rename(mnt_dir) tst_readdir(mnt_dir) tst_statvfs(mnt_dir) tst_truncate_path(mnt_dir) tst_truncate_fd(mnt_dir) tst_unlink(mnt_dir) except: cleanup(mount_process, mnt_dir) raise else: umount(mount_process, mnt_dir) def test_passthroughfs(tmpdir): mnt_dir = str(tmpdir.mkdir('mnt')) src_dir = str(tmpdir.mkdir('src')) cmdline = [sys.executable, os.path.join(basename, 'examples', 'passthroughfs.py'), src_dir, mnt_dir ] mount_process = subprocess.Popen(cmdline, stdin=subprocess.DEVNULL, universal_newlines=True) try: wait_for_mount(mount_process, mnt_dir) tst_write(mnt_dir) tst_mkdir(mnt_dir) tst_symlink(mnt_dir) tst_mknod(mnt_dir) if os.getuid() == 0: tst_chown(mnt_dir) tst_chmod(mnt_dir) # Underlying fs may not have full nanosecond resolution tst_utimens(mnt_dir, ns_tol=1000) tst_rounding(mnt_dir) tst_link(mnt_dir) tst_rename(mnt_dir) tst_readdir(mnt_dir) tst_statvfs(mnt_dir) tst_truncate_path(mnt_dir) tst_truncate_fd(mnt_dir) tst_unlink(mnt_dir) tst_passthrough(src_dir, mnt_dir) except: cleanup(mount_process, mnt_dir) raise else: umount(mount_process, mnt_dir) def checked_unlink(filename, path, isdir=False): fullname = os.path.join(path, filename) if isdir: os.rmdir(fullname) else: os.unlink(fullname) with pytest.raises(OSError) as exc_info: os.stat(fullname) assert exc_info.value.errno == errno.ENOENT assert filename not in os.listdir(path) def tst_mkdir(mnt_dir): dirname = name_generator() fullname = mnt_dir + "/" + dirname os.mkdir(fullname) fstat = os.stat(fullname) assert stat.S_ISDIR(fstat.st_mode) assert os.listdir(fullname) == [] assert fstat.st_nlink in (1,2) assert dirname in os.listdir(mnt_dir) checked_unlink(dirname, mnt_dir, isdir=True) def tst_symlink(mnt_dir): linkname = name_generator() fullname = mnt_dir + "/" + linkname os.symlink("/imaginary/dest", fullname) fstat = os.lstat(fullname) assert stat.S_ISLNK(fstat.st_mode) assert os.readlink(fullname) == "/imaginary/dest" assert fstat.st_nlink == 1 assert linkname in os.listdir(mnt_dir) checked_unlink(linkname, mnt_dir) def tst_mknod(mnt_dir): filename = os.path.join(mnt_dir, name_generator()) shutil.copyfile(TEST_FILE, filename) fstat = os.lstat(filename) assert stat.S_ISREG(fstat.st_mode) assert fstat.st_nlink == 1 assert os.path.basename(filename) in os.listdir(mnt_dir) assert filecmp.cmp(TEST_FILE, filename, False) checked_unlink(filename, mnt_dir) def tst_chown(mnt_dir): filename = os.path.join(mnt_dir, name_generator()) os.mkdir(filename) fstat = os.lstat(filename) uid = fstat.st_uid gid = fstat.st_gid uid_new = uid + 1 os.chown(filename, uid_new, -1) fstat = os.lstat(filename) assert fstat.st_uid == uid_new assert fstat.st_gid == gid gid_new = gid + 1 os.chown(filename, -1, gid_new) fstat = os.lstat(filename) assert fstat.st_uid == uid_new assert fstat.st_gid == gid_new checked_unlink(filename, mnt_dir, isdir=True) def tst_chmod(mnt_dir): filename = os.path.join(mnt_dir, name_generator()) os.mkdir(filename) fstat = os.lstat(filename) mode = stat.S_IMODE(fstat.st_mode) mode_new = 0o640 assert mode != mode_new os.chmod(filename, mode_new) fstat = os.lstat(filename) assert stat.S_IMODE(fstat.st_mode) == mode_new checked_unlink(filename, mnt_dir, isdir=True) def tst_write(mnt_dir): name = os.path.join(mnt_dir, name_generator()) shutil.copyfile(TEST_FILE, name) assert filecmp.cmp(name, TEST_FILE, False) checked_unlink(name, mnt_dir) def tst_unlink(mnt_dir): name = os.path.join(mnt_dir, name_generator()) data1 = b'foo' data2 = b'bar' with open(os.path.join(mnt_dir, name), 'wb+', buffering=0) as fh: fh.write(data1) checked_unlink(name, mnt_dir) fh.write(data2) fh.seek(0) assert fh.read() == data1+data2 def tst_statvfs(mnt_dir): os.statvfs(mnt_dir) def tst_link(mnt_dir): name1 = os.path.join(mnt_dir, name_generator()) name2 = os.path.join(mnt_dir, name_generator()) shutil.copyfile(TEST_FILE, name1) assert filecmp.cmp(name1, TEST_FILE, False) os.link(name1, name2) fstat1 = os.lstat(name1) fstat2 = os.lstat(name2) assert fstat1 == fstat2 assert fstat1.st_nlink == 2 assert os.path.basename(name2) in os.listdir(mnt_dir) assert filecmp.cmp(name1, name2, False) os.unlink(name2) fstat1 = os.lstat(name1) assert fstat1.st_nlink == 1 os.unlink(name1) def tst_rename(mnt_dir): name1 = os.path.join(mnt_dir, name_generator()) name2 = os.path.join(mnt_dir, name_generator()) shutil.copyfile(TEST_FILE, name1) assert os.path.basename(name1) in os.listdir(mnt_dir) assert os.path.basename(name2) not in os.listdir(mnt_dir) assert filecmp.cmp(name1, TEST_FILE, False) fstat1 = os.lstat(name1) os.rename(name1, name2) fstat2 = os.lstat(name2) assert fstat1 == fstat2 assert filecmp.cmp(name2, TEST_FILE, False) assert os.path.basename(name1) not in os.listdir(mnt_dir) assert os.path.basename(name2) in os.listdir(mnt_dir) os.unlink(name2) def tst_readdir(mnt_dir): dir_ = os.path.join(mnt_dir, name_generator()) file_ = dir_ + "/" + name_generator() subdir = dir_ + "/" + name_generator() subfile = subdir + "/" + name_generator() os.mkdir(dir_) shutil.copyfile(TEST_FILE, file_) os.mkdir(subdir) shutil.copyfile(TEST_FILE, subfile) listdir_is = os.listdir(dir_) listdir_is.sort() listdir_should = [ os.path.basename(file_), os.path.basename(subdir) ] listdir_should.sort() assert listdir_is == listdir_should os.unlink(file_) os.unlink(subfile) os.rmdir(subdir) os.rmdir(dir_) def tst_truncate_path(mnt_dir): assert len(TEST_DATA) > 1024 filename = os.path.join(mnt_dir, name_generator()) with open(filename, 'wb') as fh: fh.write(TEST_DATA) fstat = os.stat(filename) size = fstat.st_size assert size == len(TEST_DATA) # Add zeros at the end os.truncate(filename, size + 1024) assert os.stat(filename).st_size == size + 1024 with open(filename, 'rb') as fh: assert fh.read(size) == TEST_DATA assert fh.read(1025) == b'\0' * 1024 # Truncate data os.truncate(filename, size - 1024) assert os.stat(filename).st_size == size - 1024 with open(filename, 'rb') as fh: assert fh.read(size) == TEST_DATA[:size-1024] os.unlink(filename) def tst_truncate_fd(mnt_dir): assert len(TEST_DATA) > 1024 with NamedTemporaryFile('w+b', 0, dir=mnt_dir) as fh: fd = fh.fileno() fh.write(TEST_DATA) fstat = os.fstat(fd) size = fstat.st_size assert size == len(TEST_DATA) # Add zeros at the end os.ftruncate(fd, size + 1024) assert os.fstat(fd).st_size == size + 1024 fh.seek(0) assert fh.read(size) == TEST_DATA assert fh.read(1025) == b'\0' * 1024 # Truncate data os.ftruncate(fd, size - 1024) assert os.fstat(fd).st_size == size - 1024 fh.seek(0) assert fh.read(size) == TEST_DATA[:size-1024] def tst_utimens(mnt_dir, ns_tol=0): filename = os.path.join(mnt_dir, name_generator()) os.mkdir(filename) fstat = os.lstat(filename) atime = fstat.st_atime + 42.28 mtime = fstat.st_mtime - 42.23 atime_ns = fstat.st_atime_ns + int(42.28*1e9) mtime_ns = fstat.st_mtime_ns - int(42.23*1e9) os.utime(filename, None, ns=(atime_ns, mtime_ns)) fstat = os.lstat(filename) assert abs(fstat.st_atime - atime) < 1e-3 assert abs(fstat.st_mtime - mtime) < 1e-3 assert abs(fstat.st_atime_ns - atime_ns) <= ns_tol assert abs(fstat.st_mtime_ns - mtime_ns) <= ns_tol checked_unlink(filename, mnt_dir, isdir=True) def tst_rounding(mnt_dir, ns_tol=0): filename = os.path.join(mnt_dir, name_generator()) os.mkdir(filename) fstat = os.lstat(filename) # Approximately 100 years secs = 100 * 365 * 24 * 3600 + 999 # Max nanos nanos = _NANOS_PER_SEC - 1 # seconds+ns and ns_tol as a float in seconds secs_f = secs + nanos / _NANOS_PER_SEC secs_tol = ns_tol / _NANOS_PER_SEC atime_ns = secs * _NANOS_PER_SEC + nanos mtime_ns = atime_ns os.utime(filename, None, ns=(atime_ns, mtime_ns)) fstat = os.lstat(filename) assert abs(fstat.st_atime - secs_f) <= secs_tol assert abs(fstat.st_mtime - secs_f) <= secs_tol assert abs(fstat.st_atime_ns - atime_ns) <= ns_tol assert abs(fstat.st_mtime_ns - mtime_ns) <= ns_tol checked_unlink(filename, mnt_dir, isdir=True) def tst_passthrough(src_dir, mnt_dir): # Test propagation from source to mirror name = name_generator() src_name = os.path.join(src_dir, name) mnt_name = os.path.join(mnt_dir, name) assert name not in os.listdir(src_dir) assert name not in os.listdir(mnt_dir) with open(src_name, 'w') as fh: fh.write('Hello, world') assert name in os.listdir(src_dir) assert name in os.listdir(mnt_dir) assert_same_stats(src_name, mnt_name) # Test propagation from mirror to source name = name_generator() src_name = os.path.join(src_dir, name) mnt_name = os.path.join(mnt_dir, name) assert name not in os.listdir(src_dir) assert name not in os.listdir(mnt_dir) with open(mnt_name, 'w') as fh: fh.write('Hello, world') assert name in os.listdir(src_dir) assert name in os.listdir(mnt_dir) assert_same_stats(src_name, mnt_name) # Test propagation inside subdirectory name = name_generator() src_dir = os.path.join(src_dir, 'subdir') mnt_dir = os.path.join(mnt_dir, 'subdir') os.mkdir(src_dir) src_name = os.path.join(src_dir, name) mnt_name = os.path.join(mnt_dir, name) assert name not in os.listdir(src_dir) assert name not in os.listdir(mnt_dir) with open(mnt_name, 'w') as fh: fh.write('Hello, world') assert name in os.listdir(src_dir) assert name in os.listdir(mnt_dir) assert_same_stats(src_name, mnt_name) def assert_same_stats(name1, name2): stat1 = os.stat(name1) stat2 = os.stat(name2) for name in ('st_atime_ns', 'st_mtime_ns', 'st_ctime_ns', 'st_mode', 'st_ino', 'st_nlink', 'st_uid', 'st_gid', 'st_size'): assert getattr(stat1, name) == getattr(stat2, name) pyfuse3-3.2.0/test/test_fs.py0000775000175000017500000002107613772374532017624 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' test_fs.py - Unit tests for pyfuse3. Copyright © 2015 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' import pytest import sys if __name__ == '__main__': sys.exit(pytest.main([__file__] + sys.argv[1:])) import pyfuse3 from pyfuse3 import FUSEError import multiprocessing import os import errno import stat import time import logging import trio import threading from util import fuse_test_marker, wait_for_mount, umount, cleanup pytestmark = fuse_test_marker() def get_mp(): # We can't use forkserver because we have to make sure # that the server inherits the per-test stdout/stderr file # descriptors. if hasattr(multiprocessing, 'get_context'): mp = multiprocessing.get_context('fork') else: # Older versions only support *fork* anyway mp = multiprocessing if threading.active_count() != 1: raise RuntimeError("Multi-threaded test running is not supported") return mp @pytest.yield_fixture() def testfs(tmpdir): mnt_dir = str(tmpdir) mp = get_mp() with mp.Manager() as mgr: cross_process = mgr.Namespace() mount_process = mp.Process(target=run_fs, args=(mnt_dir, cross_process)) mount_process.start() try: wait_for_mount(mount_process, mnt_dir) yield (mnt_dir, cross_process) except: cleanup(mnt_process, mnt_dir) raise else: umount(mount_process, mnt_dir) def test_invalidate_entry(testfs): (mnt_dir, fs_state) = testfs path = os.path.join(mnt_dir, 'message') os.stat(path) assert fs_state.lookup_called fs_state.lookup_called = False os.stat(path) assert not fs_state.lookup_called # Hardcoded sleeptimes - sorry! Needed because of the special semantics of # invalidate_entry() pyfuse3.setxattr(mnt_dir, 'command', b'forget_entry') time.sleep(1.1) os.stat(path) assert fs_state.lookup_called def test_invalidate_inode(testfs): (mnt_dir, fs_state) = testfs with open(os.path.join(mnt_dir, 'message'), 'r') as fh: assert fh.read() == 'hello world\n' assert fs_state.read_called fs_state.read_called = False fh.seek(0) assert fh.read() == 'hello world\n' assert not fs_state.read_called pyfuse3.setxattr(mnt_dir, 'command', b'forget_inode') fh.seek(0) assert fh.read() == 'hello world\n' assert fs_state.read_called def test_notify_store(testfs): (mnt_dir, fs_state) = testfs with open(os.path.join(mnt_dir, 'message'), 'r') as fh: pyfuse3.setxattr(mnt_dir, 'command', b'store') fs_state.read_called = False assert fh.read() == 'hello world\n' assert not fs_state.read_called def test_entry_timeout(testfs): (mnt_dir, fs_state) = testfs fs_state.entry_timeout = 1 path = os.path.join(mnt_dir, 'message') os.stat(path) assert fs_state.lookup_called fs_state.lookup_called = False os.stat(path) assert not fs_state.lookup_called time.sleep(fs_state.entry_timeout*1.1) fs_state.lookup_called = False os.stat(path) assert fs_state.lookup_called def test_attr_timeout(testfs): (mnt_dir, fs_state) = testfs fs_state.attr_timeout = 1 with open(os.path.join(mnt_dir, 'message'), 'r') as fh: os.fstat(fh.fileno()) assert fs_state.getattr_called fs_state.getattr_called = False os.fstat(fh.fileno()) assert not fs_state.getattr_called time.sleep(fs_state.attr_timeout*1.1) fs_state.getattr_called = False os.fstat(fh.fileno()) assert fs_state.getattr_called def test_terminate(tmpdir): mnt_dir = str(tmpdir) mp = get_mp() with mp.Manager() as mgr: fs_state = mgr.Namespace() mount_process = mp.Process(target=run_fs, args=(mnt_dir, fs_state)) mount_process.start() try: wait_for_mount(mount_process, mnt_dir) pyfuse3.setxattr(mnt_dir, 'command', b'terminate') mount_process.join(5) assert mount_process.exitcode is not None except: cleanup(mount_process, mnt_dir) raise class Fs(pyfuse3.Operations): def __init__(self, cross_process): super(Fs, self).__init__() self.hello_name = b"message" self.hello_inode = pyfuse3.ROOT_INODE+1 self.hello_data = b"hello world\n" self.status = cross_process self.lookup_cnt = 0 self.status.getattr_called = False self.status.lookup_called = False self.status.read_called = False self.status.entry_timeout = 99999 self.status.attr_timeout = 99999 async def getattr(self, inode, ctx=None): entry = pyfuse3.EntryAttributes() if inode == pyfuse3.ROOT_INODE: entry.st_mode = (stat.S_IFDIR | 0o755) entry.st_size = 0 elif inode == self.hello_inode: entry.st_mode = (stat.S_IFREG | 0o644) entry.st_size = len(self.hello_data) else: raise pyfuse3.FUSEError(errno.ENOENT) stamp = int(1438467123.985654*1e9) entry.st_atime_ns = stamp entry.st_ctime_ns = stamp entry.st_mtime_ns = stamp entry.st_gid = os.getgid() entry.st_uid = os.getuid() entry.st_ino = inode entry.entry_timeout = self.status.entry_timeout entry.attr_timeout = self.status.attr_timeout self.status.getattr_called = True return entry async def forget(self, inode_list): for (inode, cnt) in inode_list: if inode == self.hello_inode: self.lookup_cnt -= 1 assert self.lookup_cnt >= 0 else: assert inode == pyfuse3.ROOT_INODE async def lookup(self, parent_inode, name, ctx=None): if parent_inode != pyfuse3.ROOT_INODE or name != self.hello_name: raise pyfuse3.FUSEError(errno.ENOENT) self.lookup_cnt += 1 self.status.lookup_called = True return await self.getattr(self.hello_inode) async def opendir(self, inode, ctx): if inode != pyfuse3.ROOT_INODE: raise pyfuse3.FUSEError(errno.ENOENT) return inode async def readdir(self, fh, off, token): assert fh == pyfuse3.ROOT_INODE if off == 0: pyfuse3.readdir_reply( token, self.hello_name, await self.getattr(self.hello_inode), 1) return async def open(self, inode, flags, ctx): if inode != self.hello_inode: raise pyfuse3.FUSEError(errno.ENOENT) if flags & os.O_RDWR or flags & os.O_WRONLY: raise pyfuse3.FUSEError(errno.EACCES) return pyfuse3.FileInfo(fh=inode) async def read(self, fh, off, size): assert fh == self.hello_inode self.status.read_called = True return self.hello_data[off:off+size] async def setxattr(self, inode, name, value, ctx): if inode != pyfuse3.ROOT_INODE or name != b'command': raise FUSEError(errno.ENOTSUP) if value == b'forget_entry': pyfuse3.invalidate_entry_async(pyfuse3.ROOT_INODE, self.hello_name) # Make sure that the request is pending before we return await trio.sleep(0.1) elif value == b'forget_inode': pyfuse3.invalidate_inode(self.hello_inode) elif value == b'store': pyfuse3.notify_store(self.hello_inode, offset=0, data=self.hello_data) elif value == b'terminate': pyfuse3.terminate() else: raise FUSEError(errno.EINVAL) def run_fs(mountpoint, cross_process): # Logging (note that we run in a new process, so we can't # rely on direct log capture and instead print to stdout) root_logger = logging.getLogger() formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(levelname)s ' '%(funcName)s(%(threadName)s): %(message)s', datefmt="%M:%S") handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.DEBUG) handler.setFormatter(formatter) root_logger.addHandler(handler) root_logger.setLevel(logging.DEBUG) testfs = Fs(cross_process) fuse_options = set(pyfuse3.default_options) fuse_options.add('fsname=pyfuse3_testfs') pyfuse3.init(testfs, mountpoint, fuse_options) try: trio.run(pyfuse3.main) finally: pyfuse3.close() pyfuse3-3.2.0/test/test_rounding.py0000775000175000017500000000213113772360360021022 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' test_rounding.py - Unit tests for pyfuse3. Copyright © 2020 Philip Warner This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' if __name__ == '__main__': import pytest import sys sys.exit(pytest.main([__file__] + sys.argv[1:])) import pyfuse3 from pyfuse3 import _NANOS_PER_SEC def test_rounding(): # Incorrect division previously resulted in rounding errors for # all dates. entry = pyfuse3.EntryAttributes() # Approximately 100 years, ending in 999 secs = 100 * 365 * 24 * 3600 + 999 nanos = _NANOS_PER_SEC - 1 total = secs * _NANOS_PER_SEC + nanos entry.st_atime_ns = total entry.st_ctime_ns = total entry.st_mtime_ns = total # Birthtime skipped -- only valid under BSD and OSX #entry.st_birthtime_ns = total assert entry.st_atime_ns == total assert entry.st_ctime_ns == total assert entry.st_mtime_ns == total # Birthtime skipped -- only valid under BSD and OSX #assert entry.st_birthtime_ns == total pyfuse3-3.2.0/test/travis-install.sh0000775000175000017500000000056613740136074021104 0ustar nikrationikratio00000000000000#!/bin/sh set -e # We're pinning most packages to specific versions to prevent the CI from failing when # testing eg merge requests because some of those packages have started emitting # depreciation warnings or made backwards incompatible changes. pip install \ "trio == 0.15" \ "pytest >= 4.6.5, < 5.0.0" \ "pytest_trio == 0.6.0" \ sphinxcontrib-asyncio pyfuse3-3.2.0/test/travis-test.sh0000775000175000017500000000043713740137122020405 0ustar nikrationikratio00000000000000#!/bin/bash set -e # Disable developer mode, so that build does not suddenly break if # e.g. a newer compiler version results in new warning messages. rm MANIFEST.in python setup.py build_cython python setup.py build_ext --inplace python -m pytest test/ python setup.py build_sphinx pyfuse3-3.2.0/test/util.py0000664000175000017500000001031613403546411017106 0ustar nikrationikratio00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- ''' util.py - Utility functions for pyfuse3 unit tests. Copyright © 2015 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' import os import platform import pytest import stat import subprocess import time def fuse_test_marker(): '''Return a pytest.marker that indicates FUSE availability If system/user/environment does not support FUSE, return a `pytest.mark.skip` object with more details. If FUSE is supported, return `pytest.mark.uses_fuse()`. ''' if platform.system() == 'Darwin': # No working autodetection, just assume it will work. return skip = lambda x: pytest.mark.skip(reason=x) with subprocess.Popen(['which', 'fusermount'], stdout=subprocess.PIPE, universal_newlines=True) as which: fusermount_path = which.communicate()[0].strip() if not fusermount_path or which.returncode != 0: return skip("Can't find fusermount executable") if not os.path.exists('/dev/fuse'): return skip("FUSE kernel module does not seem to be loaded") if os.getuid() == 0: return pytest.mark.uses_fuse() mode = os.stat(fusermount_path).st_mode if mode & stat.S_ISUID == 0: return skip('fusermount executable not setuid, and we are not root.') try: fd = os.open('/dev/fuse', os.O_RDWR) except OSError as exc: return skip('Unable to open /dev/fuse: %s' % exc.strerror) else: os.close(fd) return pytest.mark.uses_fuse() def exitcode(process): if isinstance(process, subprocess.Popen): return process.poll() else: if process.is_alive(): return None else: return process.exitcode def wait_for(callable, timeout=10, interval=0.1): '''Wait until *callable* returns something True and return it If *timeout* expires, return None ''' waited = 0 while True: ret = callable() if ret: return ret if waited > timeout: return None waited += interval time.sleep(interval) def wait_for_mount(mount_process, mnt_dir): elapsed = 0 while elapsed < 30: if os.path.ismount(mnt_dir): return True if exitcode(mount_process) is not None: pytest.fail('file system process terminated prematurely') time.sleep(0.1) elapsed += 0.1 pytest.fail("mountpoint failed to come up") def cleanup(mount_process, mnt_dir): if platform.system() == 'Darwin': subprocess.call(['umount', '-l', mnt_dir], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) else: subprocess.call(['fusermount', '-z', '-u', mnt_dir], stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT) mount_process.terminate() if isinstance(mount_process, subprocess.Popen): try: mount_process.wait(1) except subprocess.TimeoutExpired: mount_process.kill() else: mount_process.join(5) if mount_process.exitcode is None: mount_process.kill() def umount(mount_process, mnt_dir): if platform.system() == 'Darwin': subprocess.check_call(['umount', '-l', mnt_dir]) else: subprocess.check_call(['fusermount', '-z', '-u', mnt_dir]) assert not os.path.ismount(mnt_dir) if isinstance(mount_process, subprocess.Popen): try: code = mount_process.wait(5) if code == 0: return pytest.fail('file system process terminated with code %s' % (code,)) except subprocess.TimeoutExpired: mount_process.terminate() try: mount_process.wait(1) except subprocess.TimeoutExpired: mount_process.kill() else: mount_process.join(5) code = mount_process.exitcode if code == 0: return elif code is None: mount_process.terminate() mount_process.join(1) else: pytest.fail('file system process terminated with code %s' % (code,)) pytest.fail('mount process did not terminate') pyfuse3-3.2.0/util/0000775000175000017500000000000013773156367015575 5ustar nikrationikratio00000000000000pyfuse3-3.2.0/util/sphinx_cython.py0000664000175000017500000000201613350426564021031 0ustar nikrationikratio00000000000000# -*- coding: utf-8 -*- ''' sphinx_cython.py This module removes C style type declarations from function and method docstrings. It also works around http://trac.cython.org/cython_trac/ticket/812 Copyright © 2010 Nikolaus Rath This file is part of pyfuse3. This work may be distributed under the terms of the GNU LGPL. ''' import re TYPE_RE = re.compile(r'(int|char|unicode|str|bytes)(?:\s+\*?\s*|\s*\*?\s+)([a-zA-Z_].*)') def setup(app): app.connect('autodoc-process-signature', process_signature) def process_signature(app, what, name, obj, options, signature, return_annotation): # Some unused arguments #pylint: disable=W0613 if signature is None: return (signature, return_annotation) new_params = list() for param in (x.strip() for x in signature[1:-1].split(',')): hit = TYPE_RE.match(param) if hit: new_params.append(hit.group(2)) else: new_params.append(param) return ('(%s)' % ', '.join(new_params), return_annotation)