diff --git a/CMakeLists.txt b/CMakeLists.txt index 2822f33..c20bcde 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,6 +1,6 @@ cmake_minimum_required(VERSION 3.14) -project(dnet VERSION 1.17.0 LANGUAGES C) +project(dnet VERSION 1.18.0 LANGUAGES C) find_package(TCL) diff --git a/Makefile.in b/Makefile.in index b97f0cf..c3021fc 100644 --- a/Makefile.in +++ b/Makefile.in @@ -257,7 +257,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ diff --git a/aclocal.m4 b/aclocal.m4 index 94039e8..0a3ef06 100644 --- a/aclocal.m4 +++ b/aclocal.m4 @@ -14,8 +14,8 @@ m4_ifndef([AC_CONFIG_MACRO_DIRS], [m4_defun([_AM_CONFIG_MACRO_DIRS], [])m4_defun([AC_CONFIG_MACRO_DIRS], [_AM_CONFIG_MACRO_DIRS($@)])]) m4_ifndef([AC_AUTOCONF_VERSION], [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl -m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.71],, -[m4_warning([this file was generated for autoconf 2.71. +m4_if(m4_defn([AC_AUTOCONF_VERSION]), [2.72],, +[m4_warning([this file was generated for autoconf 2.72. You have another version of autoconf. It may work, but is not guaranteed to. If you have problems, you may need to regenerate the build system entirely. To do so, use the procedure documented by the package, typically 'autoreconf'.])]) diff --git a/config/config.guess b/config/config.guess index b33c9e8..e81d3ae 100755 --- a/config/config.guess +++ b/config/config.guess @@ -1,8 +1,10 @@ #! /bin/sh # Attempt to guess a canonical system name. -# Copyright 1992-2018 Free Software Foundation, Inc. +# Copyright 1992-2021 Free Software Foundation, Inc. -timestamp='2018-08-29' +# shellcheck disable=SC2006,SC2268 # see below for rationale + +timestamp='2021-06-03' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by @@ -27,11 +29,19 @@ timestamp='2018-08-29' # Originally written by Per Bothner; maintained since 2000 by Ben Elliston. # # You can get the latest version of this script from: -# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess +# https://git.savannah.gnu.org/cgit/config.git/plain/config.guess # # Please send patches to . +# The "shellcheck disable" line above the timestamp inhibits complaints +# about features and limitations of the classic Bourne shell that were +# superseded or lifted in POSIX. However, this script identifies a wide +# variety of pre-POSIX systems that do not have POSIX shells at all, and +# even some reasonably current systems (Solaris 10 as case-in-point) still +# have a pre-POSIX /bin/sh. + + me=`echo "$0" | sed -e 's,.*/,,'` usage="\ @@ -50,7 +60,7 @@ version="\ GNU config.guess ($timestamp) Originally written by Per Bothner. -Copyright 1992-2018 Free Software Foundation, Inc. +Copyright 1992-2021 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." @@ -84,6 +94,9 @@ if test $# != 0; then exit 1 fi +# Just in case it came from the environment. +GUESS= + # CC_FOR_BUILD -- compiler used by this script. Note that the use of a # compiler to aid in system detection is discouraged as it requires # temporary files to be created and, as you can see below, it is a @@ -96,12 +109,13 @@ fi tmp= # shellcheck disable=SC2172 -trap 'test -z "$tmp" || rm -fr "$tmp"' 1 2 13 15 -trap 'exitcode=$?; test -z "$tmp" || rm -fr "$tmp"; exit $exitcode' 0 +trap 'test -z "$tmp" || rm -fr "$tmp"' 0 1 2 13 15 set_cc_for_build() { + # prevent multiple calls if $tmp is already set + test "$tmp" && return 0 : "${TMPDIR=/tmp}" - # shellcheck disable=SC2039 + # shellcheck disable=SC2039,SC3028 { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir "$tmp" 2>/dev/null) ; } || { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir "$tmp" 2>/dev/null) && echo "Warning: creating insecure temp directory" >&2 ; } || @@ -111,7 +125,7 @@ set_cc_for_build() { ,,) echo "int x;" > "$dummy.c" for driver in cc gcc c89 c99 ; do if ($driver -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then - CC_FOR_BUILD="$driver" + CC_FOR_BUILD=$driver break fi done @@ -132,14 +146,12 @@ fi UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown -UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown +UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown -case "$UNAME_SYSTEM" in +case $UNAME_SYSTEM in Linux|GNU|GNU/*) - # If the system lacks a compiler, then just pick glibc. - # We could probably try harder. - LIBC=gnu + LIBC=unknown set_cc_for_build cat <<-EOF > "$dummy.c" @@ -148,24 +160,37 @@ Linux|GNU|GNU/*) LIBC=uclibc #elif defined(__dietlibc__) LIBC=dietlibc - #else + #elif defined(__GLIBC__) LIBC=gnu + #else + #include + /* First heuristic to detect musl libc. */ + #ifdef __DEFINED_va_list + LIBC=musl + #endif #endif EOF - eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`" + cc_set_libc=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'` + eval "$cc_set_libc" - # If ldd exists, use it to detect musl libc. - if command -v ldd >/dev/null && \ - ldd --version 2>&1 | grep -q ^musl - then - LIBC=musl + # Second heuristic to detect musl libc. + if [ "$LIBC" = unknown ] && + command -v ldd >/dev/null && + ldd --version 2>&1 | grep -q ^musl; then + LIBC=musl + fi + + # If the system lacks a compiler, then just pick glibc. + # We could probably try harder. + if [ "$LIBC" = unknown ]; then + LIBC=gnu fi ;; esac # Note: order is significant - the case branches are not exclusive. -case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in +case $UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION in *:NetBSD:*:*) # NetBSD (nbsd) targets should (where applicable) match one or # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, @@ -177,12 +202,12 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in # # Note: NetBSD doesn't particularly care about the vendor # portion of the name. We always set it to "unknown". - sysctl="sysctl -n hw.machine_arch" UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \ - "/sbin/$sysctl" 2>/dev/null || \ - "/usr/sbin/$sysctl" 2>/dev/null || \ + /sbin/sysctl -n hw.machine_arch 2>/dev/null || \ + /usr/sbin/sysctl -n hw.machine_arch 2>/dev/null || \ echo unknown)` - case "$UNAME_MACHINE_ARCH" in + case $UNAME_MACHINE_ARCH in + aarch64eb) machine=aarch64_be-unknown ;; armeb) machine=armeb-unknown ;; arm*) machine=arm-unknown ;; sh3el) machine=shl-unknown ;; @@ -191,13 +216,13 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in earmv*) arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` - machine="${arch}${endian}"-unknown + machine=${arch}${endian}-unknown ;; - *) machine="$UNAME_MACHINE_ARCH"-unknown ;; + *) machine=$UNAME_MACHINE_ARCH-unknown ;; esac # The Operating System including object format, if it has switched # to ELF recently (or will in the future) and ABI. - case "$UNAME_MACHINE_ARCH" in + case $UNAME_MACHINE_ARCH in earm*) os=netbsdelf ;; @@ -218,7 +243,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in ;; esac # Determine ABI tags. - case "$UNAME_MACHINE_ARCH" in + case $UNAME_MACHINE_ARCH in earm*) expr='s/^earmv[0-9]/-eabi/;s/eb$//' abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` @@ -229,7 +254,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in # thus, need a distinct triplet. However, they do not need # kernel version information, so it can be replaced with a # suitable tag, in the style of linux-gnu. - case "$UNAME_VERSION" in + case $UNAME_VERSION in Debian*) release='-gnu' ;; @@ -240,45 +265,57 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: # contains redundant information, the shorter form: # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. - echo "$machine-${os}${release}${abi-}" - exit ;; + GUESS=$machine-${os}${release}${abi-} + ;; *:Bitrig:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` - echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE_ARCH-unknown-bitrig$UNAME_RELEASE + ;; *:OpenBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` - echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE_ARCH-unknown-openbsd$UNAME_RELEASE + ;; + *:SecBSD:*:*) + UNAME_MACHINE_ARCH=`arch | sed 's/SecBSD.//'` + GUESS=$UNAME_MACHINE_ARCH-unknown-secbsd$UNAME_RELEASE + ;; *:LibertyBSD:*:*) UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'` - echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE_ARCH-unknown-libertybsd$UNAME_RELEASE + ;; *:MidnightBSD:*:*) - echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE-unknown-midnightbsd$UNAME_RELEASE + ;; *:ekkoBSD:*:*) - echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE-unknown-ekkobsd$UNAME_RELEASE + ;; *:SolidBSD:*:*) - echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE-unknown-solidbsd$UNAME_RELEASE + ;; + *:OS108:*:*) + GUESS=$UNAME_MACHINE-unknown-os108_$UNAME_RELEASE + ;; macppc:MirBSD:*:*) - echo powerpc-unknown-mirbsd"$UNAME_RELEASE" - exit ;; + GUESS=powerpc-unknown-mirbsd$UNAME_RELEASE + ;; *:MirBSD:*:*) - echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE-unknown-mirbsd$UNAME_RELEASE + ;; *:Sortix:*:*) - echo "$UNAME_MACHINE"-unknown-sortix - exit ;; + GUESS=$UNAME_MACHINE-unknown-sortix + ;; + *:Twizzler:*:*) + GUESS=$UNAME_MACHINE-unknown-twizzler + ;; *:Redox:*:*) - echo "$UNAME_MACHINE"-unknown-redox - exit ;; + GUESS=$UNAME_MACHINE-unknown-redox + ;; mips:OSF1:*.*) - echo mips-dec-osf1 - exit ;; + GUESS=mips-dec-osf1 + ;; alpha:OSF1:*:*) + # Reset EXIT trap before exiting to avoid spurious non-zero exit code. + trap '' 0 case $UNAME_RELEASE in *4.0) UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` @@ -292,7 +329,7 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in # covers most systems running today. This code pipes the CPU # types through head -n 1, so we only detect the type of CPU 0. ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` - case "$ALPHA_CPU_TYPE" in + case $ALPHA_CPU_TYPE in "EV4 (21064)") UNAME_MACHINE=alpha ;; "EV4.5 (21064)") @@ -329,112 +366,121 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in # A Tn.n version is a released field test version. # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. - echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`" - # Reset EXIT trap before exiting to avoid spurious non-zero exit code. - exitcode=$? - trap '' 0 - exit $exitcode ;; + OSF_REL=`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` + GUESS=$UNAME_MACHINE-dec-osf$OSF_REL + ;; Amiga*:UNIX_System_V:4.0:*) - echo m68k-unknown-sysv4 - exit ;; + GUESS=m68k-unknown-sysv4 + ;; *:[Aa]miga[Oo][Ss]:*:*) - echo "$UNAME_MACHINE"-unknown-amigaos - exit ;; + GUESS=$UNAME_MACHINE-unknown-amigaos + ;; *:[Mm]orph[Oo][Ss]:*:*) - echo "$UNAME_MACHINE"-unknown-morphos - exit ;; + GUESS=$UNAME_MACHINE-unknown-morphos + ;; *:OS/390:*:*) - echo i370-ibm-openedition - exit ;; + GUESS=i370-ibm-openedition + ;; *:z/VM:*:*) - echo s390-ibm-zvmoe - exit ;; + GUESS=s390-ibm-zvmoe + ;; *:OS400:*:*) - echo powerpc-ibm-os400 - exit ;; + GUESS=powerpc-ibm-os400 + ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) - echo arm-acorn-riscix"$UNAME_RELEASE" - exit ;; + GUESS=arm-acorn-riscix$UNAME_RELEASE + ;; arm*:riscos:*:*|arm*:RISCOS:*:*) - echo arm-unknown-riscos - exit ;; + GUESS=arm-unknown-riscos + ;; SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) - echo hppa1.1-hitachi-hiuxmpp - exit ;; + GUESS=hppa1.1-hitachi-hiuxmpp + ;; Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. - if test "`(/bin/universe) 2>/dev/null`" = att ; then - echo pyramid-pyramid-sysv3 - else - echo pyramid-pyramid-bsd - fi - exit ;; + case `(/bin/universe) 2>/dev/null` in + att) GUESS=pyramid-pyramid-sysv3 ;; + *) GUESS=pyramid-pyramid-bsd ;; + esac + ;; NILE*:*:*:dcosx) - echo pyramid-pyramid-svr4 - exit ;; + GUESS=pyramid-pyramid-svr4 + ;; DRS?6000:unix:4.0:6*) - echo sparc-icl-nx6 - exit ;; + GUESS=sparc-icl-nx6 + ;; DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) case `/usr/bin/uname -p` in - sparc) echo sparc-icl-nx7; exit ;; - esac ;; + sparc) GUESS=sparc-icl-nx7 ;; + esac + ;; s390x:SunOS:*:*) - echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" - exit ;; + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` + GUESS=$UNAME_MACHINE-ibm-solaris2$SUN_REL + ;; sun4H:SunOS:5.*:*) - echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" - exit ;; + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` + GUESS=sparc-hal-solaris2$SUN_REL + ;; sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) - echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" - exit ;; + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` + GUESS=sparc-sun-solaris2$SUN_REL + ;; i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) - echo i386-pc-auroraux"$UNAME_RELEASE" - exit ;; + GUESS=i386-pc-auroraux$UNAME_RELEASE + ;; i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) - UNAME_REL="`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" - case `isainfo -b` in - 32) - echo i386-pc-solaris2"$UNAME_REL" - ;; - 64) - echo x86_64-pc-solaris2"$UNAME_REL" - ;; - esac - exit ;; + set_cc_for_build + SUN_ARCH=i386 + # If there is a compiler, see if it is configured for 64-bit objects. + # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. + # This test works for both compilers. + if test "$CC_FOR_BUILD" != no_compiler_found; then + if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + SUN_ARCH=x86_64 + fi + fi + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` + GUESS=$SUN_ARCH-pc-solaris2$SUN_REL + ;; sun4*:SunOS:6*:*) # According to config.sub, this is the proper way to canonicalize # SunOS6. Hard to guess exactly what SunOS6 will be like, but # it's likely to be more like Solaris than SunOS4. - echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" - exit ;; + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` + GUESS=sparc-sun-solaris3$SUN_REL + ;; sun4*:SunOS:*:*) - case "`/usr/bin/arch -k`" in + case `/usr/bin/arch -k` in Series*|S4*) UNAME_RELEASE=`uname -v` ;; esac # Japanese Language versions have a version number like `4.1.3-JL'. - echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`" - exit ;; + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/'` + GUESS=sparc-sun-sunos$SUN_REL + ;; sun3*:SunOS:*:*) - echo m68k-sun-sunos"$UNAME_RELEASE" - exit ;; + GUESS=m68k-sun-sunos$UNAME_RELEASE + ;; sun*:*:4.2BSD:*) UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3 - case "`/bin/arch`" in + case `/bin/arch` in sun3) - echo m68k-sun-sunos"$UNAME_RELEASE" + GUESS=m68k-sun-sunos$UNAME_RELEASE ;; sun4) - echo sparc-sun-sunos"$UNAME_RELEASE" + GUESS=sparc-sun-sunos$UNAME_RELEASE ;; esac - exit ;; + ;; aushp:SunOS:*:*) - echo sparc-auspex-sunos"$UNAME_RELEASE" - exit ;; + GUESS=sparc-auspex-sunos$UNAME_RELEASE + ;; # The situation for MiNT is a little confusing. The machine name # can be virtually everything (everything which is not # "atarist" or "atariste" at least should have a processor @@ -444,41 +490,41 @@ case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) - echo m68k-atari-mint"$UNAME_RELEASE" - exit ;; + GUESS=m68k-atari-mint$UNAME_RELEASE + ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) - echo m68k-atari-mint"$UNAME_RELEASE" - exit ;; + GUESS=m68k-atari-mint$UNAME_RELEASE + ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) - echo m68k-atari-mint"$UNAME_RELEASE" - exit ;; + GUESS=m68k-atari-mint$UNAME_RELEASE + ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) - echo m68k-milan-mint"$UNAME_RELEASE" - exit ;; + GUESS=m68k-milan-mint$UNAME_RELEASE + ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) - echo m68k-hades-mint"$UNAME_RELEASE" - exit ;; + GUESS=m68k-hades-mint$UNAME_RELEASE + ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) - echo m68k-unknown-mint"$UNAME_RELEASE" - exit ;; + GUESS=m68k-unknown-mint$UNAME_RELEASE + ;; m68k:machten:*:*) - echo m68k-apple-machten"$UNAME_RELEASE" - exit ;; + GUESS=m68k-apple-machten$UNAME_RELEASE + ;; powerpc:machten:*:*) - echo powerpc-apple-machten"$UNAME_RELEASE" - exit ;; + GUESS=powerpc-apple-machten$UNAME_RELEASE + ;; RISC*:Mach:*:*) - echo mips-dec-mach_bsd4.3 - exit ;; + GUESS=mips-dec-mach_bsd4.3 + ;; RISC*:ULTRIX:*:*) - echo mips-dec-ultrix"$UNAME_RELEASE" - exit ;; + GUESS=mips-dec-ultrix$UNAME_RELEASE + ;; VAX*:ULTRIX*:*:*) - echo vax-dec-ultrix"$UNAME_RELEASE" - exit ;; + GUESS=vax-dec-ultrix$UNAME_RELEASE + ;; 2020:CLIX:*:* | 2430:CLIX:*:*) - echo clipper-intergraph-clix"$UNAME_RELEASE" - exit ;; + GUESS=clipper-intergraph-clix$UNAME_RELEASE + ;; mips:*:*:UMIPS | mips:*:*:RISCos) set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" @@ -506,75 +552,76 @@ EOF dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` && SYSTEM_NAME=`"$dummy" "$dummyarg"` && { echo "$SYSTEM_NAME"; exit; } - echo mips-mips-riscos"$UNAME_RELEASE" - exit ;; + GUESS=mips-mips-riscos$UNAME_RELEASE + ;; Motorola:PowerMAX_OS:*:*) - echo powerpc-motorola-powermax - exit ;; + GUESS=powerpc-motorola-powermax + ;; Motorola:*:4.3:PL8-*) - echo powerpc-harris-powermax - exit ;; + GUESS=powerpc-harris-powermax + ;; Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) - echo powerpc-harris-powermax - exit ;; + GUESS=powerpc-harris-powermax + ;; Night_Hawk:Power_UNIX:*:*) - echo powerpc-harris-powerunix - exit ;; + GUESS=powerpc-harris-powerunix + ;; m88k:CX/UX:7*:*) - echo m88k-harris-cxux7 - exit ;; + GUESS=m88k-harris-cxux7 + ;; m88k:*:4*:R4*) - echo m88k-motorola-sysv4 - exit ;; + GUESS=m88k-motorola-sysv4 + ;; m88k:*:3*:R3*) - echo m88k-motorola-sysv3 - exit ;; + GUESS=m88k-motorola-sysv3 + ;; AViiON:dgux:*:*) # DG/UX returns AViiON for all architectures UNAME_PROCESSOR=`/usr/bin/uname -p` - if [ "$UNAME_PROCESSOR" = mc88100 ] || [ "$UNAME_PROCESSOR" = mc88110 ] + if test "$UNAME_PROCESSOR" = mc88100 || test "$UNAME_PROCESSOR" = mc88110 then - if [ "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx ] || \ - [ "$TARGET_BINARY_INTERFACE"x = x ] + if test "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx || \ + test "$TARGET_BINARY_INTERFACE"x = x then - echo m88k-dg-dgux"$UNAME_RELEASE" + GUESS=m88k-dg-dgux$UNAME_RELEASE else - echo m88k-dg-dguxbcs"$UNAME_RELEASE" + GUESS=m88k-dg-dguxbcs$UNAME_RELEASE fi else - echo i586-dg-dgux"$UNAME_RELEASE" + GUESS=i586-dg-dgux$UNAME_RELEASE fi - exit ;; + ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) - echo m88k-dolphin-sysv3 - exit ;; + GUESS=m88k-dolphin-sysv3 + ;; M88*:*:R3*:*) # Delta 88k system running SVR3 - echo m88k-motorola-sysv3 - exit ;; + GUESS=m88k-motorola-sysv3 + ;; XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) - echo m88k-tektronix-sysv3 - exit ;; + GUESS=m88k-tektronix-sysv3 + ;; Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) - echo m68k-tektronix-bsd - exit ;; + GUESS=m68k-tektronix-bsd + ;; *:IRIX*:*:*) - echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`" - exit ;; + IRIX_REL=`echo "$UNAME_RELEASE" | sed -e 's/-/_/g'` + GUESS=mips-sgi-irix$IRIX_REL + ;; ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. - echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id - exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' + GUESS=romp-ibm-aix # uname -m gives an 8 hex-code CPU id + ;; # Note that: echo "'`uname -s`'" gives 'AIX ' i*86:AIX:*:*) - echo i386-ibm-aix - exit ;; + GUESS=i386-ibm-aix + ;; ia64:AIX:*:*) - if [ -x /usr/bin/oslevel ] ; then + if test -x /usr/bin/oslevel ; then IBM_REV=`/usr/bin/oslevel` else - IBM_REV="$UNAME_VERSION.$UNAME_RELEASE" + IBM_REV=$UNAME_VERSION.$UNAME_RELEASE fi - echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV" - exit ;; + GUESS=$UNAME_MACHINE-ibm-aix$IBM_REV + ;; *:AIX:2:3) if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then set_cc_for_build @@ -591,16 +638,16 @@ EOF EOF if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` then - echo "$SYSTEM_NAME" + GUESS=$SYSTEM_NAME else - echo rs6000-ibm-aix3.2.5 + GUESS=rs6000-ibm-aix3.2.5 fi elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then - echo rs6000-ibm-aix3.2.4 + GUESS=rs6000-ibm-aix3.2.4 else - echo rs6000-ibm-aix3.2 + GUESS=rs6000-ibm-aix3.2 fi - exit ;; + ;; *:AIX:*:[4567]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then @@ -608,56 +655,56 @@ EOF else IBM_ARCH=powerpc fi - if [ -x /usr/bin/lslpp ] ; then - IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | + if test -x /usr/bin/lslpp ; then + IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | \ awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` else - IBM_REV="$UNAME_VERSION.$UNAME_RELEASE" + IBM_REV=$UNAME_VERSION.$UNAME_RELEASE fi - echo "$IBM_ARCH"-ibm-aix"$IBM_REV" - exit ;; + GUESS=$IBM_ARCH-ibm-aix$IBM_REV + ;; *:AIX:*:*) - echo rs6000-ibm-aix - exit ;; + GUESS=rs6000-ibm-aix + ;; ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*) - echo romp-ibm-bsd4.4 - exit ;; + GUESS=romp-ibm-bsd4.4 + ;; ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and - echo romp-ibm-bsd"$UNAME_RELEASE" # 4.3 with uname added to - exit ;; # report: romp-ibm BSD 4.3 + GUESS=romp-ibm-bsd$UNAME_RELEASE # 4.3 with uname added to + ;; # report: romp-ibm BSD 4.3 *:BOSX:*:*) - echo rs6000-bull-bosx - exit ;; + GUESS=rs6000-bull-bosx + ;; DPX/2?00:B.O.S.:*:*) - echo m68k-bull-sysv3 - exit ;; + GUESS=m68k-bull-sysv3 + ;; 9000/[34]??:4.3bsd:1.*:*) - echo m68k-hp-bsd - exit ;; + GUESS=m68k-hp-bsd + ;; hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) - echo m68k-hp-bsd4.4 - exit ;; + GUESS=m68k-hp-bsd4.4 + ;; 9000/[34678]??:HP-UX:*:*) - HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` - case "$UNAME_MACHINE" in + HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` + case $UNAME_MACHINE in 9000/31?) HP_ARCH=m68000 ;; 9000/[34]??) HP_ARCH=m68k ;; 9000/[678][0-9][0-9]) - if [ -x /usr/bin/getconf ]; then + if test -x /usr/bin/getconf; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` - case "$sc_cpu_version" in + case $sc_cpu_version in 523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0 528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1 532) # CPU_PA_RISC2_0 - case "$sc_kernel_bits" in + case $sc_kernel_bits in 32) HP_ARCH=hppa2.0n ;; 64) HP_ARCH=hppa2.0w ;; '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20 esac ;; esac fi - if [ "$HP_ARCH" = "" ]; then + if test "$HP_ARCH" = ""; then set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" @@ -696,7 +743,7 @@ EOF test -z "$HP_ARCH" && HP_ARCH=hppa fi ;; esac - if [ "$HP_ARCH" = hppa2.0w ] + if test "$HP_ARCH" = hppa2.0w then set_cc_for_build @@ -717,12 +764,12 @@ EOF HP_ARCH=hppa64 fi fi - echo "$HP_ARCH"-hp-hpux"$HPUX_REV" - exit ;; + GUESS=$HP_ARCH-hp-hpux$HPUX_REV + ;; ia64:HP-UX:*:*) - HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` - echo ia64-hp-hpux"$HPUX_REV" - exit ;; + HPUX_REV=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*.[0B]*//'` + GUESS=ia64-hp-hpux$HPUX_REV + ;; 3050*:HI-UX:*:*) set_cc_for_build sed 's/^ //' << EOF > "$dummy.c" @@ -752,36 +799,36 @@ EOF EOF $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` && { echo "$SYSTEM_NAME"; exit; } - echo unknown-hitachi-hiuxwe2 - exit ;; + GUESS=unknown-hitachi-hiuxwe2 + ;; 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*) - echo hppa1.1-hp-bsd - exit ;; + GUESS=hppa1.1-hp-bsd + ;; 9000/8??:4.3bsd:*:*) - echo hppa1.0-hp-bsd - exit ;; + GUESS=hppa1.0-hp-bsd + ;; *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) - echo hppa1.0-hp-mpeix - exit ;; + GUESS=hppa1.0-hp-mpeix + ;; hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*) - echo hppa1.1-hp-osf - exit ;; + GUESS=hppa1.1-hp-osf + ;; hp8??:OSF1:*:*) - echo hppa1.0-hp-osf - exit ;; + GUESS=hppa1.0-hp-osf + ;; i*86:OSF1:*:*) - if [ -x /usr/sbin/sysversion ] ; then - echo "$UNAME_MACHINE"-unknown-osf1mk + if test -x /usr/sbin/sysversion ; then + GUESS=$UNAME_MACHINE-unknown-osf1mk else - echo "$UNAME_MACHINE"-unknown-osf1 + GUESS=$UNAME_MACHINE-unknown-osf1 fi - exit ;; + ;; parisc*:Lites*:*:*) - echo hppa1.1-hp-lites - exit ;; + GUESS=hppa1.1-hp-lites + ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) - echo c1-convex-bsd - exit ;; + GUESS=c1-convex-bsd + ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd @@ -789,17 +836,18 @@ EOF fi exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) - echo c34-convex-bsd - exit ;; + GUESS=c34-convex-bsd + ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) - echo c38-convex-bsd - exit ;; + GUESS=c38-convex-bsd + ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) - echo c4-convex-bsd - exit ;; + GUESS=c4-convex-bsd + ;; CRAY*Y-MP:*:*:*) - echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' - exit ;; + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` + GUESS=ymp-cray-unicos$CRAY_REL + ;; CRAY*[A-Z]90:*:*:*) echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ @@ -807,114 +855,126 @@ EOF -e 's/\.[^.]*$/.X/' exit ;; CRAY*TS:*:*:*) - echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' - exit ;; + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` + GUESS=t90-cray-unicos$CRAY_REL + ;; CRAY*T3E:*:*:*) - echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' - exit ;; + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` + GUESS=alphaev5-cray-unicosmk$CRAY_REL + ;; CRAY*SV1:*:*:*) - echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' - exit ;; + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` + GUESS=sv1-cray-unicos$CRAY_REL + ;; *:UNICOS/mp:*:*) - echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' - exit ;; + CRAY_REL=`echo "$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/'` + GUESS=craynv-cray-unicosmp$CRAY_REL + ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'` - echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" - exit ;; + GUESS=${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} + ;; 5000:UNIX_System_V:4.*:*) FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'` - echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" - exit ;; + GUESS=sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL} + ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) - echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE-pc-bsdi$UNAME_RELEASE + ;; sparc*:BSD/OS:*:*) - echo sparc-unknown-bsdi"$UNAME_RELEASE" - exit ;; + GUESS=sparc-unknown-bsdi$UNAME_RELEASE + ;; *:BSD/OS:*:*) - echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE-unknown-bsdi$UNAME_RELEASE + ;; arm:FreeBSD:*:*) UNAME_PROCESSOR=`uname -p` set_cc_for_build if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then - echo "${UNAME_PROCESSOR}"-unknown-freebsd"`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`"-gnueabi + FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` + GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabi else - echo "${UNAME_PROCESSOR}"-unknown-freebsd"`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'`"-gnueabihf + FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` + GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL-gnueabihf fi - exit ;; + ;; *:FreeBSD:*:*) UNAME_PROCESSOR=`/usr/bin/uname -p` - case "$UNAME_PROCESSOR" in + case $UNAME_PROCESSOR in amd64) UNAME_PROCESSOR=x86_64 ;; i386) UNAME_PROCESSOR=i586 ;; esac - echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" - exit ;; + FREEBSD_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` + GUESS=$UNAME_PROCESSOR-unknown-freebsd$FREEBSD_REL + ;; i*:CYGWIN*:*) - echo "$UNAME_MACHINE"-pc-cygwin - exit ;; + GUESS=$UNAME_MACHINE-pc-cygwin + ;; *:MINGW64*:*) - echo "$UNAME_MACHINE"-pc-mingw64 - exit ;; + GUESS=$UNAME_MACHINE-pc-mingw64 + ;; *:MINGW*:*) - echo "$UNAME_MACHINE"-pc-mingw32 - exit ;; + GUESS=$UNAME_MACHINE-pc-mingw32 + ;; *:MSYS*:*) - echo "$UNAME_MACHINE"-pc-msys - exit ;; + GUESS=$UNAME_MACHINE-pc-msys + ;; i*:PW*:*) - echo "$UNAME_MACHINE"-pc-pw32 - exit ;; + GUESS=$UNAME_MACHINE-pc-pw32 + ;; *:Interix*:*) - case "$UNAME_MACHINE" in + case $UNAME_MACHINE in x86) - echo i586-pc-interix"$UNAME_RELEASE" - exit ;; + GUESS=i586-pc-interix$UNAME_RELEASE + ;; authenticamd | genuineintel | EM64T) - echo x86_64-unknown-interix"$UNAME_RELEASE" - exit ;; + GUESS=x86_64-unknown-interix$UNAME_RELEASE + ;; IA64) - echo ia64-unknown-interix"$UNAME_RELEASE" - exit ;; + GUESS=ia64-unknown-interix$UNAME_RELEASE + ;; esac ;; i*:UWIN*:*) - echo "$UNAME_MACHINE"-pc-uwin - exit ;; + GUESS=$UNAME_MACHINE-pc-uwin + ;; amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) - echo x86_64-unknown-cygwin - exit ;; + GUESS=x86_64-pc-cygwin + ;; prep*:SunOS:5.*:*) - echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" - exit ;; + SUN_REL=`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'` + GUESS=powerpcle-unknown-solaris2$SUN_REL + ;; *:GNU:*:*) # the GNU system - echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`" - exit ;; + GNU_ARCH=`echo "$UNAME_MACHINE" | sed -e 's,[-/].*$,,'` + GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's,/.*$,,'` + GUESS=$GNU_ARCH-unknown-$LIBC$GNU_REL + ;; *:GNU/*:*:*) # other systems with GNU libc and userland - echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC" - exit ;; + GNU_SYS=`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"` + GNU_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` + GUESS=$UNAME_MACHINE-unknown-$GNU_SYS$GNU_REL-$LIBC + ;; *:Minix:*:*) - echo "$UNAME_MACHINE"-unknown-minix - exit ;; + GUESS=$UNAME_MACHINE-unknown-minix + ;; aarch64:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; aarch64_be:Linux:*:*) UNAME_MACHINE=aarch64_be - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; alpha:Linux:*:*) - case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in + case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' /proc/cpuinfo 2>/dev/null` in EV5) UNAME_MACHINE=alphaev5 ;; EV56) UNAME_MACHINE=alphaev56 ;; PCA56) UNAME_MACHINE=alphapca56 ;; @@ -925,183 +985,225 @@ EOF esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC=gnulibc1 ; fi - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; - arc:Linux:*:* | arceb:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; + arc:Linux:*:* | arceb:Linux:*:* | arc32:Linux:*:* | arc64:Linux:*:*) + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; arm*:Linux:*:*) set_cc_for_build if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_EABI__ then - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC else if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ | grep -q __ARM_PCS_VFP then - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi + GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabi else - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf + GUESS=$UNAME_MACHINE-unknown-linux-${LIBC}eabihf fi fi - exit ;; + ;; avr32*:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; cris:Linux:*:*) - echo "$UNAME_MACHINE"-axis-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-axis-linux-$LIBC + ;; crisv32:Linux:*:*) - echo "$UNAME_MACHINE"-axis-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-axis-linux-$LIBC + ;; e2k:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; frv:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; hexagon:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; i*86:Linux:*:*) - echo "$UNAME_MACHINE"-pc-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-pc-linux-$LIBC + ;; ia64:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; k1om:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; + loongarch32:Linux:*:* | loongarch64:Linux:*:* | loongarchx32:Linux:*:*) + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; m32r*:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; m68*:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; mips:Linux:*:* | mips64:Linux:*:*) set_cc_for_build + IS_GLIBC=0 + test x"${LIBC}" = xgnu && IS_GLIBC=1 sed 's/^ //' << EOF > "$dummy.c" #undef CPU - #undef ${UNAME_MACHINE} - #undef ${UNAME_MACHINE}el + #undef mips + #undef mipsel + #undef mips64 + #undef mips64el + #if ${IS_GLIBC} && defined(_ABI64) + LIBCABI=gnuabi64 + #else + #if ${IS_GLIBC} && defined(_ABIN32) + LIBCABI=gnuabin32 + #else + LIBCABI=${LIBC} + #endif + #endif + + #if ${IS_GLIBC} && defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6 + CPU=mipsisa64r6 + #else + #if ${IS_GLIBC} && !defined(__mips64) && defined(__mips_isa_rev) && __mips_isa_rev>=6 + CPU=mipsisa32r6 + #else + #if defined(__mips64) + CPU=mips64 + #else + CPU=mips + #endif + #endif + #endif + #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) - CPU=${UNAME_MACHINE}el + MIPS_ENDIAN=el #else #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) - CPU=${UNAME_MACHINE} + MIPS_ENDIAN= #else - CPU= + MIPS_ENDIAN= #endif #endif EOF - eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`" - test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; } + cc_set_vars=`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU\|^MIPS_ENDIAN\|^LIBCABI'` + eval "$cc_set_vars" + test "x$CPU" != x && { echo "$CPU${MIPS_ENDIAN}-unknown-linux-$LIBCABI"; exit; } ;; mips64el:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; openrisc*:Linux:*:*) - echo or1k-unknown-linux-"$LIBC" - exit ;; + GUESS=or1k-unknown-linux-$LIBC + ;; or32:Linux:*:* | or1k*:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; padre:Linux:*:*) - echo sparc-unknown-linux-"$LIBC" - exit ;; + GUESS=sparc-unknown-linux-$LIBC + ;; parisc64:Linux:*:* | hppa64:Linux:*:*) - echo hppa64-unknown-linux-"$LIBC" - exit ;; + GUESS=hppa64-unknown-linux-$LIBC + ;; parisc:Linux:*:* | hppa:Linux:*:*) # Look for CPU level case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in - PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;; - PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;; - *) echo hppa-unknown-linux-"$LIBC" ;; + PA7*) GUESS=hppa1.1-unknown-linux-$LIBC ;; + PA8*) GUESS=hppa2.0-unknown-linux-$LIBC ;; + *) GUESS=hppa-unknown-linux-$LIBC ;; esac - exit ;; + ;; ppc64:Linux:*:*) - echo powerpc64-unknown-linux-"$LIBC" - exit ;; + GUESS=powerpc64-unknown-linux-$LIBC + ;; ppc:Linux:*:*) - echo powerpc-unknown-linux-"$LIBC" - exit ;; + GUESS=powerpc-unknown-linux-$LIBC + ;; ppc64le:Linux:*:*) - echo powerpc64le-unknown-linux-"$LIBC" - exit ;; + GUESS=powerpc64le-unknown-linux-$LIBC + ;; ppcle:Linux:*:*) - echo powerpcle-unknown-linux-"$LIBC" - exit ;; - riscv32:Linux:*:* | riscv64:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=powerpcle-unknown-linux-$LIBC + ;; + riscv32:Linux:*:* | riscv32be:Linux:*:* | riscv64:Linux:*:* | riscv64be:Linux:*:*) + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; s390:Linux:*:* | s390x:Linux:*:*) - echo "$UNAME_MACHINE"-ibm-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-ibm-linux-$LIBC + ;; sh64*:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; sh*:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; sparc:Linux:*:* | sparc64:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; tile*:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; vax:Linux:*:*) - echo "$UNAME_MACHINE"-dec-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-dec-linux-$LIBC + ;; x86_64:Linux:*:*) - echo "$UNAME_MACHINE"-pc-linux-"$LIBC" - exit ;; + set_cc_for_build + LIBCABI=$LIBC + if test "$CC_FOR_BUILD" != no_compiler_found; then + if (echo '#ifdef __ILP32__'; echo IS_X32; echo '#endif') | \ + (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_X32 >/dev/null + then + LIBCABI=${LIBC}x32 + fi + fi + GUESS=$UNAME_MACHINE-pc-linux-$LIBCABI + ;; xtensa*:Linux:*:*) - echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" - exit ;; + GUESS=$UNAME_MACHINE-unknown-linux-$LIBC + ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. # earlier versions are messed up and put the nodename in both # sysname and nodename. - echo i386-sequent-sysv4 - exit ;; + GUESS=i386-sequent-sysv4 + ;; i*86:UNIX_SV:4.2MP:2.*) # Unixware is an offshoot of SVR4, but it has its own version # number series starting with 2... # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. # Use sysv4.2uw... so that sysv4* matches it. - echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION" - exit ;; + GUESS=$UNAME_MACHINE-pc-sysv4.2uw$UNAME_VERSION + ;; i*86:OS/2:*:*) # If we were able to find `uname', then EMX Unix compatibility # is probably installed. - echo "$UNAME_MACHINE"-pc-os2-emx - exit ;; + GUESS=$UNAME_MACHINE-pc-os2-emx + ;; i*86:XTS-300:*:STOP) - echo "$UNAME_MACHINE"-unknown-stop - exit ;; + GUESS=$UNAME_MACHINE-unknown-stop + ;; i*86:atheos:*:*) - echo "$UNAME_MACHINE"-unknown-atheos - exit ;; + GUESS=$UNAME_MACHINE-unknown-atheos + ;; i*86:syllable:*:*) - echo "$UNAME_MACHINE"-pc-syllable - exit ;; + GUESS=$UNAME_MACHINE-pc-syllable + ;; i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) - echo i386-unknown-lynxos"$UNAME_RELEASE" - exit ;; + GUESS=i386-unknown-lynxos$UNAME_RELEASE + ;; i*86:*DOS:*:*) - echo "$UNAME_MACHINE"-pc-msdosdjgpp - exit ;; + GUESS=$UNAME_MACHINE-pc-msdosdjgpp + ;; i*86:*:4.*:*) UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'` if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then - echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL" + GUESS=$UNAME_MACHINE-univel-sysv$UNAME_REL else - echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL" + GUESS=$UNAME_MACHINE-pc-sysv$UNAME_REL fi - exit ;; + ;; i*86:*:5:[678]*) # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in @@ -1109,12 +1211,12 @@ EOF *Pentium) UNAME_MACHINE=i586 ;; *Pent*|*Celeron) UNAME_MACHINE=i686 ;; esac - echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}" - exit ;; + GUESS=$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION} + ;; i*86:*:3.2:*) if test -f /usr/options/cb.name; then UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 @@ -1124,11 +1226,11 @@ EOF && UNAME_MACHINE=i686 (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ && UNAME_MACHINE=i686 - echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL" + GUESS=$UNAME_MACHINE-pc-sco$UNAME_REL else - echo "$UNAME_MACHINE"-pc-sysv32 + GUESS=$UNAME_MACHINE-pc-sysv32 fi - exit ;; + ;; pc:*:*:*) # Left here for compatibility: # uname -m prints for DJGPP always 'pc', but it prints nothing about @@ -1136,31 +1238,31 @@ EOF # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configure will decide that # this is a cross-build. - echo i586-pc-msdosdjgpp - exit ;; + GUESS=i586-pc-msdosdjgpp + ;; Intel:Mach:3*:*) - echo i386-pc-mach3 - exit ;; + GUESS=i386-pc-mach3 + ;; paragon:*:*:*) - echo i860-intel-osf1 - exit ;; + GUESS=i860-intel-osf1 + ;; i860:*:4.*:*) # i860-SVR4 if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then - echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4 + GUESS=i860-stardent-sysv$UNAME_RELEASE # Stardent Vistra i860-SVR4 else # Add other i860-SVR4 vendors below as they are discovered. - echo i860-unknown-sysv"$UNAME_RELEASE" # Unknown i860-SVR4 + GUESS=i860-unknown-sysv$UNAME_RELEASE # Unknown i860-SVR4 fi - exit ;; + ;; mini*:CTIX:SYS*5:*) # "miniframe" - echo m68010-convergent-sysv - exit ;; + GUESS=m68010-convergent-sysv + ;; mc68k:UNIX:SYSTEM5:3.51m) - echo m68k-convergent-sysv - exit ;; + GUESS=m68k-convergent-sysv + ;; M680?0:D-NIX:5.3:*) - echo m68k-diab-dnix - exit ;; + GUESS=m68k-diab-dnix + ;; M68*:*:R3V[5678]*:*) test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) @@ -1185,250 +1287,401 @@ EOF /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) - echo m68k-unknown-lynxos"$UNAME_RELEASE" - exit ;; + GUESS=m68k-unknown-lynxos$UNAME_RELEASE + ;; mc68030:UNIX_System_V:4.*:*) - echo m68k-atari-sysv4 - exit ;; + GUESS=m68k-atari-sysv4 + ;; TSUNAMI:LynxOS:2.*:*) - echo sparc-unknown-lynxos"$UNAME_RELEASE" - exit ;; + GUESS=sparc-unknown-lynxos$UNAME_RELEASE + ;; rs6000:LynxOS:2.*:*) - echo rs6000-unknown-lynxos"$UNAME_RELEASE" - exit ;; + GUESS=rs6000-unknown-lynxos$UNAME_RELEASE + ;; PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) - echo powerpc-unknown-lynxos"$UNAME_RELEASE" - exit ;; + GUESS=powerpc-unknown-lynxos$UNAME_RELEASE + ;; SM[BE]S:UNIX_SV:*:*) - echo mips-dde-sysv"$UNAME_RELEASE" - exit ;; + GUESS=mips-dde-sysv$UNAME_RELEASE + ;; RM*:ReliantUNIX-*:*:*) - echo mips-sni-sysv4 - exit ;; + GUESS=mips-sni-sysv4 + ;; RM*:SINIX-*:*:*) - echo mips-sni-sysv4 - exit ;; + GUESS=mips-sni-sysv4 + ;; *:SINIX-*:*:*) if uname -p 2>/dev/null >/dev/null ; then UNAME_MACHINE=`(uname -p) 2>/dev/null` - echo "$UNAME_MACHINE"-sni-sysv4 + GUESS=$UNAME_MACHINE-sni-sysv4 else - echo ns32k-sni-sysv + GUESS=ns32k-sni-sysv fi - exit ;; + ;; PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort # says - echo i586-unisys-sysv4 - exit ;; + GUESS=i586-unisys-sysv4 + ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm - echo hppa1.1-stratus-sysv4 - exit ;; + GUESS=hppa1.1-stratus-sysv4 + ;; *:*:*:FTX*) # From seanf@swdc.stratus.com. - echo i860-stratus-sysv4 - exit ;; + GUESS=i860-stratus-sysv4 + ;; i*86:VOS:*:*) # From Paul.Green@stratus.com. - echo "$UNAME_MACHINE"-stratus-vos - exit ;; + GUESS=$UNAME_MACHINE-stratus-vos + ;; *:VOS:*:*) # From Paul.Green@stratus.com. - echo hppa1.1-stratus-vos - exit ;; + GUESS=hppa1.1-stratus-vos + ;; mc68*:A/UX:*:*) - echo m68k-apple-aux"$UNAME_RELEASE" - exit ;; + GUESS=m68k-apple-aux$UNAME_RELEASE + ;; news*:NEWS-OS:6*:*) - echo mips-sony-newsos6 - exit ;; + GUESS=mips-sony-newsos6 + ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) - if [ -d /usr/nec ]; then - echo mips-nec-sysv"$UNAME_RELEASE" + if test -d /usr/nec; then + GUESS=mips-nec-sysv$UNAME_RELEASE else - echo mips-unknown-sysv"$UNAME_RELEASE" + GUESS=mips-unknown-sysv$UNAME_RELEASE fi - exit ;; + ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. - echo powerpc-be-beos - exit ;; + GUESS=powerpc-be-beos + ;; BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. - echo powerpc-apple-beos - exit ;; + GUESS=powerpc-apple-beos + ;; BePC:BeOS:*:*) # BeOS running on Intel PC compatible. - echo i586-pc-beos - exit ;; + GUESS=i586-pc-beos + ;; BePC:Haiku:*:*) # Haiku running on Intel PC compatible. - echo i586-pc-haiku - exit ;; + GUESS=i586-pc-haiku + ;; x86_64:Haiku:*:*) - echo x86_64-unknown-haiku - exit ;; + GUESS=x86_64-unknown-haiku + ;; SX-4:SUPER-UX:*:*) - echo sx4-nec-superux"$UNAME_RELEASE" - exit ;; + GUESS=sx4-nec-superux$UNAME_RELEASE + ;; SX-5:SUPER-UX:*:*) - echo sx5-nec-superux"$UNAME_RELEASE" - exit ;; + GUESS=sx5-nec-superux$UNAME_RELEASE + ;; SX-6:SUPER-UX:*:*) - echo sx6-nec-superux"$UNAME_RELEASE" - exit ;; + GUESS=sx6-nec-superux$UNAME_RELEASE + ;; SX-7:SUPER-UX:*:*) - echo sx7-nec-superux"$UNAME_RELEASE" - exit ;; + GUESS=sx7-nec-superux$UNAME_RELEASE + ;; SX-8:SUPER-UX:*:*) - echo sx8-nec-superux"$UNAME_RELEASE" - exit ;; + GUESS=sx8-nec-superux$UNAME_RELEASE + ;; SX-8R:SUPER-UX:*:*) - echo sx8r-nec-superux"$UNAME_RELEASE" - exit ;; + GUESS=sx8r-nec-superux$UNAME_RELEASE + ;; SX-ACE:SUPER-UX:*:*) - echo sxace-nec-superux"$UNAME_RELEASE" - exit ;; + GUESS=sxace-nec-superux$UNAME_RELEASE + ;; Power*:Rhapsody:*:*) - echo powerpc-apple-rhapsody"$UNAME_RELEASE" - exit ;; + GUESS=powerpc-apple-rhapsody$UNAME_RELEASE + ;; *:Rhapsody:*:*) - echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE-apple-rhapsody$UNAME_RELEASE + ;; + arm64:Darwin:*:*) + GUESS=aarch64-apple-darwin$UNAME_RELEASE + ;; *:Darwin:*:*) - UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown - set_cc_for_build - if test "$UNAME_PROCESSOR" = unknown ; then - UNAME_PROCESSOR=powerpc + UNAME_PROCESSOR=`uname -p` + case $UNAME_PROCESSOR in + unknown) UNAME_PROCESSOR=powerpc ;; + esac + if command -v xcode-select > /dev/null 2> /dev/null && \ + ! xcode-select --print-path > /dev/null 2> /dev/null ; then + # Avoid executing cc if there is no toolchain installed as + # cc will be a stub that puts up a graphical alert + # prompting the user to install developer tools. + CC_FOR_BUILD=no_compiler_found + else + set_cc_for_build fi - if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then - if [ "$CC_FOR_BUILD" != no_compiler_found ]; then - if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ - (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ - grep IS_64BIT_ARCH >/dev/null - then - case $UNAME_PROCESSOR in - i386) UNAME_PROCESSOR=x86_64 ;; - powerpc) UNAME_PROCESSOR=powerpc64 ;; - esac - fi - # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc - if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \ - (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ - grep IS_PPC >/dev/null - then - UNAME_PROCESSOR=powerpc - fi + if test "$CC_FOR_BUILD" != no_compiler_found; then + if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ + (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_64BIT_ARCH >/dev/null + then + case $UNAME_PROCESSOR in + i386) UNAME_PROCESSOR=x86_64 ;; + powerpc) UNAME_PROCESSOR=powerpc64 ;; + esac + fi + # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc + if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \ + (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ + grep IS_PPC >/dev/null + then + UNAME_PROCESSOR=powerpc fi elif test "$UNAME_PROCESSOR" = i386 ; then - # Avoid executing cc on OS X 10.9, as it ships with a stub - # that puts up a graphical alert prompting to install - # developer tools. Any system running Mac OS X 10.7 or - # later (Darwin 11 and later) is required to have a 64-bit - # processor. This is not true of the ARM version of Darwin - # that Apple uses in portable devices. - UNAME_PROCESSOR=x86_64 + # uname -m returns i386 or x86_64 + UNAME_PROCESSOR=$UNAME_MACHINE fi - echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_PROCESSOR-apple-darwin$UNAME_RELEASE + ;; *:procnto*:*:* | *:QNX:[0123456789]*:*) UNAME_PROCESSOR=`uname -p` if test "$UNAME_PROCESSOR" = x86; then UNAME_PROCESSOR=i386 UNAME_MACHINE=pc fi - echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_PROCESSOR-$UNAME_MACHINE-nto-qnx$UNAME_RELEASE + ;; *:QNX:*:4*) - echo i386-pc-qnx - exit ;; + GUESS=i386-pc-qnx + ;; NEO-*:NONSTOP_KERNEL:*:*) - echo neo-tandem-nsk"$UNAME_RELEASE" - exit ;; + GUESS=neo-tandem-nsk$UNAME_RELEASE + ;; NSE-*:NONSTOP_KERNEL:*:*) - echo nse-tandem-nsk"$UNAME_RELEASE" - exit ;; + GUESS=nse-tandem-nsk$UNAME_RELEASE + ;; NSR-*:NONSTOP_KERNEL:*:*) - echo nsr-tandem-nsk"$UNAME_RELEASE" - exit ;; + GUESS=nsr-tandem-nsk$UNAME_RELEASE + ;; NSV-*:NONSTOP_KERNEL:*:*) - echo nsv-tandem-nsk"$UNAME_RELEASE" - exit ;; + GUESS=nsv-tandem-nsk$UNAME_RELEASE + ;; NSX-*:NONSTOP_KERNEL:*:*) - echo nsx-tandem-nsk"$UNAME_RELEASE" - exit ;; + GUESS=nsx-tandem-nsk$UNAME_RELEASE + ;; *:NonStop-UX:*:*) - echo mips-compaq-nonstopux - exit ;; + GUESS=mips-compaq-nonstopux + ;; BS2000:POSIX*:*:*) - echo bs2000-siemens-sysv - exit ;; + GUESS=bs2000-siemens-sysv + ;; DS/*:UNIX_System_V:*:*) - echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE" - exit ;; + GUESS=$UNAME_MACHINE-$UNAME_SYSTEM-$UNAME_RELEASE + ;; *:Plan9:*:*) # "uname -m" is not consistent, so use $cputype instead. 386 # is converted to i386 for consistency with other x86 # operating systems. - # shellcheck disable=SC2154 - if test "$cputype" = 386; then + if test "${cputype-}" = 386; then UNAME_MACHINE=i386 - else - UNAME_MACHINE="$cputype" + elif test "x${cputype-}" != x; then + UNAME_MACHINE=$cputype fi - echo "$UNAME_MACHINE"-unknown-plan9 - exit ;; + GUESS=$UNAME_MACHINE-unknown-plan9 + ;; *:TOPS-10:*:*) - echo pdp10-unknown-tops10 - exit ;; + GUESS=pdp10-unknown-tops10 + ;; *:TENEX:*:*) - echo pdp10-unknown-tenex - exit ;; + GUESS=pdp10-unknown-tenex + ;; KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) - echo pdp10-dec-tops20 - exit ;; + GUESS=pdp10-dec-tops20 + ;; XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) - echo pdp10-xkl-tops20 - exit ;; + GUESS=pdp10-xkl-tops20 + ;; *:TOPS-20:*:*) - echo pdp10-unknown-tops20 - exit ;; + GUESS=pdp10-unknown-tops20 + ;; *:ITS:*:*) - echo pdp10-unknown-its - exit ;; + GUESS=pdp10-unknown-its + ;; SEI:*:*:SEIUX) - echo mips-sei-seiux"$UNAME_RELEASE" - exit ;; + GUESS=mips-sei-seiux$UNAME_RELEASE + ;; *:DragonFly:*:*) - echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" - exit ;; + DRAGONFLY_REL=`echo "$UNAME_RELEASE" | sed -e 's/[-(].*//'` + GUESS=$UNAME_MACHINE-unknown-dragonfly$DRAGONFLY_REL + ;; *:*VMS:*:*) UNAME_MACHINE=`(uname -p) 2>/dev/null` - case "$UNAME_MACHINE" in - A*) echo alpha-dec-vms ; exit ;; - I*) echo ia64-dec-vms ; exit ;; - V*) echo vax-dec-vms ; exit ;; + case $UNAME_MACHINE in + A*) GUESS=alpha-dec-vms ;; + I*) GUESS=ia64-dec-vms ;; + V*) GUESS=vax-dec-vms ;; esac ;; *:XENIX:*:SysV) - echo i386-pc-xenix - exit ;; + GUESS=i386-pc-xenix + ;; i*86:skyos:*:*) - echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`" - exit ;; + SKYOS_REL=`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'` + GUESS=$UNAME_MACHINE-pc-skyos$SKYOS_REL + ;; i*86:rdos:*:*) - echo "$UNAME_MACHINE"-pc-rdos - exit ;; - i*86:AROS:*:*) - echo "$UNAME_MACHINE"-pc-aros - exit ;; + GUESS=$UNAME_MACHINE-pc-rdos + ;; + *:AROS:*:*) + GUESS=$UNAME_MACHINE-unknown-aros + ;; x86_64:VMkernel:*:*) - echo "$UNAME_MACHINE"-unknown-esx - exit ;; + GUESS=$UNAME_MACHINE-unknown-esx + ;; amd64:Isilon\ OneFS:*:*) - echo x86_64-unknown-onefs - exit ;; + GUESS=x86_64-unknown-onefs + ;; + *:Unleashed:*:*) + GUESS=$UNAME_MACHINE-unknown-unleashed$UNAME_RELEASE + ;; esac +# Do we have a guess based on uname results? +if test "x$GUESS" != x; then + echo "$GUESS" + exit +fi + +# No uname command or uname output not recognized. +set_cc_for_build +cat > "$dummy.c" < +#include +#endif +#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__) +#if defined (vax) || defined (__vax) || defined (__vax__) || defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__) +#include +#if defined(_SIZE_T_) || defined(SIGLOST) +#include +#endif +#endif +#endif +main () +{ +#if defined (sony) +#if defined (MIPSEB) + /* BFD wants "bsd" instead of "newsos". Perhaps BFD should be changed, + I don't know.... */ + printf ("mips-sony-bsd\n"); exit (0); +#else +#include + printf ("m68k-sony-newsos%s\n", +#ifdef NEWSOS4 + "4" +#else + "" +#endif + ); exit (0); +#endif +#endif + +#if defined (NeXT) +#if !defined (__ARCHITECTURE__) +#define __ARCHITECTURE__ "m68k" +#endif + int version; + version=`(hostinfo | sed -n 's/.*NeXT Mach \([0-9]*\).*/\1/p') 2>/dev/null`; + if (version < 4) + printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version); + else + printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version); + exit (0); +#endif + +#if defined (MULTIMAX) || defined (n16) +#if defined (UMAXV) + printf ("ns32k-encore-sysv\n"); exit (0); +#else +#if defined (CMU) + printf ("ns32k-encore-mach\n"); exit (0); +#else + printf ("ns32k-encore-bsd\n"); exit (0); +#endif +#endif +#endif + +#if defined (__386BSD__) + printf ("i386-pc-bsd\n"); exit (0); +#endif + +#if defined (sequent) +#if defined (i386) + printf ("i386-sequent-dynix\n"); exit (0); +#endif +#if defined (ns32000) + printf ("ns32k-sequent-dynix\n"); exit (0); +#endif +#endif + +#if defined (_SEQUENT_) + struct utsname un; + + uname(&un); + if (strncmp(un.version, "V2", 2) == 0) { + printf ("i386-sequent-ptx2\n"); exit (0); + } + if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */ + printf ("i386-sequent-ptx1\n"); exit (0); + } + printf ("i386-sequent-ptx\n"); exit (0); +#endif + +#if defined (vax) +#if !defined (ultrix) +#include +#if defined (BSD) +#if BSD == 43 + printf ("vax-dec-bsd4.3\n"); exit (0); +#else +#if BSD == 199006 + printf ("vax-dec-bsd4.3reno\n"); exit (0); +#else + printf ("vax-dec-bsd\n"); exit (0); +#endif +#endif +#else + printf ("vax-dec-bsd\n"); exit (0); +#endif +#else +#if defined(_SIZE_T_) || defined(SIGLOST) + struct utsname un; + uname (&un); + printf ("vax-dec-ultrix%s\n", un.release); exit (0); +#else + printf ("vax-dec-ultrix\n"); exit (0); +#endif +#endif +#endif +#if defined(ultrix) || defined(_ultrix) || defined(__ultrix) || defined(__ultrix__) +#if defined(mips) || defined(__mips) || defined(__mips__) || defined(MIPS) || defined(__MIPS__) +#if defined(_SIZE_T_) || defined(SIGLOST) + struct utsname *un; + uname (&un); + printf ("mips-dec-ultrix%s\n", un.release); exit (0); +#else + printf ("mips-dec-ultrix\n"); exit (0); +#endif +#endif +#endif + +#if defined (alliant) && defined (i860) + printf ("i860-alliant-bsd\n"); exit (0); +#endif + + exit (1); +} +EOF + +$CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null && SYSTEM_NAME=`"$dummy"` && + { echo "$SYSTEM_NAME"; exit; } + +# Apollos put the system type in the environment. +test -d /usr/apollo && { echo "$ISP-apollo-$SYSTYPE"; exit; } + echo "$0: unable to guess system type" >&2 -case "$UNAME_MACHINE:$UNAME_SYSTEM" in +case $UNAME_MACHINE:$UNAME_SYSTEM in mips:Linux | mips64:Linux) # If we got here on MIPS GNU/Linux, output extra information. cat >&2 <&2 <&2 exit 1 ;; *local*) @@ -111,9 +120,12 @@ case $# in esac # Split fields of configuration type -IFS="-" read -r field1 field2 field3 field4 <&2 - exit 1 + # No normalization, but not necessarily accepted, that comes below. ;; esac + else # Here we handle the default operating systems that come with various machines. @@ -1525,6 +1522,7 @@ else # will signal an error saying that MANUFACTURER isn't an operating # system, and we'll never get to this point. +kernel= case $cpu-$vendor in score-*) os=elf @@ -1536,7 +1534,8 @@ case $cpu-$vendor in os=riscix1.2 ;; arm*-rebel) - os=linux + kernel=linux + os=gnu ;; arm*-semi) os=aout @@ -1702,84 +1701,179 @@ case $cpu-$vendor in os=none ;; esac + fi +# Now, validate our (potentially fixed-up) OS. +case $os in + # Sometimes we do "kernel-libc", so those need to count as OSes. + musl* | newlib* | relibc* | uclibc*) + ;; + # Likewise for "kernel-abi" + eabi* | gnueabi*) + ;; + # VxWorks passes extra cpu info in the 4th filed. + simlinux | simwindows | spe) + ;; + # Now accept the basic system types. + # The portable systems comes first. + # Each alternative MUST end in a * to match a version number. + gnu* | android* | bsd* | mach* | minix* | genix* | ultrix* | irix* \ + | *vms* | esix* | aix* | cnk* | sunos | sunos[34]* \ + | hpux* | unos* | osf* | luna* | dgux* | auroraux* | solaris* \ + | sym* | plan9* | psp* | sim* | xray* | os68k* | v88r* \ + | hiux* | abug | nacl* | netware* | windows* \ + | os9* | macos* | osx* | ios* \ + | mpw* | magic* | mmixware* | mon960* | lnews* \ + | amigaos* | amigados* | msdos* | newsos* | unicos* | aof* \ + | aos* | aros* | cloudabi* | sortix* | twizzler* \ + | nindy* | vxsim* | vxworks* | ebmon* | hms* | mvs* \ + | clix* | riscos* | uniplus* | iris* | isc* | rtu* | xenix* \ + | mirbsd* | netbsd* | dicos* | openedition* | ose* \ + | bitrig* | openbsd* | secbsd* | solidbsd* | libertybsd* | os108* \ + | ekkobsd* | freebsd* | riscix* | lynxos* | os400* \ + | bosx* | nextstep* | cxux* | aout* | elf* | oabi* \ + | ptx* | coff* | ecoff* | winnt* | domain* | vsta* \ + | udi* | lites* | ieee* | go32* | aux* | hcos* \ + | chorusrdb* | cegcc* | glidix* | serenity* \ + | cygwin* | msys* | pe* | moss* | proelf* | rtems* \ + | midipix* | mingw32* | mingw64* | mint* \ + | uxpv* | beos* | mpeix* | udk* | moxiebox* \ + | interix* | uwin* | mks* | rhapsody* | darwin* \ + | openstep* | oskit* | conix* | pw32* | nonstopux* \ + | storm-chaos* | tops10* | tenex* | tops20* | its* \ + | os2* | vos* | palmos* | uclinux* | nucleus* | morphos* \ + | scout* | superux* | sysv* | rtmk* | tpf* | windiss* \ + | powermax* | dnix* | nx6 | nx7 | sei* | dragonfly* \ + | skyos* | haiku* | rdos* | toppers* | drops* | es* \ + | onefs* | tirtos* | phoenix* | fuchsia* | redox* | bme* \ + | midnightbsd* | amdhsa* | unleashed* | emscripten* | wasi* \ + | nsk* | powerunix* | genode* | zvmoe* | qnx* | emx* | zephyr*) + ;; + # This one is extra strict with allowed versions + sco3.2v2 | sco3.2v[4-9]* | sco5v6*) + # Don't forget version if it is 3.2v4 or newer. + ;; + none) + ;; + *) + echo Invalid configuration \`"$1"\': OS \`"$os"\' not recognized 1>&2 + exit 1 + ;; +esac + +# As a final step for OS-related things, validate the OS-kernel combination +# (given a valid OS), if there is a kernel. +case $kernel-$os in + linux-gnu* | linux-dietlibc* | linux-android* | linux-newlib* \ + | linux-musl* | linux-relibc* | linux-uclibc* ) + ;; + uclinux-uclibc* ) + ;; + -dietlibc* | -newlib* | -musl* | -relibc* | -uclibc* ) + # These are just libc implementations, not actual OSes, and thus + # require a kernel. + echo "Invalid configuration \`$1': libc \`$os' needs explicit kernel." 1>&2 + exit 1 + ;; + kfreebsd*-gnu* | kopensolaris*-gnu*) + ;; + vxworks-simlinux | vxworks-simwindows | vxworks-spe) + ;; + nto-qnx*) + ;; + os2-emx) + ;; + *-eabi* | *-gnueabi*) + ;; + -*) + # Blank kernel with real OS is always fine. + ;; + *-*) + echo "Invalid configuration \`$1': Kernel \`$kernel' not known to work with OS \`$os'." 1>&2 + exit 1 + ;; +esac + # Here we handle the case where we know the os, and the CPU type, but not the # manufacturer. We pick the logical manufacturer. case $vendor in unknown) - case $os in - riscix*) + case $cpu-$os in + *-riscix*) vendor=acorn ;; - sunos*) + *-sunos*) vendor=sun ;; - cnk*|-aix*) + *-cnk* | *-aix*) vendor=ibm ;; - beos*) + *-beos*) vendor=be ;; - hpux*) + *-hpux*) vendor=hp ;; - mpeix*) + *-mpeix*) vendor=hp ;; - hiux*) + *-hiux*) vendor=hitachi ;; - unos*) + *-unos*) vendor=crds ;; - dgux*) + *-dgux*) vendor=dg ;; - luna*) + *-luna*) vendor=omron ;; - genix*) + *-genix*) vendor=ns ;; - clix*) + *-clix*) vendor=intergraph ;; - mvs* | opened*) + *-mvs* | *-opened*) + vendor=ibm + ;; + *-os400*) vendor=ibm ;; - os400*) + s390-* | s390x-*) vendor=ibm ;; - ptx*) + *-ptx*) vendor=sequent ;; - tpf*) + *-tpf*) vendor=ibm ;; - vxsim* | vxworks* | windiss*) + *-vxsim* | *-vxworks* | *-windiss*) vendor=wrs ;; - aux*) + *-aux*) vendor=apple ;; - hms*) + *-hms*) vendor=hitachi ;; - mpw* | macos*) + *-mpw* | *-macos*) vendor=apple ;; - *mint | mint[0-9]* | *MiNT | MiNT[0-9]*) + *-*mint | *-mint[0-9]* | *-*MiNT | *-MiNT[0-9]*) vendor=atari ;; - vos*) + *-vos*) vendor=stratus ;; esac ;; esac -echo "$cpu-$vendor-$os" +echo "$cpu-$vendor-${kernel:+$kernel-}$os" exit # Local variables: diff --git a/config/install-sh b/config/install-sh index 20d8b2e..ec298b5 100755 --- a/config/install-sh +++ b/config/install-sh @@ -1,7 +1,7 @@ #!/bin/sh # install - install a program, script, or datafile -scriptversion=2018-03-11.20; # UTC +scriptversion=2020-11-14.01; # UTC # This originates from X11R5 (mit/util/scripts/install.sh), which was # later released in X11R6 (xc/config/util/install.sh) with the @@ -69,6 +69,11 @@ posix_mkdir= # Desired mode of installed file. mode=0755 +# Create dirs (including intermediate dirs) using mode 755. +# This is like GNU 'install' as of coreutils 8.32 (2020). +mkdir_umask=22 + +backupsuffix= chgrpcmd= chmodcmd=$chmodprog chowncmd= @@ -99,18 +104,28 @@ Options: --version display version info and exit. -c (ignored) - -C install only if different (preserve the last data modification time) + -C install only if different (preserve data modification time) -d create directories instead of installing files. -g GROUP $chgrpprog installed files to GROUP. -m MODE $chmodprog installed files to MODE. -o USER $chownprog installed files to USER. + -p pass -p to $cpprog. -s $stripprog installed files. + -S SUFFIX attempt to back up existing files, with suffix SUFFIX. -t DIRECTORY install into DIRECTORY. -T report an error if DSTFILE is a directory. Environment variables override the default commands: CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG RMPROG STRIPPROG + +By default, rm is invoked with -f; when overridden with RMPROG, +it's up to you to specify -f if you want it. + +If -S is not specified, no backups are attempted. + +Email bug reports to bug-automake@gnu.org. +Automake home page: https://www.gnu.org/software/automake/ " while test $# -ne 0; do @@ -137,8 +152,13 @@ while test $# -ne 0; do -o) chowncmd="$chownprog $2" shift;; + -p) cpprog="$cpprog -p";; + -s) stripcmd=$stripprog;; + -S) backupsuffix="$2" + shift;; + -t) is_target_a_directory=always dst_arg=$2 @@ -255,6 +275,10 @@ do dstdir=$dst test -d "$dstdir" dstdir_status=$? + # Don't chown directories that already exist. + if test $dstdir_status = 0; then + chowncmd="" + fi else # Waiting for this to be detected by the "$cpprog $src $dsttmp" command @@ -301,22 +325,6 @@ do if test $dstdir_status != 0; then case $posix_mkdir in '') - # Create intermediate dirs using mode 755 as modified by the umask. - # This is like FreeBSD 'install' as of 1997-10-28. - umask=`umask` - case $stripcmd.$umask in - # Optimize common cases. - *[2367][2367]) mkdir_umask=$umask;; - .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; - - *[0-7]) - mkdir_umask=`expr $umask + 22 \ - - $umask % 100 % 40 + $umask % 20 \ - - $umask % 10 % 4 + $umask % 2 - `;; - *) mkdir_umask=$umask,go-w;; - esac - # With -d, create the new directory with the user-specified mode. # Otherwise, rely on $mkdir_umask. if test -n "$dir_arg"; then @@ -326,52 +334,49 @@ do fi posix_mkdir=false - case $umask in - *[123567][0-7][0-7]) - # POSIX mkdir -p sets u+wx bits regardless of umask, which - # is incompatible with FreeBSD 'install' when (umask & 300) != 0. - ;; - *) - # Note that $RANDOM variable is not portable (e.g. dash); Use it - # here however when possible just to lower collision chance. - tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ - - trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0 - - # Because "mkdir -p" follows existing symlinks and we likely work - # directly in world-writeable /tmp, make sure that the '$tmpdir' - # directory is successfully created first before we actually test - # 'mkdir -p' feature. - if (umask $mkdir_umask && - $mkdirprog $mkdir_mode "$tmpdir" && - exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1 - then - if test -z "$dir_arg" || { - # Check for POSIX incompatibilities with -m. - # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or - # other-writable bit of parent directory when it shouldn't. - # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. - test_tmpdir="$tmpdir/a" - ls_ld_tmpdir=`ls -ld "$test_tmpdir"` - case $ls_ld_tmpdir in - d????-?r-*) different_mode=700;; - d????-?--*) different_mode=755;; - *) false;; - esac && - $mkdirprog -m$different_mode -p -- "$test_tmpdir" && { - ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"` - test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" - } - } - then posix_mkdir=: - fi - rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" - else - # Remove any dirs left behind by ancient mkdir implementations. - rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null - fi - trap '' 0;; - esac;; + # The $RANDOM variable is not portable (e.g., dash). Use it + # here however when possible just to lower collision chance. + tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ + + trap ' + ret=$? + rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null + exit $ret + ' 0 + + # Because "mkdir -p" follows existing symlinks and we likely work + # directly in world-writeable /tmp, make sure that the '$tmpdir' + # directory is successfully created first before we actually test + # 'mkdir -p'. + if (umask $mkdir_umask && + $mkdirprog $mkdir_mode "$tmpdir" && + exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1 + then + if test -z "$dir_arg" || { + # Check for POSIX incompatibilities with -m. + # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or + # other-writable bit of parent directory when it shouldn't. + # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. + test_tmpdir="$tmpdir/a" + ls_ld_tmpdir=`ls -ld "$test_tmpdir"` + case $ls_ld_tmpdir in + d????-?r-*) different_mode=700;; + d????-?--*) different_mode=755;; + *) false;; + esac && + $mkdirprog -m$different_mode -p -- "$test_tmpdir" && { + ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"` + test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" + } + } + then posix_mkdir=: + fi + rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" + else + # Remove any dirs left behind by ancient mkdir implementations. + rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null + fi + trap '' 0;; esac if @@ -382,7 +387,7 @@ do then : else - # The umask is ridiculous, or mkdir does not conform to POSIX, + # mkdir does not conform to POSIX, # or it failed possibly due to a race condition. Create the # directory the slow way, step by step, checking for races as we go. @@ -411,7 +416,7 @@ do prefixes= else if $posix_mkdir; then - (umask=$mkdir_umask && + (umask $mkdir_umask && $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break # Don't fail if two instances are running concurrently. test -d "$prefix" || exit 1 @@ -488,6 +493,13 @@ do then rm -f "$dsttmp" else + # If $backupsuffix is set, and the file being installed + # already exists, attempt a backup. Don't worry if it fails, + # e.g., if mv doesn't support -f. + if test -n "$backupsuffix" && test -f "$dst"; then + $doit $mvcmd -f "$dst" "$dst$backupsuffix" 2>/dev/null + fi + # Rename the file to the real destination. $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || @@ -502,9 +514,9 @@ do # file should still install successfully. { test ! -f "$dst" || - $doit $rmcmd -f "$dst" 2>/dev/null || + $doit $rmcmd "$dst" 2>/dev/null || { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && - { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } + { $doit $rmcmd "$rmtmp" 2>/dev/null; :; } } || { echo "$0: cannot unlink or rename $dst" >&2 (exit 1); exit 1 diff --git a/config/ltmain.sh b/config/ltmain.sh index 49fcad1..2a50d7f 100644 --- a/config/ltmain.sh +++ b/config/ltmain.sh @@ -2668,10 +2668,17 @@ libtool_validate_options () # preserve --debug test : = "$debug_cmd" || func_append preserve_args " --debug" - # Keeping compiler generated duplicates in $postdeps and $predeps is not - # harmful, and is necessary in a majority of systems that use it to satisfy - # symbol dependencies. - opt_duplicate_compiler_generated_deps=: + case $host in + # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452 + # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788 + *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*) + # don't eliminate duplications in $postdeps and $predeps + opt_duplicate_compiler_generated_deps=: + ;; + *) + opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps + ;; + esac $opt_help || { # Sanity checks first: diff --git a/config/missing b/config/missing index 8d0eaad..1fe1611 100755 --- a/config/missing +++ b/config/missing @@ -3,7 +3,7 @@ scriptversion=2018-03-07.03; # UTC -# Copyright (C) 1996-2020 Free Software Foundation, Inc. +# Copyright (C) 1996-2021 Free Software Foundation, Inc. # Originally written by Fran,cois Pinard , 1996. # This program is free software; you can redistribute it and/or modify diff --git a/config/mkinstalldirs b/config/mkinstalldirs index 36aa909..c364f3d 100755 --- a/config/mkinstalldirs +++ b/config/mkinstalldirs @@ -1,7 +1,7 @@ #! /bin/sh # mkinstalldirs --- make directory hierarchy -scriptversion=2018-03-07.03; # UTC +scriptversion=2020-07-26.22; # UTC # Original author: Noah Friedman # Created: 1993-05-16 @@ -92,6 +92,8 @@ case $dirmode in *) if mkdir -m "$dirmode" -p --version . >/dev/null 2>&1 && test ! -d ./--version; then + echo "umask 22" + umask 22 echo "mkdir -m $dirmode -p -- $*" exec mkdir -m "$dirmode" -p -- "$@" else @@ -104,6 +106,9 @@ case $dirmode in ;; esac +echo "umask 22" +umask 22 + for file do case $file in @@ -132,21 +137,16 @@ do if test ! -d "$pathcomp"; then errstatus=$lasterr - else - if test ! -z "$dirmode"; then - echo "chmod $dirmode $pathcomp" - lasterr= - chmod "$dirmode" "$pathcomp" || lasterr=$? - - if test ! -z "$lasterr"; then - errstatus=$lasterr - fi - fi fi fi pathcomp=$pathcomp/ done + + if test ! -z "$dirmode"; then + echo "chmod $dirmode $file" + chmod "$dirmode" "$file" || errstatus=$? + fi done exit $errstatus diff --git a/configure b/configure index 525e9c5..8872bd5 100755 --- a/configure +++ b/configure @@ -1,9 +1,9 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.71 for libdnet 1.17.0. +# Generated by GNU Autoconf 2.72 for libdnet 1.18.0. # # -# Copyright (C) 1992-1996, 1998-2017, 2020-2021 Free Software Foundation, +# Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation, # Inc. # # @@ -15,7 +15,6 @@ # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -as_nop=: if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh @@ -24,12 +23,13 @@ then : # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST -else $as_nop - case `(set -o) 2>/dev/null` in #( +else case e in #( + e) case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; +esac ;; esac fi @@ -101,7 +101,7 @@ IFS=$as_save_IFS ;; esac -# We did not find ourselves, most probably we were run as `sh COMMAND' +# We did not find ourselves, most probably we were run as 'sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 @@ -131,15 +131,14 @@ case $- in # (((( esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail -# out after a failed `exec'. +# out after a failed 'exec'. printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi # We don't want this to propagate to other subprocesses. { _as_can_reexec=; unset _as_can_reexec;} if test "x$CONFIG_SHELL" = x; then - as_bourne_compatible="as_nop=: -if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 + as_bourne_compatible="if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh NULLCMD=: @@ -147,12 +146,13 @@ then : # is contrary to our usage. Disable this feature. alias -g '\${1+\"\$@\"}'='\"\$@\"' setopt NO_GLOB_SUBST -else \$as_nop - case \`(set -o) 2>/dev/null\` in #( +else case e in #( + e) case \`(set -o) 2>/dev/null\` in #( *posix*) : set -o posix ;; #( *) : ;; +esac ;; esac fi " @@ -170,8 +170,9 @@ as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; } if ( set x; as_fn_ret_success y && test x = \"\$1\" ) then : -else \$as_nop - exitcode=1; echo positional parameters were not saved. +else case e in #( + e) exitcode=1; echo positional parameters were not saved. ;; +esac fi test x\$exitcode = x0 || exit 1 blah=\$(echo \$(echo blah)) @@ -193,14 +194,15 @@ test \$(( 1 + 1 )) = 2 || exit 1" if (eval "$as_required") 2>/dev/null then : as_have_required=yes -else $as_nop - as_have_required=no +else case e in #( + e) as_have_required=no ;; +esac fi if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null then : -else $as_nop - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +else case e in #( + e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR as_found=false for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH do @@ -233,12 +235,13 @@ IFS=$as_save_IFS if $as_found then : -else $as_nop - if { test -f "$SHELL" || test -f "$SHELL.exe"; } && +else case e in #( + e) if { test -f "$SHELL" || test -f "$SHELL.exe"; } && as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null then : CONFIG_SHELL=$SHELL as_have_required=yes -fi +fi ;; +esac fi @@ -260,7 +263,7 @@ case $- in # (((( esac exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"} # Admittedly, this is quite paranoid, since all the known shells bail -# out after a failed `exec'. +# out after a failed 'exec'. printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2 exit 255 fi @@ -279,7 +282,8 @@ $0: message. Then install a modern shell, or manually run $0: the script under such a shell if you do have one." fi exit 1 -fi +fi ;; +esac fi fi SHELL=${CONFIG_SHELL-/bin/sh} @@ -318,14 +322,6 @@ as_fn_exit () as_fn_set_status $1 exit $1 } # as_fn_exit -# as_fn_nop -# --------- -# Do nothing but, unlike ":", preserve the value of $?. -as_fn_nop () -{ - return $? -} -as_nop=as_fn_nop # as_fn_mkdir_p # ------------- @@ -394,11 +390,12 @@ then : { eval $1+=\$2 }' -else $as_nop - as_fn_append () +else case e in #( + e) as_fn_append () { eval $1=\$$1\$2 - } + } ;; +esac fi # as_fn_append # as_fn_arith ARG... @@ -412,21 +409,14 @@ then : { as_val=$(( $* )) }' -else $as_nop - as_fn_arith () +else case e in #( + e) as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` - } + } ;; +esac fi # as_fn_arith -# as_fn_nop -# --------- -# Do nothing but, unlike ":", preserve the value of $?. -as_fn_nop () -{ - return $? -} -as_nop=as_fn_nop # as_fn_error STATUS ERROR [LINENO LOG_FD] # ---------------------------------------- @@ -500,6 +490,8 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits /[$]LINENO/= ' <$as_myself | sed ' + t clear + :clear s/[$]LINENO.*/&-/ t lineno b @@ -548,7 +540,6 @@ esac as_echo='printf %s\n' as_echo_n='printf %s' - rm -f conf$$ conf$$.exe conf$$.file if test -d conf$$.dir; then rm -f conf$$.dir/conf$$.file @@ -560,9 +551,9 @@ if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -pR'. + # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable. + # In both cases, we have to default to 'cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then @@ -587,10 +578,12 @@ as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. -as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" +as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" +as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated # Sed expression to map a string onto a valid variable name. -as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" +as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g" +as_tr_sh="eval sed '$as_sed_sh'" # deprecated SHELL=${CONFIG_SHELL-/bin/sh} @@ -618,8 +611,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='libdnet' PACKAGE_TARNAME='libdnet' -PACKAGE_VERSION='1.17.0' -PACKAGE_STRING='libdnet 1.17.0' +PACKAGE_VERSION='1.18.0' +PACKAGE_STRING='libdnet 1.18.0' PACKAGE_BUGREPORT='' PACKAGE_URL='' @@ -659,7 +652,6 @@ ac_subst_vars='am__EXEEXT_FALSE am__EXEEXT_TRUE LTLIBOBJS LIBOBJS -CPP STRLCPY_HEADER HAVE_CHECK_FALSE HAVE_CHECK_TRUE @@ -830,8 +822,7 @@ PKG_CONFIG PKG_CONFIG_PATH PKG_CONFIG_LIBDIR CHECK_CFLAGS -CHECK_LIBS -CPP' +CHECK_LIBS' # Initialize some variables set by options. @@ -940,7 +931,7 @@ do ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid feature name: \`$ac_useropt'" + as_fn_error $? "invalid feature name: '$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in @@ -966,7 +957,7 @@ do ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid feature name: \`$ac_useropt'" + as_fn_error $? "invalid feature name: '$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in @@ -1179,7 +1170,7 @@ do ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid package name: \`$ac_useropt'" + as_fn_error $? "invalid package name: '$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in @@ -1195,7 +1186,7 @@ do ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'` # Reject names that are not valid shell variable names. expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null && - as_fn_error $? "invalid package name: \`$ac_useropt'" + as_fn_error $? "invalid package name: '$ac_useropt'" ac_useropt_orig=$ac_useropt ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'` case $ac_user_opts in @@ -1225,8 +1216,8 @@ do | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*) x_libraries=$ac_optarg ;; - -*) as_fn_error $? "unrecognized option: \`$ac_option' -Try \`$0 --help' for more information" + -*) as_fn_error $? "unrecognized option: '$ac_option' +Try '$0 --help' for more information" ;; *=*) @@ -1234,7 +1225,7 @@ Try \`$0 --help' for more information" # Reject names that are not valid shell variable names. case $ac_envvar in #( '' | [0-9]* | *[!_$as_cr_alnum]* ) - as_fn_error $? "invalid variable name: \`$ac_envvar'" ;; + as_fn_error $? "invalid variable name: '$ac_envvar'" ;; esac eval $ac_envvar=\$ac_optarg export $ac_envvar ;; @@ -1284,7 +1275,7 @@ do as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val" done -# There might be people who depend on the old broken behavior: `$host' +# There might be people who depend on the old broken behavior: '$host' # used to hold the argument of --host etc. # FIXME: To remove some day. build=$build_alias @@ -1352,7 +1343,7 @@ if test ! -r "$srcdir/$ac_unique_file"; then test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .." as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir" fi -ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work" +ac_msg="sources are in $srcdir, but 'cd $srcdir' does not work" ac_abs_confdir=`( cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg" pwd)` @@ -1380,7 +1371,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures libdnet 1.17.0 to adapt to many kinds of systems. +'configure' configures libdnet 1.18.0 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1394,11 +1385,11 @@ Configuration: --help=short display options specific to this package --help=recursive display the short help of all the included packages -V, --version display version information and exit - -q, --quiet, --silent do not print \`checking ...' messages + -q, --quiet, --silent do not print 'checking ...' messages --cache-file=FILE cache test results in FILE [disabled] - -C, --config-cache alias for \`--cache-file=config.cache' + -C, --config-cache alias for '--cache-file=config.cache' -n, --no-create do not create output files - --srcdir=DIR find the sources in DIR [configure dir or \`..'] + --srcdir=DIR find the sources in DIR [configure dir or '..'] Installation directories: --prefix=PREFIX install architecture-independent files in PREFIX @@ -1406,10 +1397,10 @@ Installation directories: --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX [PREFIX] -By default, \`make install' will install all the files in -\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify -an installation prefix other than \`$ac_default_prefix' using \`--prefix', -for instance \`--prefix=\$HOME'. +By default, 'make install' will install all the files in +'$ac_default_prefix/bin', '$ac_default_prefix/lib' etc. You can specify +an installation prefix other than '$ac_default_prefix' using '--prefix', +for instance '--prefix=\$HOME'. For better control, use the options below. @@ -1451,7 +1442,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of libdnet 1.17.0:";; + short | recursive ) echo "Configuration of libdnet 1.18.0:";; esac cat <<\_ACEOF @@ -1508,9 +1499,8 @@ Some influential environment variables: CHECK_CFLAGS C compiler flags for CHECK, overriding pkg-config CHECK_LIBS linker flags for CHECK, overriding pkg-config - CPP C preprocessor -Use these variables to override the choices made by `configure' or to help +Use these variables to override the choices made by 'configure' or to help it to find libraries and programs with nonstandard names/locations. Report bugs to the package provider. @@ -1577,10 +1567,10 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -libdnet configure 1.17.0 -generated by GNU Autoconf 2.71 +libdnet configure 1.18.0 +generated by GNU Autoconf 2.72 -Copyright (C) 2021 Free Software Foundation, Inc. +Copyright (C) 2023 Free Software Foundation, Inc. This configure script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it. _ACEOF @@ -1619,11 +1609,12 @@ printf "%s\n" "$ac_try_echo"; } >&5 } && test -s conftest.$ac_objext then : ac_retval=0 -else $as_nop - printf "%s\n" "$as_me: failed program was:" >&5 +else case e in #( + e) printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 - ac_retval=1 + ac_retval=1 ;; +esac fi eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno as_fn_set_status $ac_retval @@ -1661,11 +1652,12 @@ printf "%s\n" "$ac_try_echo"; } >&5 } then : ac_retval=0 -else $as_nop - printf "%s\n" "$as_me: failed program was:" >&5 +else case e in #( + e) printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 - ac_retval=1 + ac_retval=1 ;; +esac fi # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would @@ -1689,8 +1681,8 @@ printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 #include <$2> @@ -1698,10 +1690,12 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : eval "$3=yes" -else $as_nop - eval "$3=no" +else case e in #( + e) eval "$3=no" ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi eval ac_res=\$$3 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 @@ -1721,15 +1715,15 @@ printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Define $2 to an innocuous variant, in case declares $2. For example, HP-UX 11i declares gettimeofday. */ #define $2 innocuous_$2 /* System header to define __stub macros and hopefully few prototypes, - which can conflict with char $2 (); below. */ + which can conflict with char $2 (void); below. */ #include #undef $2 @@ -1740,7 +1734,7 @@ else $as_nop #ifdef __cplusplus extern "C" #endif -char $2 (); +char $2 (void); /* The GNU C library defines this for functions which it implements to always fail with ENOSYS. Some functions are actually named something starting with __ and the normal name is an alias. */ @@ -1759,11 +1753,13 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : eval "$3=yes" -else $as_nop - eval "$3=no" +else case e in #( + e) eval "$3=no" ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ - conftest$ac_exeext conftest.$ac_ext + conftest$ac_exeext conftest.$ac_ext ;; +esac fi eval ac_res=\$$3 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 @@ -1784,8 +1780,8 @@ printf %s "checking for $2... " >&6; } if eval test \${$3+y} then : printf %s "(cached) " >&6 -else $as_nop - eval "$3=no" +else case e in #( + e) eval "$3=no" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $4 @@ -1815,12 +1811,14 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : -else $as_nop - eval "$3=yes" +else case e in #( + e) eval "$3=yes" ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi eval ac_res=\$$3 { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5 @@ -1829,44 +1827,6 @@ printf "%s\n" "$ac_res" >&6; } } # ac_fn_c_check_type -# ac_fn_c_try_cpp LINENO -# ---------------------- -# Try to preprocess conftest.$ac_ext, and return whether this succeeded. -ac_fn_c_try_cpp () -{ - as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack - if { { ac_try="$ac_cpp conftest.$ac_ext" -case "(($ac_try" in - *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; - *) ac_try_echo=$ac_try;; -esac -eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\"" -printf "%s\n" "$ac_try_echo"; } >&5 - (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err - ac_status=$? - if test -s conftest.err; then - grep -v '^ *+' conftest.err >conftest.er1 - cat conftest.er1 >&5 - mv -f conftest.er1 conftest.err - fi - printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 - test $ac_status = 0; } > conftest.i && { - test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || - test ! -s conftest.err - } -then : - ac_retval=0 -else $as_nop - printf "%s\n" "$as_me: failed program was:" >&5 -sed 's/^/| /' conftest.$ac_ext >&5 - - ac_retval=1 -fi - eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno - as_fn_set_status $ac_retval - -} # ac_fn_c_try_cpp - # ac_fn_c_try_run LINENO # ---------------------- # Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that @@ -1897,12 +1857,13 @@ printf "%s\n" "$ac_try_echo"; } >&5 test $ac_status = 0; }; } then : ac_retval=0 -else $as_nop - printf "%s\n" "$as_me: program exited with status $ac_status" >&5 +else case e in #( + e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5 printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 - ac_retval=$ac_status + ac_retval=$ac_status ;; +esac fi rm -rf conftest.dSYM conftest_ipa8_conftest.oo eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno @@ -1933,8 +1894,8 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by libdnet $as_me 1.17.0, which was -generated by GNU Autoconf 2.71. Invocation command line was +It was created by libdnet $as_me 1.18.0, which was +generated by GNU Autoconf 2.72. Invocation command line was $ $0$ac_configure_args_raw @@ -2180,10 +2141,10 @@ esac printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;} sed 's/^/| /' "$ac_site_file" >&5 . "$ac_site_file" \ - || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} + || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "failed to load site script $ac_site_file -See \`config.log' for more details" "$LINENO" 5; } +See 'config.log' for more details" "$LINENO" 5; } fi done @@ -2219,9 +2180,7 @@ struct stat; /* Most of the following tests are stolen from RCS 5.7 src/conf.sh. */ struct buf { int x; }; struct buf * (*rcsopen) (struct buf *, struct stat *, int); -static char *e (p, i) - char **p; - int i; +static char *e (char **p, int i) { return p[i]; } @@ -2235,6 +2194,21 @@ static char *f (char * (*g) (char **, int), char **p, ...) return s; } +/* C89 style stringification. */ +#define noexpand_stringify(a) #a +const char *stringified = noexpand_stringify(arbitrary+token=sequence); + +/* C89 style token pasting. Exercises some of the corner cases that + e.g. old MSVC gets wrong, but not very hard. */ +#define noexpand_concat(a,b) a##b +#define expand_concat(a,b) noexpand_concat(a,b) +extern int vA; +extern int vbee; +#define aye A +#define bee B +int *pvA = &expand_concat(v,aye); +int *pvbee = &noexpand_concat(v,bee); + /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has function prototypes and stuff, but not \xHH hex character constants. These do not provoke an error unfortunately, instead are silently treated @@ -2262,16 +2236,19 @@ ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]); # Test code for whether the C compiler supports C99 (global declarations) ac_c_conftest_c99_globals=' -// Does the compiler advertise C99 conformance? +/* Does the compiler advertise C99 conformance? */ #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L # error "Compiler does not advertise C99 conformance" #endif +// See if C++-style comments work. + #include extern int puts (const char *); extern int printf (const char *, ...); extern int dprintf (int, const char *, ...); extern void *malloc (size_t); +extern void free (void *); // Check varargs macros. These examples are taken from C99 6.10.3.5. // dprintf is used instead of fprintf to avoid needing to declare @@ -2321,7 +2298,6 @@ typedef const char *ccp; static inline int test_restrict (ccp restrict text) { - // See if C++-style comments work. // Iterate through items via the restricted pointer. // Also check for declarations in for loops. for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i) @@ -2387,6 +2363,8 @@ ac_c_conftest_c99_main=' ia->datasize = 10; for (int i = 0; i < ia->datasize; ++i) ia->data[i] = i * 1.234; + // Work around memory leak warnings. + free (ia); // Check named initializers. struct named_init ni = { @@ -2408,7 +2386,7 @@ ac_c_conftest_c99_main=' # Test code for whether the C compiler supports C11 (global declarations) ac_c_conftest_c11_globals=' -// Does the compiler advertise C11 conformance? +/* Does the compiler advertise C11 conformance? */ #if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L # error "Compiler does not advertise C11 conformance" #endif @@ -2600,8 +2578,9 @@ IFS=$as_save_IFS if $as_found then : -else $as_nop - as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 +else case e in #( + e) as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 ;; +esac fi @@ -2629,12 +2608,12 @@ for ac_var in $ac_precious_vars; do eval ac_new_val=\$ac_env_${ac_var}_value case $ac_old_set,$ac_new_set in set,) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5 -printf "%s\n" "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5 +printf "%s\n" "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;} ac_cache_corrupted=: ;; ,set) - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5 -printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5 +printf "%s\n" "$as_me: error: '$ac_var' was not set in the previous run" >&2;} ac_cache_corrupted=: ;; ,);; *) @@ -2643,18 +2622,18 @@ printf "%s\n" "$as_me: error: \`$ac_var' was not set in the previous run" >&2;} ac_old_val_w=`echo x $ac_old_val` ac_new_val_w=`echo x $ac_new_val` if test "$ac_old_val_w" != "$ac_new_val_w"; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5 -printf "%s\n" "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5 +printf "%s\n" "$as_me: error: '$ac_var' has changed since the previous run:" >&2;} ac_cache_corrupted=: else - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5 -printf "%s\n" "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5 +printf "%s\n" "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;} eval $ac_var=\$ac_old_val fi - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: \`$ac_old_val'" >&5 -printf "%s\n" "$as_me: former value: \`$ac_old_val'" >&2;} - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: \`$ac_new_val'" >&5 -printf "%s\n" "$as_me: current value: \`$ac_new_val'" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: former value: '$ac_old_val'" >&5 +printf "%s\n" "$as_me: former value: '$ac_old_val'" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: current value: '$ac_new_val'" >&5 +printf "%s\n" "$as_me: current value: '$ac_new_val'" >&2;} fi;; esac # Pass precious variables to config.status. @@ -2670,11 +2649,11 @@ printf "%s\n" "$as_me: current value: \`$ac_new_val'" >&2;} fi done if $ac_cache_corrupted; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5 printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;} - as_fn_error $? "run \`${MAKE-make} distclean' and/or \`rm $cache_file' + as_fn_error $? "run '${MAKE-make} distclean' and/or 'rm $cache_file' and start over" "$LINENO" 5 fi ## -------------------- ## @@ -2716,8 +2695,8 @@ if test -z "$INSTALL"; then if test ${ac_cv_path_install+y} then : printf %s "(cached) " >&6 -else $as_nop - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +else case e in #( + e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH do IFS=$as_save_IFS @@ -2771,7 +2750,8 @@ esac IFS=$as_save_IFS rm -rf conftest.one conftest.two conftest.dir - + ;; +esac fi if test ${ac_cv_path_install+y}; then INSTALL=$ac_cv_path_install @@ -2867,7 +2847,7 @@ test "$program_prefix" != NONE && test "$program_suffix" != NONE && program_transform_name="s&\$&$program_suffix&;$program_transform_name" # Double any \ or $. -# By default was `s,x,x', remove it if useless. +# By default was 's,x,x', remove it if useless. ac_script='s/[\\$]/&&/g;s/;s,x,x,$//' program_transform_name=`printf "%s\n" "$program_transform_name" | sed "$ac_script"` @@ -2910,8 +2890,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_STRIP+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$STRIP"; then +else case e in #( + e) if test -n "$STRIP"; then ac_cv_prog_STRIP="$STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -2933,7 +2913,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then @@ -2955,8 +2936,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_STRIP+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_STRIP"; then +else case e in #( + e) if test -n "$ac_ct_STRIP"; then ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -2978,7 +2959,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then @@ -3014,8 +2996,8 @@ if test -z "$MKDIR_P"; then if test ${ac_cv_path_mkdir+y} then : printf %s "(cached) " >&6 -else $as_nop - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +else case e in #( + e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin do IFS=$as_save_IFS @@ -3029,7 +3011,7 @@ do as_fn_executable_p "$as_dir$ac_prog$ac_exec_ext" || continue case `"$as_dir$ac_prog$ac_exec_ext" --version 2>&1` in #( 'mkdir ('*'coreutils) '* | \ - 'BusyBox '* | \ + *'BusyBox '* | \ 'mkdir (fileutils) '4.1*) ac_cv_path_mkdir=$as_dir$ac_prog$ac_exec_ext break 3;; @@ -3038,18 +3020,17 @@ do done done IFS=$as_save_IFS - + ;; +esac fi test -d ./--version && rmdir ./--version if test ${ac_cv_path_mkdir+y}; then MKDIR_P="$ac_cv_path_mkdir -p" else - # As a last resort, use the slow shell script. Don't cache a - # value for MKDIR_P within a source directory, because that will - # break other packages using the cache if that directory is - # removed, or if the value is a relative name. - MKDIR_P="$ac_install_sh -d" + # As a last resort, use plain mkdir -p, + # in the hope it doesn't have the bugs of ancient mkdir. + MKDIR_P='mkdir -p' fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5 @@ -3064,8 +3045,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AWK+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$AWK"; then +else case e in #( + e) if test -n "$AWK"; then ac_cv_prog_AWK="$AWK" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3087,7 +3068,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi AWK=$ac_cv_prog_AWK if test -n "$AWK"; then @@ -3109,8 +3091,8 @@ ac_make=`printf "%s\n" "$2" | sed 's/+/p/g; s/[^a-zA-Z0-9_]/_/g'` if eval test \${ac_cv_prog_make_${ac_make}_set+y} then : printf %s "(cached) " >&6 -else $as_nop - cat >conftest.make <<\_ACEOF +else case e in #( + e) cat >conftest.make <<\_ACEOF SHELL = /bin/sh all: @echo '@@@%%%=$(MAKE)=@@@%%%' @@ -3122,7 +3104,8 @@ case `${MAKE-make} -f conftest.make 2>/dev/null` in *) eval ac_cv_prog_make_${ac_make}_set=no;; esac -rm -f conftest.make +rm -f conftest.make ;; +esac fi if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 @@ -3160,8 +3143,8 @@ printf %s "checking whether $am_make supports nested variables... " >&6; } if test ${am_cv_make_support_nested_variables+y} then : printf %s "(cached) " >&6 -else $as_nop - if printf "%s\n" 'TRUE=$(BAR$(V)) +else case e in #( + e) if printf "%s\n" 'TRUE=$(BAR$(V)) BAR0=false BAR1=true V=1 @@ -3171,7 +3154,8 @@ am__doit: am_cv_make_support_nested_variables=yes else am_cv_make_support_nested_variables=no -fi +fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5 printf "%s\n" "$am_cv_make_support_nested_variables" >&6; } @@ -3206,7 +3190,7 @@ fi # Define the identity of the package. PACKAGE='libdnet' - VERSION='1.17.0' + VERSION='1.18.0' printf "%s\n" "#define PACKAGE \"$PACKAGE\"" >>confdefs.h @@ -3350,15 +3334,16 @@ printf %s "checking build system type... " >&6; } if test ${ac_cv_build+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_build_alias=$build_alias +else case e in #( + e) ac_build_alias=$build_alias test "x$ac_build_alias" = x && ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"` test "x$ac_build_alias" = x && as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5 ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` || as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5 - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5 printf "%s\n" "$ac_cv_build" >&6; } @@ -3385,14 +3370,15 @@ printf %s "checking host system type... " >&6; } if test ${ac_cv_host+y} then : printf %s "(cached) " >&6 -else $as_nop - if test "x$host_alias" = x; then +else case e in #( + e) if test "x$host_alias" = x; then ac_cv_host=$ac_cv_build else ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` || as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5 fi - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5 printf "%s\n" "$ac_cv_host" >&6; } @@ -3569,8 +3555,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3592,7 +3578,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -3614,8 +3601,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_CC"; then +else case e in #( + e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3637,7 +3624,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then @@ -3672,8 +3660,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3695,7 +3683,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -3717,8 +3706,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no @@ -3757,7 +3746,8 @@ if test $ac_prog_rejected = yes; then ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@" fi fi -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -3781,8 +3771,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3804,7 +3794,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -3830,8 +3821,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_CC"; then +else case e in #( + e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3853,7 +3844,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then @@ -3891,8 +3883,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3914,7 +3906,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -3936,8 +3929,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_CC"; then +else case e in #( + e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -3959,7 +3952,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then @@ -3988,10 +3982,10 @@ fi fi -test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} +test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH -See \`config.log' for more details" "$LINENO" 5; } +See 'config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 @@ -4063,8 +4057,8 @@ printf "%s\n" "$ac_try_echo"; } >&5 printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : - # Autoconf-2.13 could set the ac_cv_exeext variable to `no'. -# So ignore a value of `no', otherwise this would lead to `EXEEXT = no' + # Autoconf-2.13 could set the ac_cv_exeext variable to 'no'. +# So ignore a value of 'no', otherwise this would lead to 'EXEEXT = no' # in a Makefile. We should not override ac_cv_exeext if it was cached, # so that the user can short-circuit this test for compilers unknown to # Autoconf. @@ -4084,7 +4078,7 @@ do ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'` fi # We set ac_cv_exeext here because the later test for it is not - # safe: cross compilers may not add the suffix if given an `-o' + # safe: cross compilers may not add the suffix if given an '-o' # argument, so we may need to know it at that point already. # Even if this section looks crufty: it has the advantage of # actually working. @@ -4095,8 +4089,9 @@ do done test "$ac_cv_exeext" = no && ac_cv_exeext= -else $as_nop - ac_file='' +else case e in #( + e) ac_file='' ;; +esac fi if test -z "$ac_file" then : @@ -4105,13 +4100,14 @@ printf "%s\n" "no" >&6; } printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 -{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} +{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error 77 "C compiler cannot create executables -See \`config.log' for more details" "$LINENO" 5; } -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } +See 'config.log' for more details" "$LINENO" 5; } +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 +printf "%s\n" "yes" >&6; } ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5 printf %s "checking for C compiler default output file name... " >&6; } @@ -4135,10 +4131,10 @@ printf "%s\n" "$ac_try_echo"; } >&5 printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5 test $ac_status = 0; } then : - # If both `conftest.exe' and `conftest' are `present' (well, observable) -# catch `conftest.exe'. For instance with Cygwin, `ls conftest' will -# work properly (i.e., refer to `conftest.exe'), while it won't with -# `rm'. + # If both 'conftest.exe' and 'conftest' are 'present' (well, observable) +# catch 'conftest.exe'. For instance with Cygwin, 'ls conftest' will +# work properly (i.e., refer to 'conftest.exe'), while it won't with +# 'rm'. for ac_file in conftest.exe conftest conftest.*; do test -f "$ac_file" || continue case $ac_file in @@ -4148,11 +4144,12 @@ for ac_file in conftest.exe conftest conftest.*; do * ) break;; esac done -else $as_nop - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} +else case e in #( + e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of executables: cannot compile and link -See \`config.log' for more details" "$LINENO" 5; } +See 'config.log' for more details" "$LINENO" 5; } ;; +esac fi rm -f conftest conftest$ac_cv_exeext { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5 @@ -4168,6 +4165,8 @@ int main (void) { FILE *f = fopen ("conftest.out", "w"); + if (!f) + return 1; return ferror (f) || fclose (f) != 0; ; @@ -4207,26 +4206,27 @@ printf "%s\n" "$ac_try_echo"; } >&5 if test "$cross_compiling" = maybe; then cross_compiling=yes else - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error 77 "cannot run C compiled programs. -If you meant to cross compile, use \`--host'. -See \`config.log' for more details" "$LINENO" 5; } +If you meant to cross compile, use '--host'. +See 'config.log' for more details" "$LINENO" 5; } fi fi fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5 printf "%s\n" "$cross_compiling" >&6; } -rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out +rm -f conftest.$ac_ext conftest$ac_cv_exeext \ + conftest.o conftest.obj conftest.out ac_clean_files=$ac_clean_files_save { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5 printf %s "checking for suffix of object files... " >&6; } if test ${ac_cv_objext+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int @@ -4258,16 +4258,18 @@ then : break;; esac done -else $as_nop - printf "%s\n" "$as_me: failed program was:" >&5 +else case e in #( + e) printf "%s\n" "$as_me: failed program was:" >&5 sed 's/^/| /' conftest.$ac_ext >&5 -{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} +{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "cannot compute suffix of object files: cannot compile -See \`config.log' for more details" "$LINENO" 5; } +See 'config.log' for more details" "$LINENO" 5; } ;; +esac fi -rm -f conftest.$ac_cv_objext conftest.$ac_ext +rm -f conftest.$ac_cv_objext conftest.$ac_ext ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5 printf "%s\n" "$ac_cv_objext" >&6; } @@ -4278,8 +4280,8 @@ printf %s "checking whether the compiler supports GNU C... " >&6; } if test ${ac_cv_c_compiler_gnu+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int @@ -4296,12 +4298,14 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_compiler_gnu=yes -else $as_nop - ac_compiler_gnu=no +else case e in #( + e) ac_compiler_gnu=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; } @@ -4319,8 +4323,8 @@ printf %s "checking whether $CC accepts -g... " >&6; } if test ${ac_cv_prog_cc_g+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_save_c_werror_flag=$ac_c_werror_flag +else case e in #( + e) ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" @@ -4338,8 +4342,8 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_g=yes -else $as_nop - CFLAGS="" +else case e in #( + e) CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -4354,8 +4358,8 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : -else $as_nop - ac_c_werror_flag=$ac_save_c_werror_flag +else case e in #( + e) ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -4372,12 +4376,15 @@ if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_g=yes fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext - ac_c_werror_flag=$ac_save_c_werror_flag + ac_c_werror_flag=$ac_save_c_werror_flag ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 printf "%s\n" "$ac_cv_prog_cc_g" >&6; } @@ -4404,8 +4411,8 @@ printf %s "checking for $CC option to enable C11 features... " >&6; } if test ${ac_cv_prog_cc_c11+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_cv_prog_cc_c11=no +else case e in #( + e) ac_cv_prog_cc_c11=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -4422,25 +4429,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c11" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC +CC=$ac_save_CC ;; +esac fi if test "x$ac_cv_prog_cc_c11" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } -else $as_nop - if test "x$ac_cv_prog_cc_c11" = x +else case e in #( + e) if test "x$ac_cv_prog_cc_c11" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 printf "%s\n" "$ac_cv_prog_cc_c11" >&6; } - CC="$CC $ac_cv_prog_cc_c11" + CC="$CC $ac_cv_prog_cc_c11" ;; +esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11 - ac_prog_cc_stdc=c11 + ac_prog_cc_stdc=c11 ;; +esac fi fi if test x$ac_prog_cc_stdc = xno @@ -4450,8 +4460,8 @@ printf %s "checking for $CC option to enable C99 features... " >&6; } if test ${ac_cv_prog_cc_c99+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_cv_prog_cc_c99=no +else case e in #( + e) ac_cv_prog_cc_c99=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -4468,25 +4478,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c99" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC +CC=$ac_save_CC ;; +esac fi if test "x$ac_cv_prog_cc_c99" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } -else $as_nop - if test "x$ac_cv_prog_cc_c99" = x +else case e in #( + e) if test "x$ac_cv_prog_cc_c99" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 printf "%s\n" "$ac_cv_prog_cc_c99" >&6; } - CC="$CC $ac_cv_prog_cc_c99" + CC="$CC $ac_cv_prog_cc_c99" ;; +esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 - ac_prog_cc_stdc=c99 + ac_prog_cc_stdc=c99 ;; +esac fi fi if test x$ac_prog_cc_stdc = xno @@ -4496,8 +4509,8 @@ printf %s "checking for $CC option to enable C89 features... " >&6; } if test ${ac_cv_prog_cc_c89+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_cv_prog_cc_c89=no +else case e in #( + e) ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -4514,25 +4527,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC +CC=$ac_save_CC ;; +esac fi if test "x$ac_cv_prog_cc_c89" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } -else $as_nop - if test "x$ac_cv_prog_cc_c89" = x +else case e in #( + e) if test "x$ac_cv_prog_cc_c89" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 printf "%s\n" "$ac_cv_prog_cc_c89" >&6; } - CC="$CC $ac_cv_prog_cc_c89" + CC="$CC $ac_cv_prog_cc_c89" ;; +esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 - ac_prog_cc_stdc=c89 + ac_prog_cc_stdc=c89 ;; +esac fi fi @@ -4553,8 +4569,8 @@ printf %s "checking whether $CC understands -c and -o together... " >&6; } if test ${am_cv_prog_cc_c_o+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int @@ -4584,7 +4600,8 @@ _ACEOF fi done rm -f core conftest* - unset am_i + unset am_i ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 printf "%s\n" "$am_cv_prog_cc_c_o" >&6; } @@ -4610,8 +4627,8 @@ printf %s "checking dependency style of $depcc... " >&6; } if test ${am_cv_CC_dependencies_compiler_type+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then +else case e in #( + e) if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up @@ -4715,7 +4732,8 @@ else $as_nop else am_cv_CC_dependencies_compiler_type=none fi - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; } @@ -4737,8 +4755,8 @@ printf %s "checking for a sed that does not truncate output... " >&6; } if test ${ac_cv_path_SED+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ +else case e in #( + e) ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ for ac_i in 1 2 3 4 5 6 7; do ac_script="$ac_script$as_nl$ac_script" done @@ -4763,9 +4781,10 @@ do as_fn_executable_p "$ac_path_SED" || continue # Check for GNU ac_path_SED and select it if it is found. # Check for GNU $ac_path_SED -case `"$ac_path_SED" --version 2>&1` in +case `"$ac_path_SED" --version 2>&1` in #( *GNU*) ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;; +#( *) ac_count=0 printf %s 0123456789 >"conftest.in" @@ -4800,7 +4819,8 @@ IFS=$as_save_IFS else ac_cv_path_SED=$SED fi - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5 printf "%s\n" "$ac_cv_path_SED" >&6; } @@ -4825,8 +4845,8 @@ printf %s "checking for grep that handles long lines and -e... " >&6; } if test ${ac_cv_path_GREP+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -z "$GREP"; then +else case e in #( + e) if test -z "$GREP"; then ac_path_GREP_found=false # Loop through the user's path and test for each of PROGNAME-LIST as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -4845,9 +4865,10 @@ do as_fn_executable_p "$ac_path_GREP" || continue # Check for GNU ac_path_GREP and select it if it is found. # Check for GNU $ac_path_GREP -case `"$ac_path_GREP" --version 2>&1` in +case `"$ac_path_GREP" --version 2>&1` in #( *GNU*) ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;; +#( *) ac_count=0 printf %s 0123456789 >"conftest.in" @@ -4882,7 +4903,8 @@ IFS=$as_save_IFS else ac_cv_path_GREP=$GREP fi - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5 printf "%s\n" "$ac_cv_path_GREP" >&6; } @@ -4894,8 +4916,8 @@ printf %s "checking for egrep... " >&6; } if test ${ac_cv_path_EGREP+y} then : printf %s "(cached) " >&6 -else $as_nop - if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 +else case e in #( + e) if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 then ac_cv_path_EGREP="$GREP -E" else if test -z "$EGREP"; then @@ -4917,9 +4939,10 @@ do as_fn_executable_p "$ac_path_EGREP" || continue # Check for GNU ac_path_EGREP and select it if it is found. # Check for GNU $ac_path_EGREP -case `"$ac_path_EGREP" --version 2>&1` in +case `"$ac_path_EGREP" --version 2>&1` in #( *GNU*) ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; +#( *) ac_count=0 printf %s 0123456789 >"conftest.in" @@ -4955,20 +4978,23 @@ else ac_cv_path_EGREP=$EGREP fi - fi + fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 printf "%s\n" "$ac_cv_path_EGREP" >&6; } EGREP="$ac_cv_path_EGREP" + EGREP_TRADITIONAL=$EGREP + ac_cv_path_EGREP_TRADITIONAL=$EGREP { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5 printf %s "checking for fgrep... " >&6; } if test ${ac_cv_path_FGREP+y} then : printf %s "(cached) " >&6 -else $as_nop - if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 +else case e in #( + e) if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1 then ac_cv_path_FGREP="$GREP -F" else if test -z "$FGREP"; then @@ -4990,9 +5016,10 @@ do as_fn_executable_p "$ac_path_FGREP" || continue # Check for GNU ac_path_FGREP and select it if it is found. # Check for GNU $ac_path_FGREP -case `"$ac_path_FGREP" --version 2>&1` in +case `"$ac_path_FGREP" --version 2>&1` in #( *GNU*) ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;; +#( *) ac_count=0 printf %s 0123456789 >"conftest.in" @@ -5028,7 +5055,8 @@ else ac_cv_path_FGREP=$FGREP fi - fi + fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5 printf "%s\n" "$ac_cv_path_FGREP" >&6; } @@ -5059,8 +5087,9 @@ test -z "$GREP" && GREP=grep if test ${with_gnu_ld+y} then : withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes -else $as_nop - with_gnu_ld=no +else case e in #( + e) with_gnu_ld=no ;; +esac fi ac_prog=ld @@ -5105,8 +5134,8 @@ fi if test ${lt_cv_path_LD+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -z "$LD"; then +else case e in #( + e) if test -z "$LD"; then lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR for ac_dir in $PATH; do IFS=$lt_save_ifs @@ -5129,7 +5158,8 @@ else $as_nop IFS=$lt_save_ifs else lt_cv_path_LD=$LD # Let the user override the test with a path. -fi +fi ;; +esac fi LD=$lt_cv_path_LD @@ -5146,8 +5176,8 @@ printf %s "checking if the linker ($LD) is GNU ld... " >&6; } if test ${lt_cv_prog_gnu_ld+y} then : printf %s "(cached) " >&6 -else $as_nop - # I'd rather use --version here, but apparently some GNU lds only accept -v. +else case e in #( + e) # I'd rather use --version here, but apparently some GNU lds only accept -v. case `$LD -v 2>&1 &1 &5 @@ -5174,8 +5205,8 @@ printf %s "checking for BSD- or MS-compatible name lister (nm)... " >&6; } if test ${lt_cv_path_NM+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$NM"; then +else case e in #( + e) if test -n "$NM"; then # Let the user override the test. lt_cv_path_NM=$NM else @@ -5222,7 +5253,8 @@ else IFS=$lt_save_ifs done : ${lt_cv_path_NM=no} -fi +fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5 printf "%s\n" "$lt_cv_path_NM" >&6; } @@ -5243,8 +5275,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DUMPBIN+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$DUMPBIN"; then +else case e in #( + e) if test -n "$DUMPBIN"; then ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -5266,7 +5298,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi DUMPBIN=$ac_cv_prog_DUMPBIN if test -n "$DUMPBIN"; then @@ -5292,8 +5325,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DUMPBIN+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_DUMPBIN"; then +else case e in #( + e) if test -n "$ac_ct_DUMPBIN"; then ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -5315,7 +5348,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN if test -n "$ac_ct_DUMPBIN"; then @@ -5369,8 +5403,8 @@ printf %s "checking the name lister ($NM) interface... " >&6; } if test ${lt_cv_nm_interface+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_nm_interface="BSD nm" +else case e in #( + e) lt_cv_nm_interface="BSD nm" echo "int some_variable = 0;" > conftest.$ac_ext (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5) (eval "$ac_compile" 2>conftest.err) @@ -5383,7 +5417,8 @@ else $as_nop if $GREP 'External.*some_variable' conftest.out > /dev/null; then lt_cv_nm_interface="MS dumpbin" fi - rm -f conftest* + rm -f conftest* ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5 printf "%s\n" "$lt_cv_nm_interface" >&6; } @@ -5405,8 +5440,8 @@ printf %s "checking the maximum length of command line arguments... " >&6; } if test ${lt_cv_sys_max_cmd_len+y} then : printf %s "(cached) " >&6 -else $as_nop - i=0 +else case e in #( + e) i=0 teststring=ABCD case $build_os in @@ -5528,7 +5563,8 @@ else $as_nop fi ;; esac - + ;; +esac fi if test -n "$lt_cv_sys_max_cmd_len"; then @@ -5585,8 +5621,8 @@ printf %s "checking how to convert $build file names to $host format... " >&6; } if test ${lt_cv_to_host_file_cmd+y} then : printf %s "(cached) " >&6 -else $as_nop - case $host in +else case e in #( + e) case $host in *-*-mingw* ) case $build in *-*-mingw* ) # actually msys @@ -5617,7 +5653,8 @@ else $as_nop lt_cv_to_host_file_cmd=func_convert_file_noop ;; esac - + ;; +esac fi to_host_file_cmd=$lt_cv_to_host_file_cmd @@ -5633,8 +5670,8 @@ printf %s "checking how to convert $build file names to toolchain format... " >& if test ${lt_cv_to_tool_file_cmd+y} then : printf %s "(cached) " >&6 -else $as_nop - #assume ordinary cross tools, or native build. +else case e in #( + e) #assume ordinary cross tools, or native build. lt_cv_to_tool_file_cmd=func_convert_file_noop case $host in *-*-mingw* ) @@ -5645,7 +5682,8 @@ case $host in esac ;; esac - + ;; +esac fi to_tool_file_cmd=$lt_cv_to_tool_file_cmd @@ -5661,8 +5699,9 @@ printf %s "checking for $LD option to reload object files... " >&6; } if test ${lt_cv_ld_reload_flag+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_ld_reload_flag='-r' +else case e in #( + e) lt_cv_ld_reload_flag='-r' ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5 printf "%s\n" "$lt_cv_ld_reload_flag" >&6; } @@ -5703,8 +5742,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_FILECMD+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$FILECMD"; then +else case e in #( + e) if test -n "$FILECMD"; then ac_cv_prog_FILECMD="$FILECMD" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -5726,7 +5765,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi FILECMD=$ac_cv_prog_FILECMD if test -n "$FILECMD"; then @@ -5748,8 +5788,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_FILECMD+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_FILECMD"; then +else case e in #( + e) if test -n "$ac_ct_FILECMD"; then ac_cv_prog_ac_ct_FILECMD="$ac_ct_FILECMD" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -5771,7 +5811,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_FILECMD=$ac_cv_prog_ac_ct_FILECMD if test -n "$ac_ct_FILECMD"; then @@ -5811,8 +5852,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OBJDUMP+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$OBJDUMP"; then +else case e in #( + e) if test -n "$OBJDUMP"; then ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -5834,7 +5875,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi OBJDUMP=$ac_cv_prog_OBJDUMP if test -n "$OBJDUMP"; then @@ -5856,8 +5898,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OBJDUMP+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_OBJDUMP"; then +else case e in #( + e) if test -n "$ac_ct_OBJDUMP"; then ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -5879,7 +5921,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP if test -n "$ac_ct_OBJDUMP"; then @@ -5920,8 +5963,8 @@ printf %s "checking how to recognize dependent libraries... " >&6; } if test ${lt_cv_deplibs_check_method+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_file_magic_cmd='$MAGIC_CMD' +else case e in #( + e) lt_cv_file_magic_cmd='$MAGIC_CMD' lt_cv_file_magic_test_file= lt_cv_deplibs_check_method='unknown' # Need to set the preceding variable on all platforms that support @@ -6114,7 +6157,8 @@ os2*) lt_cv_deplibs_check_method=pass_all ;; esac - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5 printf "%s\n" "$lt_cv_deplibs_check_method" >&6; } @@ -6166,8 +6210,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DLLTOOL+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$DLLTOOL"; then +else case e in #( + e) if test -n "$DLLTOOL"; then ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -6189,7 +6233,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi DLLTOOL=$ac_cv_prog_DLLTOOL if test -n "$DLLTOOL"; then @@ -6211,8 +6256,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DLLTOOL+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_DLLTOOL"; then +else case e in #( + e) if test -n "$ac_ct_DLLTOOL"; then ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -6234,7 +6279,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL if test -n "$ac_ct_DLLTOOL"; then @@ -6276,8 +6322,8 @@ printf %s "checking how to associate runtime and link libraries... " >&6; } if test ${lt_cv_sharedlib_from_linklib_cmd+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_sharedlib_from_linklib_cmd='unknown' +else case e in #( + e) lt_cv_sharedlib_from_linklib_cmd='unknown' case $host_os in cygwin* | mingw* | pw32* | cegcc*) @@ -6297,7 +6343,8 @@ cygwin* | mingw* | pw32* | cegcc*) lt_cv_sharedlib_from_linklib_cmd=$ECHO ;; esac - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5 printf "%s\n" "$lt_cv_sharedlib_from_linklib_cmd" >&6; } @@ -6321,8 +6368,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_AR+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$AR"; then +else case e in #( + e) if test -n "$AR"; then ac_cv_prog_AR="$AR" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -6344,7 +6391,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi AR=$ac_cv_prog_AR if test -n "$AR"; then @@ -6370,8 +6418,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_AR+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_AR"; then +else case e in #( + e) if test -n "$ac_ct_AR"; then ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -6393,7 +6441,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_AR=$ac_cv_prog_ac_ct_AR if test -n "$ac_ct_AR"; then @@ -6455,8 +6504,8 @@ printf %s "checking for archiver @FILE support... " >&6; } if test ${lt_cv_ar_at_file+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_ar_at_file=no +else case e in #( + e) lt_cv_ar_at_file=no cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -6493,7 +6542,8 @@ then : fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5 printf "%s\n" "$lt_cv_ar_at_file" >&6; } @@ -6518,8 +6568,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_STRIP+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$STRIP"; then +else case e in #( + e) if test -n "$STRIP"; then ac_cv_prog_STRIP="$STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -6541,7 +6591,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi STRIP=$ac_cv_prog_STRIP if test -n "$STRIP"; then @@ -6563,8 +6614,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_STRIP+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_STRIP"; then +else case e in #( + e) if test -n "$ac_ct_STRIP"; then ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -6586,7 +6637,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP if test -n "$ac_ct_STRIP"; then @@ -6627,8 +6679,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_RANLIB+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$RANLIB"; then +else case e in #( + e) if test -n "$RANLIB"; then ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -6650,7 +6702,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi RANLIB=$ac_cv_prog_RANLIB if test -n "$RANLIB"; then @@ -6672,8 +6725,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_RANLIB+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_RANLIB"; then +else case e in #( + e) if test -n "$ac_ct_RANLIB"; then ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -6695,7 +6748,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB if test -n "$ac_ct_RANLIB"; then @@ -6806,8 +6860,8 @@ printf %s "checking command to parse $NM output from $compiler object... " >&6; if test ${lt_cv_sys_global_symbol_pipe+y} then : printf %s "(cached) " >&6 -else $as_nop - +else case e in #( + e) # These are sane defaults that work on at least a few old systems. # [They come from Ultrix. What could be older than Ultrix?!! ;)] @@ -7062,7 +7116,8 @@ _LT_EOF lt_cv_sys_global_symbol_pipe= fi done - + ;; +esac fi if test -z "$lt_cv_sys_global_symbol_pipe"; then @@ -7126,8 +7181,9 @@ printf %s "checking for sysroot... " >&6; } if test ${with_sysroot+y} then : withval=$with_sysroot; -else $as_nop - with_sysroot=no +else case e in #( + e) with_sysroot=no ;; +esac fi @@ -7162,8 +7218,8 @@ printf %s "checking for a working dd... " >&6; } if test ${ac_cv_path_lt_DD+y} then : printf %s "(cached) " >&6 -else $as_nop - printf 0123456789abcdef0123456789abcdef >conftest.i +else case e in #( + e) printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i : ${lt_DD:=$DD} if test -z "$lt_DD"; then @@ -7199,7 +7255,8 @@ else ac_cv_path_lt_DD=$lt_DD fi -rm -f conftest.i conftest2.i conftest.out +rm -f conftest.i conftest2.i conftest.out ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5 printf "%s\n" "$ac_cv_path_lt_DD" >&6; } @@ -7210,8 +7267,8 @@ printf %s "checking how to truncate binary pipes... " >&6; } if test ${lt_cv_truncate_bin+y} then : printf %s "(cached) " >&6 -else $as_nop - printf 0123456789abcdef0123456789abcdef >conftest.i +else case e in #( + e) printf 0123456789abcdef0123456789abcdef >conftest.i cat conftest.i conftest.i >conftest2.i lt_cv_truncate_bin= if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; then @@ -7219,7 +7276,8 @@ if "$ac_cv_path_lt_DD" bs=32 count=1 conftest.out 2>/dev/null; the && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1" fi rm -f conftest.i conftest2.i conftest.out -test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" +test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q" ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5 printf "%s\n" "$lt_cv_truncate_bin" >&6; } @@ -7429,8 +7487,8 @@ printf %s "checking whether the C compiler needs -belf... " >&6; } if test ${lt_cv_cc_needs_belf+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_ext=c +else case e in #( + e) ac_ext=c ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' @@ -7450,8 +7508,9 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : lt_cv_cc_needs_belf=yes -else $as_nop - lt_cv_cc_needs_belf=no +else case e in #( + e) lt_cv_cc_needs_belf=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext @@ -7460,7 +7519,8 @@ ac_cpp='$CPP $CPPFLAGS' ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' ac_compiler_gnu=$ac_cv_c_compiler_gnu - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5 printf "%s\n" "$lt_cv_cc_needs_belf" >&6; } @@ -7518,8 +7578,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_MANIFEST_TOOL+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$MANIFEST_TOOL"; then +else case e in #( + e) if test -n "$MANIFEST_TOOL"; then ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7541,7 +7601,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL if test -n "$MANIFEST_TOOL"; then @@ -7563,8 +7624,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_MANIFEST_TOOL+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_MANIFEST_TOOL"; then +else case e in #( + e) if test -n "$ac_ct_MANIFEST_TOOL"; then ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7586,7 +7647,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL if test -n "$ac_ct_MANIFEST_TOOL"; then @@ -7618,15 +7680,16 @@ printf %s "checking if $MANIFEST_TOOL is a manifest tool... " >&6; } if test ${lt_cv_path_mainfest_tool+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_path_mainfest_tool=no +else case e in #( + e) lt_cv_path_mainfest_tool=no echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5 $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out cat conftest.err >&5 if $GREP 'Manifest Tool' conftest.out > /dev/null; then lt_cv_path_mainfest_tool=yes fi - rm -f conftest* + rm -f conftest* ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5 printf "%s\n" "$lt_cv_path_mainfest_tool" >&6; } @@ -7649,8 +7712,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_DSYMUTIL+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$DSYMUTIL"; then +else case e in #( + e) if test -n "$DSYMUTIL"; then ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7672,7 +7735,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi DSYMUTIL=$ac_cv_prog_DSYMUTIL if test -n "$DSYMUTIL"; then @@ -7694,8 +7758,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_DSYMUTIL+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_DSYMUTIL"; then +else case e in #( + e) if test -n "$ac_ct_DSYMUTIL"; then ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7717,7 +7781,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL if test -n "$ac_ct_DSYMUTIL"; then @@ -7751,8 +7816,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_NMEDIT+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$NMEDIT"; then +else case e in #( + e) if test -n "$NMEDIT"; then ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7774,7 +7839,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi NMEDIT=$ac_cv_prog_NMEDIT if test -n "$NMEDIT"; then @@ -7796,8 +7862,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_NMEDIT+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_NMEDIT"; then +else case e in #( + e) if test -n "$ac_ct_NMEDIT"; then ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7819,7 +7885,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT if test -n "$ac_ct_NMEDIT"; then @@ -7853,8 +7920,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_LIPO+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$LIPO"; then +else case e in #( + e) if test -n "$LIPO"; then ac_cv_prog_LIPO="$LIPO" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7876,7 +7943,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi LIPO=$ac_cv_prog_LIPO if test -n "$LIPO"; then @@ -7898,8 +7966,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_LIPO+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_LIPO"; then +else case e in #( + e) if test -n "$ac_ct_LIPO"; then ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7921,7 +7989,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO if test -n "$ac_ct_LIPO"; then @@ -7955,8 +8024,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OTOOL+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$OTOOL"; then +else case e in #( + e) if test -n "$OTOOL"; then ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -7978,7 +8047,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi OTOOL=$ac_cv_prog_OTOOL if test -n "$OTOOL"; then @@ -8000,8 +8070,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OTOOL+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_OTOOL"; then +else case e in #( + e) if test -n "$ac_ct_OTOOL"; then ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -8023,7 +8093,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL if test -n "$ac_ct_OTOOL"; then @@ -8057,8 +8128,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_OTOOL64+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$OTOOL64"; then +else case e in #( + e) if test -n "$OTOOL64"; then ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -8080,7 +8151,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi OTOOL64=$ac_cv_prog_OTOOL64 if test -n "$OTOOL64"; then @@ -8102,8 +8174,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_OTOOL64+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_OTOOL64"; then +else case e in #( + e) if test -n "$ac_ct_OTOOL64"; then ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -8125,7 +8197,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64 if test -n "$ac_ct_OTOOL64"; then @@ -8182,8 +8255,8 @@ printf %s "checking for -single_module linker flag... " >&6; } if test ${lt_cv_apple_cc_single_mod+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_apple_cc_single_mod=no +else case e in #( + e) lt_cv_apple_cc_single_mod=no if test -z "$LT_MULTI_MODULE"; then # By default we will add the -single_module flag. You can override # by either setting the environment variable LT_MULTI_MODULE @@ -8209,7 +8282,8 @@ else $as_nop fi rm -rf libconftest.dylib* rm -f conftest.* - fi + fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5 printf "%s\n" "$lt_cv_apple_cc_single_mod" >&6; } @@ -8219,8 +8293,8 @@ printf %s "checking for -exported_symbols_list linker flag... " >&6; } if test ${lt_cv_ld_exported_symbols_list+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_ld_exported_symbols_list=no +else case e in #( + e) lt_cv_ld_exported_symbols_list=no save_LDFLAGS=$LDFLAGS echo "_main" > conftest.sym LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym" @@ -8238,13 +8312,15 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : lt_cv_ld_exported_symbols_list=yes -else $as_nop - lt_cv_ld_exported_symbols_list=no +else case e in #( + e) lt_cv_ld_exported_symbols_list=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LDFLAGS=$save_LDFLAGS - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5 printf "%s\n" "$lt_cv_ld_exported_symbols_list" >&6; } @@ -8254,8 +8330,8 @@ printf %s "checking for -force_load linker flag... " >&6; } if test ${lt_cv_ld_force_load+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_ld_force_load=no +else case e in #( + e) lt_cv_ld_force_load=no cat > conftest.c << _LT_EOF int forced_loaded() { return 2;} _LT_EOF @@ -8280,7 +8356,8 @@ _LT_EOF fi rm -f conftest.err libconftest.a conftest conftest.c rm -rf conftest.dSYM - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5 printf "%s\n" "$lt_cv_ld_force_load" >&6; } @@ -8420,8 +8497,9 @@ then : IFS=$lt_save_ifs ;; esac -else $as_nop - enable_shared=yes +else case e in #( + e) enable_shared=yes ;; +esac fi @@ -8452,8 +8530,9 @@ then : IFS=$lt_save_ifs ;; esac -else $as_nop - enable_static=yes +else case e in #( + e) enable_static=yes ;; +esac fi @@ -8484,8 +8563,9 @@ then : IFS=$lt_save_ifs ;; esac -else $as_nop - pic_mode=default +else case e in #( + e) pic_mode=default ;; +esac fi @@ -8515,8 +8595,9 @@ then : IFS=$lt_save_ifs ;; esac -else $as_nop - enable_fast_install=yes +else case e in #( + e) enable_fast_install=yes ;; +esac fi @@ -8543,15 +8624,17 @@ then : ;; esac lt_cv_with_aix_soname=$with_aix_soname -else $as_nop - if test ${lt_cv_with_aix_soname+y} +else case e in #( + e) if test ${lt_cv_with_aix_soname+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_with_aix_soname=aix +else case e in #( + e) lt_cv_with_aix_soname=aix ;; +esac fi - with_aix_soname=$lt_cv_with_aix_soname + with_aix_soname=$lt_cv_with_aix_soname ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5 @@ -8642,8 +8725,8 @@ printf %s "checking for objdir... " >&6; } if test ${lt_cv_objdir+y} then : printf %s "(cached) " >&6 -else $as_nop - rm -f .libs 2>/dev/null +else case e in #( + e) rm -f .libs 2>/dev/null mkdir .libs 2>/dev/null if test -d .libs; then lt_cv_objdir=.libs @@ -8651,7 +8734,8 @@ else # MS-DOS does not allow filenames that begin with a dot. lt_cv_objdir=_libs fi -rmdir .libs 2>/dev/null +rmdir .libs 2>/dev/null ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5 printf "%s\n" "$lt_cv_objdir" >&6; } @@ -8712,8 +8796,8 @@ printf %s "checking for ${ac_tool_prefix}file... " >&6; } if test ${lt_cv_path_MAGIC_CMD+y} then : printf %s "(cached) " >&6 -else $as_nop - case $MAGIC_CMD in +else case e in #( + e) case $MAGIC_CMD in [\\/*] | ?:[\\/]*) lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path. ;; @@ -8756,6 +8840,7 @@ _LT_EOF IFS=$lt_save_ifs MAGIC_CMD=$lt_save_MAGIC_CMD ;; +esac ;; esac fi @@ -8779,8 +8864,8 @@ printf %s "checking for file... " >&6; } if test ${lt_cv_path_MAGIC_CMD+y} then : printf %s "(cached) " >&6 -else $as_nop - case $MAGIC_CMD in +else case e in #( + e) case $MAGIC_CMD in [\\/*] | ?:[\\/]*) lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path. ;; @@ -8823,6 +8908,7 @@ _LT_EOF IFS=$lt_save_ifs MAGIC_CMD=$lt_save_MAGIC_CMD ;; +esac ;; esac fi @@ -8922,8 +9008,8 @@ printf %s "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; } if test ${lt_cv_prog_compiler_rtti_exceptions+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_prog_compiler_rtti_exceptions=no +else case e in #( + e) lt_cv_prog_compiler_rtti_exceptions=no ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="-fno-rtti -fno-exceptions" ## exclude from sc_useless_quotes_in_assignment @@ -8951,7 +9037,8 @@ else $as_nop fi fi $RM conftest* - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5 printf "%s\n" "$lt_cv_prog_compiler_rtti_exceptions" >&6; } @@ -9316,8 +9403,9 @@ printf %s "checking for $compiler option to produce PIC... " >&6; } if test ${lt_cv_prog_compiler_pic+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_prog_compiler_pic=$lt_prog_compiler_pic +else case e in #( + e) lt_cv_prog_compiler_pic=$lt_prog_compiler_pic ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5 printf "%s\n" "$lt_cv_prog_compiler_pic" >&6; } @@ -9332,8 +9420,8 @@ printf %s "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; if test ${lt_cv_prog_compiler_pic_works+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_prog_compiler_pic_works=no +else case e in #( + e) lt_cv_prog_compiler_pic_works=no ac_outfile=conftest.$ac_objext echo "$lt_simple_compile_test_code" > conftest.$ac_ext lt_compiler_flag="$lt_prog_compiler_pic -DPIC" ## exclude from sc_useless_quotes_in_assignment @@ -9361,7 +9449,8 @@ else $as_nop fi fi $RM conftest* - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5 printf "%s\n" "$lt_cv_prog_compiler_pic_works" >&6; } @@ -9397,8 +9486,8 @@ printf %s "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; if test ${lt_cv_prog_compiler_static_works+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_prog_compiler_static_works=no +else case e in #( + e) lt_cv_prog_compiler_static_works=no save_LDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS $lt_tmp_static_flag" echo "$lt_simple_link_test_code" > conftest.$ac_ext @@ -9419,7 +9508,8 @@ else $as_nop fi $RM -r conftest* LDFLAGS=$save_LDFLAGS - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5 printf "%s\n" "$lt_cv_prog_compiler_static_works" >&6; } @@ -9441,8 +9531,8 @@ printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_prog_compiler_c_o=no +else case e in #( + e) lt_cv_prog_compiler_c_o=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest @@ -9482,7 +9572,8 @@ else $as_nop cd .. $RM -r conftest $RM conftest* - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; } @@ -9497,8 +9588,8 @@ printf %s "checking if $compiler supports -c -o file.$ac_objext... " >&6; } if test ${lt_cv_prog_compiler_c_o+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_prog_compiler_c_o=no +else case e in #( + e) lt_cv_prog_compiler_c_o=no $RM -r conftest 2>/dev/null mkdir conftest cd conftest @@ -9538,7 +9629,8 @@ else $as_nop cd .. $RM -r conftest $RM conftest* - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5 printf "%s\n" "$lt_cv_prog_compiler_c_o" >&6; } @@ -10133,8 +10225,8 @@ else if test ${lt_cv_aix_libpath_+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int @@ -10166,7 +10258,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ if test -z "$lt_cv_aix_libpath_"; then lt_cv_aix_libpath_=/usr/lib:/lib fi - + ;; +esac fi aix_libpath=$lt_cv_aix_libpath_ @@ -10188,8 +10281,8 @@ else if test ${lt_cv_aix_libpath_+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int @@ -10221,7 +10314,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ if test -z "$lt_cv_aix_libpath_"; then lt_cv_aix_libpath_=/usr/lib:/lib fi - + ;; +esac fi aix_libpath=$lt_cv_aix_libpath_ @@ -10472,8 +10566,8 @@ printf %s "checking if $CC understands -b... " >&6; } if test ${lt_cv_prog_compiler__b+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_prog_compiler__b=no +else case e in #( + e) lt_cv_prog_compiler__b=no save_LDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS -b" echo "$lt_simple_link_test_code" > conftest.$ac_ext @@ -10494,7 +10588,8 @@ else $as_nop fi $RM -r conftest* LDFLAGS=$save_LDFLAGS - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5 printf "%s\n" "$lt_cv_prog_compiler__b" >&6; } @@ -10542,8 +10637,8 @@ printf %s "checking whether the $host_os linker accepts -exported_symbol... " >& if test ${lt_cv_irix_exported_symbol+y} then : printf %s "(cached) " >&6 -else $as_nop - save_LDFLAGS=$LDFLAGS +else case e in #( + e) save_LDFLAGS=$LDFLAGS LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -10552,12 +10647,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : lt_cv_irix_exported_symbol=yes -else $as_nop - lt_cv_irix_exported_symbol=no +else case e in #( + e) lt_cv_irix_exported_symbol=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext - LDFLAGS=$save_LDFLAGS + LDFLAGS=$save_LDFLAGS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5 printf "%s\n" "$lt_cv_irix_exported_symbol" >&6; } @@ -10883,8 +10980,8 @@ printf %s "checking whether -lc should be explicitly linked in... " >&6; } if test ${lt_cv_archive_cmds_need_lc+y} then : printf %s "(cached) " >&6 -else $as_nop - $RM conftest* +else case e in #( + e) $RM conftest* echo "$lt_simple_compile_test_code" > conftest.$ac_ext if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5 @@ -10920,7 +11017,8 @@ else $as_nop cat conftest.err 1>&5 fi $RM conftest* - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5 printf "%s\n" "$lt_cv_archive_cmds_need_lc" >&6; } @@ -11647,8 +11745,8 @@ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) if test ${lt_cv_shlibpath_overrides_runpath+y} then : printf %s "(cached) " >&6 -else $as_nop - lt_cv_shlibpath_overrides_runpath=no +else case e in #( + e) lt_cv_shlibpath_overrides_runpath=no save_LDFLAGS=$LDFLAGS save_libdir=$libdir eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \ @@ -11675,7 +11773,8 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext LDFLAGS=$save_LDFLAGS libdir=$save_libdir - + ;; +esac fi shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath @@ -11685,9 +11784,6 @@ fi # before this can be enabled. hardcode_into_libs=yes - # Add ABI-specific directories to the system library path. - sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib" - # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command @@ -11696,7 +11792,7 @@ fi # appending ld.so.conf contents (and includes) to the search path. if test -f /etc/ld.so.conf; then lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` - sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra" + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" fi # We used to test for /lib/ld.so.1 and disable shared libraries on @@ -12103,16 +12199,22 @@ printf %s "checking for dlopen in -ldl... " >&6; } if test ${ac_cv_lib_dl_dlopen+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-ldl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char dlopen (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (void); int main (void) { @@ -12124,24 +12226,27 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_dl_dlopen=yes -else $as_nop - ac_cv_lib_dl_dlopen=no +else case e in #( + e) ac_cv_lib_dl_dlopen=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes then : lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl -else $as_nop - +else case e in #( + e) lt_cv_dlopen=dyld lt_cv_dlopen_libs= lt_cv_dlopen_self=yes - + ;; +esac fi ;; @@ -12159,22 +12264,28 @@ fi if test "x$ac_cv_func_shl_load" = xyes then : lt_cv_dlopen=shl_load -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5 printf %s "checking for shl_load in -ldld... " >&6; } if test ${ac_cv_lib_dld_shl_load+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-ldld $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char shl_load (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char shl_load (void); int main (void) { @@ -12186,39 +12297,47 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_dld_shl_load=yes -else $as_nop - ac_cv_lib_dld_shl_load=no +else case e in #( + e) ac_cv_lib_dld_shl_load=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5 printf "%s\n" "$ac_cv_lib_dld_shl_load" >&6; } if test "x$ac_cv_lib_dld_shl_load" = xyes then : lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld -else $as_nop - ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" +else case e in #( + e) ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen" if test "x$ac_cv_func_dlopen" = xyes then : lt_cv_dlopen=dlopen -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5 printf %s "checking for dlopen in -ldl... " >&6; } if test ${ac_cv_lib_dl_dlopen+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-ldl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char dlopen (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (void); int main (void) { @@ -12230,34 +12349,42 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_dl_dlopen=yes -else $as_nop - ac_cv_lib_dl_dlopen=no +else case e in #( + e) ac_cv_lib_dl_dlopen=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5 printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; } if test "x$ac_cv_lib_dl_dlopen" = xyes then : lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5 printf %s "checking for dlopen in -lsvld... " >&6; } if test ${ac_cv_lib_svld_dlopen+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lsvld $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char dlopen (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char dlopen (void); int main (void) { @@ -12269,34 +12396,42 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_svld_dlopen=yes -else $as_nop - ac_cv_lib_svld_dlopen=no +else case e in #( + e) ac_cv_lib_svld_dlopen=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5 printf "%s\n" "$ac_cv_lib_svld_dlopen" >&6; } if test "x$ac_cv_lib_svld_dlopen" = xyes then : lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5 printf %s "checking for dld_link in -ldld... " >&6; } if test ${ac_cv_lib_dld_dld_link+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-ldld $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char dld_link (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char dld_link (void); int main (void) { @@ -12308,12 +12443,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_dld_dld_link=yes -else $as_nop - ac_cv_lib_dld_dld_link=no +else case e in #( + e) ac_cv_lib_dld_dld_link=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5 printf "%s\n" "$ac_cv_lib_dld_dld_link" >&6; } @@ -12322,19 +12459,24 @@ then : lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld fi - + ;; +esac fi - + ;; +esac fi - + ;; +esac fi - + ;; +esac fi - + ;; +esac fi ;; @@ -12362,8 +12504,8 @@ printf %s "checking whether a program can dlopen itself... " >&6; } if test ${lt_cv_dlopen_self+y} then : printf %s "(cached) " >&6 -else $as_nop - if test yes = "$cross_compiling"; then : +else case e in #( + e) if test yes = "$cross_compiling"; then : lt_cv_dlopen_self=cross else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 @@ -12457,7 +12599,8 @@ _LT_EOF fi rm -fr conftest* - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5 printf "%s\n" "$lt_cv_dlopen_self" >&6; } @@ -12469,8 +12612,8 @@ printf %s "checking whether a statically linked program can dlopen itself... " > if test ${lt_cv_dlopen_self_static+y} then : printf %s "(cached) " >&6 -else $as_nop - if test yes = "$cross_compiling"; then : +else case e in #( + e) if test yes = "$cross_compiling"; then : lt_cv_dlopen_self_static=cross else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 @@ -12564,7 +12707,8 @@ _LT_EOF fi rm -fr conftest* - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5 printf "%s\n" "$lt_cv_dlopen_self_static" >&6; } @@ -12738,8 +12882,9 @@ printf %s "checking whether to enable maintainer-specific portions of Makefiles. if test ${enable_maintainer_mode+y} then : enableval=$enable_maintainer_mode; USE_MAINTAINER_MODE=$enableval -else $as_nop - USE_MAINTAINER_MODE=no +else case e in #( + e) USE_MAINTAINER_MODE=no ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $USE_MAINTAINER_MODE" >&5 @@ -12779,8 +12924,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -12802,7 +12947,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -12824,8 +12970,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_CC"; then +else case e in #( + e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -12847,7 +12993,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then @@ -12882,8 +13029,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -12905,7 +13052,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -12927,8 +13075,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else ac_prog_rejected=no @@ -12967,7 +13115,8 @@ if test $ac_prog_rejected = yes; then ac_cv_prog_CC="$as_dir$ac_word${1+' '}$@" fi fi -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -12991,8 +13140,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -13014,7 +13163,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -13040,8 +13190,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_CC"; then +else case e in #( + e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -13063,7 +13213,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then @@ -13101,8 +13252,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$CC"; then +else case e in #( + e) if test -n "$CC"; then ac_cv_prog_CC="$CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -13124,7 +13275,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi CC=$ac_cv_prog_CC if test -n "$CC"; then @@ -13146,8 +13298,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_prog_ac_ct_CC+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -n "$ac_ct_CC"; then +else case e in #( + e) if test -n "$ac_ct_CC"; then ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test. else as_save_IFS=$IFS; IFS=$PATH_SEPARATOR @@ -13169,7 +13321,8 @@ done done IFS=$as_save_IFS -fi +fi ;; +esac fi ac_ct_CC=$ac_cv_prog_ac_ct_CC if test -n "$ac_ct_CC"; then @@ -13198,10 +13351,10 @@ fi fi -test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} +test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "no acceptable C compiler found in \$PATH -See \`config.log' for more details" "$LINENO" 5; } +See 'config.log' for more details" "$LINENO" 5; } # Provide some information about the compiler. printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5 @@ -13233,8 +13386,8 @@ printf %s "checking whether the compiler supports GNU C... " >&6; } if test ${ac_cv_c_compiler_gnu+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int @@ -13251,12 +13404,14 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_compiler_gnu=yes -else $as_nop - ac_compiler_gnu=no +else case e in #( + e) ac_compiler_gnu=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ac_cv_c_compiler_gnu=$ac_compiler_gnu - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5 printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; } @@ -13274,8 +13429,8 @@ printf %s "checking whether $CC accepts -g... " >&6; } if test ${ac_cv_prog_cc_g+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_save_c_werror_flag=$ac_c_werror_flag +else case e in #( + e) ac_save_c_werror_flag=$ac_c_werror_flag ac_c_werror_flag=yes ac_cv_prog_cc_g=no CFLAGS="-g" @@ -13293,8 +13448,8 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_g=yes -else $as_nop - CFLAGS="" +else case e in #( + e) CFLAGS="" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -13309,8 +13464,8 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : -else $as_nop - ac_c_werror_flag=$ac_save_c_werror_flag +else case e in #( + e) ac_c_werror_flag=$ac_save_c_werror_flag CFLAGS="-g" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -13327,12 +13482,15 @@ if ac_fn_c_try_compile "$LINENO" then : ac_cv_prog_cc_g=yes fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext - ac_c_werror_flag=$ac_save_c_werror_flag + ac_c_werror_flag=$ac_save_c_werror_flag ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5 printf "%s\n" "$ac_cv_prog_cc_g" >&6; } @@ -13359,8 +13517,8 @@ printf %s "checking for $CC option to enable C11 features... " >&6; } if test ${ac_cv_prog_cc_c11+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_cv_prog_cc_c11=no +else case e in #( + e) ac_cv_prog_cc_c11=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -13377,25 +13535,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c11" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC +CC=$ac_save_CC ;; +esac fi if test "x$ac_cv_prog_cc_c11" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } -else $as_nop - if test "x$ac_cv_prog_cc_c11" = x +else case e in #( + e) if test "x$ac_cv_prog_cc_c11" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5 printf "%s\n" "$ac_cv_prog_cc_c11" >&6; } - CC="$CC $ac_cv_prog_cc_c11" + CC="$CC $ac_cv_prog_cc_c11" ;; +esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11 - ac_prog_cc_stdc=c11 + ac_prog_cc_stdc=c11 ;; +esac fi fi if test x$ac_prog_cc_stdc = xno @@ -13405,8 +13566,8 @@ printf %s "checking for $CC option to enable C99 features... " >&6; } if test ${ac_cv_prog_cc_c99+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_cv_prog_cc_c99=no +else case e in #( + e) ac_cv_prog_cc_c99=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -13423,25 +13584,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c99" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC +CC=$ac_save_CC ;; +esac fi if test "x$ac_cv_prog_cc_c99" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } -else $as_nop - if test "x$ac_cv_prog_cc_c99" = x +else case e in #( + e) if test "x$ac_cv_prog_cc_c99" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5 printf "%s\n" "$ac_cv_prog_cc_c99" >&6; } - CC="$CC $ac_cv_prog_cc_c99" + CC="$CC $ac_cv_prog_cc_c99" ;; +esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99 - ac_prog_cc_stdc=c99 + ac_prog_cc_stdc=c99 ;; +esac fi fi if test x$ac_prog_cc_stdc = xno @@ -13451,8 +13615,8 @@ printf %s "checking for $CC option to enable C89 features... " >&6; } if test ${ac_cv_prog_cc_c89+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_cv_prog_cc_c89=no +else case e in #( + e) ac_cv_prog_cc_c89=no ac_save_CC=$CC cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -13469,25 +13633,28 @@ rm -f core conftest.err conftest.$ac_objext conftest.beam test "x$ac_cv_prog_cc_c89" != "xno" && break done rm -f conftest.$ac_ext -CC=$ac_save_CC +CC=$ac_save_CC ;; +esac fi if test "x$ac_cv_prog_cc_c89" = xno then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5 printf "%s\n" "unsupported" >&6; } -else $as_nop - if test "x$ac_cv_prog_cc_c89" = x +else case e in #( + e) if test "x$ac_cv_prog_cc_c89" = x then : { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5 printf "%s\n" "none needed" >&6; } -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5 printf "%s\n" "$ac_cv_prog_cc_c89" >&6; } - CC="$CC $ac_cv_prog_cc_c89" + CC="$CC $ac_cv_prog_cc_c89" ;; +esac fi ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89 - ac_prog_cc_stdc=c89 + ac_prog_cc_stdc=c89 ;; +esac fi fi @@ -13508,8 +13675,8 @@ printf %s "checking whether $CC understands -c and -o together... " >&6; } if test ${am_cv_prog_cc_c_o+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int @@ -13539,7 +13706,8 @@ _ACEOF fi done rm -f core conftest* - unset am_i + unset am_i ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5 printf "%s\n" "$am_cv_prog_cc_c_o" >&6; } @@ -13565,8 +13733,8 @@ printf %s "checking dependency style of $depcc... " >&6; } if test ${am_cv_CC_dependencies_compiler_type+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then +else case e in #( + e) if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then # We make a subdir and do the tests there. Otherwise we can end up # making bogus files that we don't know about and never remove. For # instance it was reported that on HP-UX the gcc test will end up @@ -13670,7 +13838,8 @@ else $as_nop else am_cv_CC_dependencies_compiler_type=none fi - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5 printf "%s\n" "$am_cv_CC_dependencies_compiler_type" >&6; } @@ -13764,8 +13933,8 @@ printf %s "checking for main in -lws2_32... " >&6; } if test ${ac_cv_lib_ws2_32_main+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lws2_32 $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -13782,12 +13951,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_ws2_32_main=yes -else $as_nop - ac_cv_lib_ws2_32_main=no +else case e in #( + e) ac_cv_lib_ws2_32_main=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ws2_32_main" >&5 printf "%s\n" "$ac_cv_lib_ws2_32_main" >&6; } @@ -13804,8 +13975,8 @@ printf %s "checking for main in -liphlpapi... " >&6; } if test ${ac_cv_lib_iphlpapi_main+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-liphlpapi $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -13822,12 +13993,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_iphlpapi_main=yes -else $as_nop - ac_cv_lib_iphlpapi_main=no +else case e in #( + e) ac_cv_lib_iphlpapi_main=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_iphlpapi_main" >&5 printf "%s\n" "$ac_cv_lib_iphlpapi_main" >&6; } @@ -13861,8 +14034,8 @@ printf "%s\n" "$withval" >&6; } else as_fn_error $? "packet32.h or packet.lib not found in $withval" "$LINENO" 5 fi -else $as_nop - for dir in ${prefix} ${HOME}/WPdpack ; do +else case e in #( + e) for dir in ${prefix} ${HOME}/WPdpack ; do if test -f ${dir}/include/packet32.h -a -f ${dir}/lib/packet.lib; then CFLAGS="$CFLAGS -I${dir}/include" LIBS="$LIBS -L${dir}/lib -lpacket" @@ -13874,7 +14047,8 @@ else $as_nop as_fn_error $? "WinPcap developer's pack not found" "$LINENO" 5 fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5 -printf "%s\n" "yes" >&6; } +printf "%s\n" "yes" >&6; } ;; +esac fi fi @@ -13887,23 +14061,29 @@ if test "$CYGWIN" != yes ; then if test "x$ac_cv_func_gethostbyname" = xyes then : -else $as_nop - # Some OSes (eg. Solaris) place it in libnsl: +else case e in #( + e) # Some OSes (eg. Solaris) place it in libnsl: { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5 printf %s "checking for gethostbyname in -lnsl... " >&6; } if test ${ac_cv_lib_nsl_gethostbyname+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lnsl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char gethostbyname (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char gethostbyname (void); int main (void) { @@ -13915,12 +14095,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_nsl_gethostbyname=yes -else $as_nop - ac_cv_lib_nsl_gethostbyname=no +else case e in #( + e) ac_cv_lib_nsl_gethostbyname=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5 printf "%s\n" "$ac_cv_lib_nsl_gethostbyname" >&6; } @@ -13930,23 +14112,29 @@ then : LIBS="-lnsl $LIBS" -else $as_nop - # Some strange OSes (SINIX) have it in libsocket: +else case e in #( + e) # Some strange OSes (SINIX) have it in libsocket: { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lsocket" >&5 printf %s "checking for gethostbyname in -lsocket... " >&6; } if test ${ac_cv_lib_socket_gethostbyname+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lsocket $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char gethostbyname (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char gethostbyname (void); int main (void) { @@ -13958,12 +14146,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_socket_gethostbyname=yes -else $as_nop - ac_cv_lib_socket_gethostbyname=no +else case e in #( + e) ac_cv_lib_socket_gethostbyname=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_gethostbyname" >&5 printf "%s\n" "$ac_cv_lib_socket_gethostbyname" >&6; } @@ -13973,8 +14163,8 @@ then : LIBS="-lsocket $LIBS" -else $as_nop - # Unfortunately libsocket sometimes depends on libnsl. +else case e in #( + e) # Unfortunately libsocket sometimes depends on libnsl. # AC_CHECK_LIB's API is essentially broken so the # following ugliness is necessary: { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lsocket" >&5 @@ -13982,16 +14172,22 @@ printf %s "checking for gethostbyname in -lsocket... " >&6; } if test ${ac_cv_lib_socket_gethostbyname+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lsocket -lnsl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char gethostbyname (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char gethostbyname (void); int main (void) { @@ -14003,34 +14199,42 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_socket_gethostbyname=yes -else $as_nop - ac_cv_lib_socket_gethostbyname=no +else case e in #( + e) ac_cv_lib_socket_gethostbyname=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_gethostbyname" >&5 printf "%s\n" "$ac_cv_lib_socket_gethostbyname" >&6; } if test "x$ac_cv_lib_socket_gethostbyname" = xyes then : LIBS="-lsocket -lnsl $LIBS" -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lresolv" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lresolv" >&5 printf %s "checking for gethostbyname in -lresolv... " >&6; } if test ${ac_cv_lib_resolv_gethostbyname+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lresolv $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char gethostbyname (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char gethostbyname (void); int main (void) { @@ -14042,12 +14246,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_resolv_gethostbyname=yes -else $as_nop - ac_cv_lib_resolv_gethostbyname=no +else case e in #( + e) ac_cv_lib_resolv_gethostbyname=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_resolv_gethostbyname" >&5 printf "%s\n" "$ac_cv_lib_resolv_gethostbyname" >&6; } @@ -14058,35 +14264,45 @@ then : LIBS="-lresolv $LIBS" fi - + ;; +esac fi - + ;; +esac fi - + ;; +esac fi - + ;; +esac fi ac_fn_c_check_func "$LINENO" "socket" "ac_cv_func_socket" if test "x$ac_cv_func_socket" = xyes then : -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for socket in -lsocket" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for socket in -lsocket" >&5 printf %s "checking for socket in -lsocket... " >&6; } if test ${ac_cv_lib_socket_socket+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lsocket $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char socket (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char socket (void); int main (void) { @@ -14098,12 +14314,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_socket_socket=yes -else $as_nop - ac_cv_lib_socket_socket=no +else case e in #( + e) ac_cv_lib_socket_socket=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_socket" >&5 printf "%s\n" "$ac_cv_lib_socket_socket" >&6; } @@ -14113,22 +14331,28 @@ then : LIBS="-lsocket $LIBS" -else $as_nop - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for socket in -lsocket" >&5 +else case e in #( + e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for socket in -lsocket" >&5 printf %s "checking for socket in -lsocket... " >&6; } if test ${ac_cv_lib_socket_socket+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lsocket -lnsl $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char socket (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char socket (void); int main (void) { @@ -14140,12 +14364,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_socket_socket=yes -else $as_nop - ac_cv_lib_socket_socket=no +else case e in #( + e) ac_cv_lib_socket_socket=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_socket" >&5 printf "%s\n" "$ac_cv_lib_socket_socket" >&6; } @@ -14153,9 +14379,11 @@ if test "x$ac_cv_lib_socket_socket" = xyes then : LIBS="-lsocket -lnsl $LIBS" fi - + ;; +esac fi - + ;; +esac fi # DLPI needs putmsg under HPUX so test for -lstr while we're at it @@ -14164,16 +14392,22 @@ printf %s "checking for putmsg in -lstr... " >&6; } if test ${ac_cv_lib_str_putmsg+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lstr $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char putmsg (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char putmsg (void); int main (void) { @@ -14185,12 +14419,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_str_putmsg=yes -else $as_nop - ac_cv_lib_str_putmsg=no +else case e in #( + e) ac_cv_lib_str_putmsg=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_str_putmsg" >&5 printf "%s\n" "$ac_cv_lib_str_putmsg" >&6; } @@ -14207,16 +14443,22 @@ printf %s "checking for open_mib in -lnm... " >&6; } if test ${ac_cv_lib_nm_open_mib+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_check_lib_save_LIBS=$LIBS +else case e in #( + e) ac_check_lib_save_LIBS=$LIBS LIBS="-lnm $LIBS" cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ /* Override any GCC internal prototype to avoid an error. Use char because int might match the return type of a GCC - builtin and then its argument prototype would still apply. */ -char open_mib (); + builtin and then its argument prototype would still apply. + The 'extern "C"' is for builds by C++ compilers; + although this is not generally supported in C code supporting it here + has little cost and some practical benefit (sr 110532). */ +#ifdef __cplusplus +extern "C" +#endif +char open_mib (void); int main (void) { @@ -14228,12 +14470,14 @@ _ACEOF if ac_fn_c_try_link "$LINENO" then : ac_cv_lib_nm_open_mib=yes -else $as_nop - ac_cv_lib_nm_open_mib=no +else case e in #( + e) ac_cv_lib_nm_open_mib=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam \ conftest$ac_exeext conftest.$ac_ext -LIBS=$ac_check_lib_save_LIBS +LIBS=$ac_check_lib_save_LIBS ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nm_open_mib" >&5 printf "%s\n" "$ac_cv_lib_nm_open_mib" >&6; } @@ -14272,8 +14516,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_PKG_CONFIG+y} then : printf %s "(cached) " >&6 -else $as_nop - case $PKG_CONFIG in +else case e in #( + e) case $PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path. ;; @@ -14298,6 +14542,7 @@ done IFS=$as_save_IFS ;; +esac ;; esac fi PKG_CONFIG=$ac_cv_path_PKG_CONFIG @@ -14320,8 +14565,8 @@ printf %s "checking for $ac_word... " >&6; } if test ${ac_cv_path_ac_pt_PKG_CONFIG+y} then : printf %s "(cached) " >&6 -else $as_nop - case $ac_pt_PKG_CONFIG in +else case e in #( + e) case $ac_pt_PKG_CONFIG in [\\/]* | ?:[\\/]*) ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path. ;; @@ -14346,6 +14591,7 @@ done IFS=$as_save_IFS ;; +esac ;; esac fi ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG @@ -14416,8 +14662,8 @@ printf "%s\n" "$withval" >&6; } fi ;; esac -else $as_nop - +else case e in #( + e) pkg_failed=no { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for check" >&5 printf %s "checking for check... " >&6; } @@ -14489,8 +14735,8 @@ See the pkg-config man page for more details." "$LINENO" 5 elif test $pkg_failed = untried; then { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "The pkg-config script could not be found or is too old. Make sure it is in your PATH or set the PKG_CONFIG environment variable to the full path to pkg-config. @@ -14500,7 +14746,7 @@ and CHECK_LIBS to avoid the need to call pkg-config. See the pkg-config man page for more details. To get pkg-config, see . -See \`config.log' for more details" "$LINENO" 5; } +See 'config.log' for more details" "$LINENO" 5; } else CHECK_CFLAGS=$pkg_cv_CHECK_CFLAGS CHECK_LIBS=$pkg_cv_CHECK_LIBS @@ -14518,7 +14764,8 @@ printf "%s\n" "yes" >&6; } { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5 printf "%s\n" "no" >&6; } fi - + ;; +esac fi @@ -14535,83 +14782,6 @@ fi -# Autoupdate added the next two lines to ensure that your configure -# script's behavior did not change. They are probably safe to remove. - -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5 -printf %s "checking for egrep... " >&6; } -if test ${ac_cv_path_EGREP+y} -then : - printf %s "(cached) " >&6 -else $as_nop - if echo a | $GREP -E '(a|b)' >/dev/null 2>&1 - then ac_cv_path_EGREP="$GREP -E" - else - if test -z "$EGREP"; then - ac_path_EGREP_found=false - # Loop through the user's path and test for each of PROGNAME-LIST - as_save_IFS=$IFS; IFS=$PATH_SEPARATOR -for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin -do - IFS=$as_save_IFS - case $as_dir in #((( - '') as_dir=./ ;; - */) ;; - *) as_dir=$as_dir/ ;; - esac - for ac_prog in egrep - do - for ac_exec_ext in '' $ac_executable_extensions; do - ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext" - as_fn_executable_p "$ac_path_EGREP" || continue -# Check for GNU ac_path_EGREP and select it if it is found. - # Check for GNU $ac_path_EGREP -case `"$ac_path_EGREP" --version 2>&1` in -*GNU*) - ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;; -*) - ac_count=0 - printf %s 0123456789 >"conftest.in" - while : - do - cat "conftest.in" "conftest.in" >"conftest.tmp" - mv "conftest.tmp" "conftest.in" - cp "conftest.in" "conftest.nl" - printf "%s\n" 'EGREP' >> "conftest.nl" - "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break - diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break - as_fn_arith $ac_count + 1 && ac_count=$as_val - if test $ac_count -gt ${ac_path_EGREP_max-0}; then - # Best one so far, save it but keep looking for a better one - ac_cv_path_EGREP="$ac_path_EGREP" - ac_path_EGREP_max=$ac_count - fi - # 10*(2^10) chars as input seems more than enough - test $ac_count -gt 10 && break - done - rm -f conftest.in conftest.tmp conftest.nl conftest.out;; -esac - - $ac_path_EGREP_found && break 3 - done - done - done -IFS=$as_save_IFS - if test -z "$ac_cv_path_EGREP"; then - as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5 - fi -else - ac_cv_path_EGREP=$EGREP -fi - - fi -fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5 -printf "%s\n" "$ac_cv_path_EGREP" >&6; } - EGREP="$ac_cv_path_EGREP" - - - if test "$CYGWIN" = yes ; then ac_fn_c_check_header_compile "$LINENO" "Iphlpapi.h" "ac_cv_header_Iphlpapi_h" "$ac_includes_default" if test "x$ac_cv_header_Iphlpapi_h" = xyes @@ -14880,8 +15050,8 @@ printf %s "checking for an ANSI C-conforming const... " >&6; } if test ${ac_cv_c_const+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ int @@ -14945,10 +15115,12 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_c_const=yes -else $as_nop - ac_cv_c_const=no +else case e in #( + e) ac_cv_c_const=no ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_const" >&5 printf "%s\n" "$ac_cv_c_const" >&6; } @@ -14963,8 +15135,8 @@ printf %s "checking for inline... " >&6; } if test ${ac_cv_c_inline+y} then : printf %s "(cached) " >&6 -else $as_nop - ac_cv_c_inline=no +else case e in #( + e) ac_cv_c_inline=no for ac_kw in inline __inline__ __inline; do cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ @@ -14982,7 +15154,8 @@ fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext test "$ac_cv_c_inline" != no && break done - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_inline" >&5 printf "%s\n" "$ac_cv_c_inline" >&6; } @@ -15008,8 +15181,8 @@ esac if test "x$ac_cv_type_pid_t" = xyes then : -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #if defined _WIN64 && !defined __CYGWIN__ @@ -15028,14 +15201,16 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_pid_type='int' -else $as_nop - ac_pid_type='__int64' +else case e in #( + e) ac_pid_type='__int64' ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext printf "%s\n" "#define pid_t $ac_pid_type" >>confdefs.h - + ;; +esac fi @@ -15043,10 +15218,11 @@ ac_fn_c_check_type "$LINENO" "size_t" "ac_cv_type_size_t" "$ac_includes_default" if test "x$ac_cv_type_size_t" = xyes then : -else $as_nop - +else case e in #( + e) printf "%s\n" "#define size_t unsigned int" >>confdefs.h - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sockaddr_in6 struct in " >&5 @@ -15054,8 +15230,8 @@ printf %s "checking for sockaddr_in6 struct in ... " >&6; } if test ${ac_cv_dnet_netinet_in_h_has_sockaddr_in6+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include @@ -15071,10 +15247,12 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_dnet_netinet_in_h_has_sockaddr_in6=yes -else $as_nop - ac_cv_dnet_netinet_in_h_has_sockaddr_in6=no +else case e in #( + e) ac_cv_dnet_netinet_in_h_has_sockaddr_in6=no ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_netinet_in_h_has_sockaddr_in6" >&5 @@ -15090,8 +15268,8 @@ printf %s "checking for sa_len in sockaddr struct... " >&6; } if test ${ac_cv_dnet_sockaddr_has_sa_len+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #ifndef _SOCKADDR_LEN #define _SOCKADDR_LEN 1 @@ -15109,10 +15287,12 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_dnet_sockaddr_has_sa_len=yes -else $as_nop - ac_cv_dnet_sockaddr_has_sa_len=no +else case e in #( + e) ac_cv_dnet_sockaddr_has_sa_len=no ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_sockaddr_has_sa_len" >&5 @@ -15129,8 +15309,8 @@ printf %s "checking for arp_dev in arpreq struct... " >&6; } if test ${ac_cv_dnet_arpreq_has_arp_dev+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include @@ -15146,10 +15326,12 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_dnet_arpreq_has_arp_dev=yes -else $as_nop - ac_cv_dnet_arpreq_has_arp_dev=no +else case e in #( + e) ac_cv_dnet_arpreq_has_arp_dev=no ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_arpreq_has_arp_dev" >&5 @@ -15166,8 +15348,8 @@ printf %s "checking for rt_msghdr struct in ... " >&6; } if test ${ac_cv_dnet_route_h_has_rt_msghdr+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #include @@ -15184,10 +15366,12 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_dnet_route_h_has_rt_msghdr=yes -else $as_nop - ac_cv_dnet_route_h_has_rt_msghdr=no +else case e in #( + e) ac_cv_dnet_route_h_has_rt_msghdr=no ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_route_h_has_rt_msghdr" >&5 @@ -15198,183 +15382,6 @@ printf "%s\n" "#define HAVE_ROUTE_RT_MSGHDR 1" >>confdefs.h fi fi -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5 -printf %s "checking how to run the C preprocessor... " >&6; } -# On Suns, sometimes $CPP names a directory. -if test -n "$CPP" && test -d "$CPP"; then - CPP= -fi -if test -z "$CPP"; then - if test ${ac_cv_prog_CPP+y} -then : - printf %s "(cached) " >&6 -else $as_nop - # Double quotes because $CC needs to be expanded - for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp - do - ac_preproc_ok=false -for ac_c_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - Syntax error -_ACEOF -if ac_fn_c_try_cpp "$LINENO" -then : - -else $as_nop - # Broken: fails on valid input. -continue -fi -rm -f conftest.err conftest.i conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_c_try_cpp "$LINENO" -then : - # Broken: success on invalid input. -continue -else $as_nop - # Passes both tests. -ac_preproc_ok=: -break -fi -rm -f conftest.err conftest.i conftest.$ac_ext - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok -then : - break -fi - - done - ac_cv_prog_CPP=$CPP - -fi - CPP=$ac_cv_prog_CPP -else - ac_cv_prog_CPP=$CPP -fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5 -printf "%s\n" "$CPP" >&6; } -ac_preproc_ok=false -for ac_c_preproc_warn_flag in '' yes -do - # Use a header file that comes with gcc, so configuring glibc - # with a fresh cross-compiler works. - # On the NeXT, cc -E runs the code through the compiler's parser, - # not just through cpp. "Syntax error" is here to catch this case. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include - Syntax error -_ACEOF -if ac_fn_c_try_cpp "$LINENO" -then : - -else $as_nop - # Broken: fails on valid input. -continue -fi -rm -f conftest.err conftest.i conftest.$ac_ext - - # OK, works on sane cases. Now check whether nonexistent headers - # can be detected and how. - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -_ACEOF -if ac_fn_c_try_cpp "$LINENO" -then : - # Broken: success on invalid input. -continue -else $as_nop - # Passes both tests. -ac_preproc_ok=: -break -fi -rm -f conftest.err conftest.i conftest.$ac_ext - -done -# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped. -rm -f conftest.i conftest.err conftest.$ac_ext -if $ac_preproc_ok -then : - -else $as_nop - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} -as_fn_error $? "C preprocessor \"$CPP\" fails sanity check -See \`config.log' for more details" "$LINENO" 5; } -fi - -ac_ext=c -ac_cpp='$CPP $CPPFLAGS' -ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5' -ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5' -ac_compiler_gnu=$ac_cv_c_compiler_gnu - - -if test $ac_cv_c_compiler_gnu = yes; then - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC needs -traditional" >&5 -printf %s "checking whether $CC needs -traditional... " >&6; } -if test ${ac_cv_prog_gcc_traditional+y} -then : - printf %s "(cached) " >&6 -else $as_nop - ac_pattern="Autoconf.*'x'" - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -Autoconf TIOCGETP -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "$ac_pattern" >/dev/null 2>&1 -then : - ac_cv_prog_gcc_traditional=yes -else $as_nop - ac_cv_prog_gcc_traditional=no -fi -rm -rf conftest* - - - if test $ac_cv_prog_gcc_traditional = no; then - cat confdefs.h - <<_ACEOF >conftest.$ac_ext -/* end confdefs.h. */ -#include -Autoconf TCGETA -_ACEOF -if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | - $EGREP "$ac_pattern" >/dev/null 2>&1 -then : - ac_cv_prog_gcc_traditional=yes -fi -rm -rf conftest* - - fi -fi -{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_gcc_traditional" >&5 -printf "%s\n" "$ac_cv_prog_gcc_traditional" >&6; } - if test $ac_cv_prog_gcc_traditional = yes; then - CC="$CC -traditional" - fi -fi if test "$GCC" = yes ; then CFLAGS="$CFLAGS -Wall" @@ -15385,12 +15392,12 @@ printf %s "checking for working memcmp... " >&6; } if test ${ac_cv_func_memcmp_working+y} then : printf %s "(cached) " >&6 -else $as_nop - if test "$cross_compiling" = yes +else case e in #( + e) if test "$cross_compiling" = yes then : ac_cv_func_memcmp_working=no -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ $ac_includes_default int @@ -15428,13 +15435,16 @@ _ACEOF if ac_fn_c_try_run "$LINENO" then : ac_cv_func_memcmp_working=yes -else $as_nop - ac_cv_func_memcmp_working=no +else case e in #( + e) ac_cv_func_memcmp_working=no ;; +esac fi rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \ - conftest.$ac_objext conftest.beam conftest.$ac_ext + conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi - + ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_func_memcmp_working" >&5 printf "%s\n" "$ac_cv_func_memcmp_working" >&6; } @@ -15450,52 +15460,56 @@ if test "x$ac_cv_func_err" = xyes then : printf "%s\n" "#define HAVE_ERR 1" >>confdefs.h -else $as_nop - case " $LIBOBJS " in +else case e in #( + e) case " $LIBOBJS " in *" err.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS err.$ac_objext" ;; esac - + ;; +esac fi ac_fn_c_check_func "$LINENO" "strlcat" "ac_cv_func_strlcat" if test "x$ac_cv_func_strlcat" = xyes then : printf "%s\n" "#define HAVE_STRLCAT 1" >>confdefs.h -else $as_nop - case " $LIBOBJS " in +else case e in #( + e) case " $LIBOBJS " in *" strlcat.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS strlcat.$ac_objext" ;; esac - + ;; +esac fi ac_fn_c_check_func "$LINENO" "strlcpy" "ac_cv_func_strlcpy" if test "x$ac_cv_func_strlcpy" = xyes then : printf "%s\n" "#define HAVE_STRLCPY 1" >>confdefs.h -else $as_nop - case " $LIBOBJS " in +else case e in #( + e) case " $LIBOBJS " in *" strlcpy.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS strlcpy.$ac_objext" ;; esac - + ;; +esac fi ac_fn_c_check_func "$LINENO" "strsep" "ac_cv_func_strsep" if test "x$ac_cv_func_strsep" = xyes then : printf "%s\n" "#define HAVE_STRSEP 1" >>confdefs.h -else $as_nop - case " $LIBOBJS " in +else case e in #( + e) case " $LIBOBJS " in *" strsep.$ac_objext "* ) ;; *) LIBOBJS="$LIBOBJS strsep.$ac_objext" ;; esac - + ;; +esac fi @@ -15505,12 +15519,13 @@ printf %s "checking for Berkeley Packet Filter... " >&6; } if test ${ac_cv_dnet_bsd_bpf+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -c /dev/bpf ; then +else case e in #( + e) if test -c /dev/bpf ; then ac_cv_dnet_bsd_bpf=yes else ac_cv_dnet_bsd_bpf=no - fi + fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_bsd_bpf" >&5 @@ -15525,12 +15540,13 @@ printf %s "checking for Linux proc filesystem... " >&6; } if test ${ac_cv_dnet_linux_procfs+y} then : printf %s "(cached) " >&6 -else $as_nop - if test "x`cat /proc/sys/kernel/ostype 2>&-`" = "xLinux" ; then +else case e in #( + e) if test "x`cat /proc/sys/kernel/ostype 2>&-`" = "xLinux" ; then ac_cv_dnet_linux_procfs=yes else ac_cv_dnet_linux_procfs=no - fi + fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_linux_procfs" >&5 @@ -15557,8 +15573,9 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_dnet_linux_pf_packet=yes -else $as_nop - ac_cv_dnet_linux_pf_packet=no +else case e in #( + e) ac_cv_dnet_linux_pf_packet=no ;; +esac fi rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_linux_pf_packet" >&5 @@ -15573,12 +15590,13 @@ printf %s "checking for SNMP MIB2 STREAMS... " >&6; } if test ${ac_cv_dnet_streams_mib2+y} then : printf %s "(cached) " >&6 -else $as_nop - if test -f /usr/include/inet/mib2.h -a -c /dev/ip ; then +else case e in #( + e) if test -f /usr/include/inet/mib2.h -a -c /dev/ip ; then ac_cv_dnet_streams_mib2=yes else ac_cv_dnet_streams_mib2=no - fi + fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_streams_mib2" >&5 @@ -15593,12 +15611,13 @@ printf %s "checking for route(7) STREAMS... " >&6; } if test ${ac_cv_dnet_streams_route+y} then : printf %s "(cached) " >&6 -else $as_nop - if grep RTSTR_SEND /usr/include/net/route.h >/dev/null 2>&1 ; then +else case e in #( + e) if grep RTSTR_SEND /usr/include/net/route.h >/dev/null 2>&1 ; then ac_cv_dnet_streams_route=yes else ac_cv_dnet_streams_route=no - fi + fi ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_streams_route" >&5 @@ -15613,8 +15632,8 @@ printf %s "checking for arp(7) ioctls... " >&6; } if test ${ac_cv_dnet_ioctl_arp+y} then : printf %s "(cached) " >&6 -else $as_nop - cat confdefs.h - <<_ACEOF >conftest.$ac_ext +else case e in #( + e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext /* end confdefs.h. */ #include #define BSD_COMP @@ -15630,10 +15649,12 @@ _ACEOF if ac_fn_c_try_compile "$LINENO" then : ac_cv_dnet_ioctl_arp=yes -else $as_nop - ac_cv_dnet_ioctl_arp=no +else case e in #( + e) ac_cv_dnet_ioctl_arp=no ;; +esac fi -rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext +rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;; +esac fi case "$host_os" in @@ -15652,8 +15673,8 @@ printf %s "checking for raw IP sockets ip_{len,off} host byte ordering... " >&6; if test ${ac_cv_dnet_rawip_host_offlen+y} then : printf %s "(cached) " >&6 -else $as_nop - +else case e in #( + e) case "$host_os" in *openbsd*) ac_cv_dnet_rawip_host_offlen=no ;; @@ -15661,7 +15682,8 @@ else $as_nop ac_cv_dnet_rawip_host_offlen=yes ;; *) ac_cv_dnet_rawip_host_offlen=no ;; - esac + esac ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_rawip_host_offlen" >&5 @@ -15676,14 +15698,15 @@ printf %s "checking for cooked raw IP sockets... " >&6; } if test ${ac_cv_dnet_rawip_cooked+y} then : printf %s "(cached) " >&6 -else $as_nop - +else case e in #( + e) case "$host_os" in solaris*|irix*) ac_cv_dnet_rawip_cooked=yes ;; *) ac_cv_dnet_rawip_cooked=no ;; - esac + esac ;; +esac fi { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_dnet_rawip_cooked" >&5 @@ -15997,8 +16020,8 @@ cat >confcache <<\_ACEOF # config.status only pays attention to the cache file if you give it # the --recheck option to rerun configure. # -# `ac_cv_env_foo' variables (set or unset) will be overridden when -# loading this file, other *unset* `ac_cv_foo' will be assigned the +# 'ac_cv_env_foo' variables (set or unset) will be overridden when +# loading this file, other *unset* 'ac_cv_foo' will be assigned the # following values. _ACEOF @@ -16028,14 +16051,14 @@ printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} (set) 2>&1 | case $as_nl`(ac_space=' '; set) 2>&1` in #( *${as_nl}ac_space=\ *) - # `set' does not quote correctly, so add quotes: double-quote + # 'set' does not quote correctly, so add quotes: double-quote # substitution turns \\\\ into \\, and sed turns \\ into \. sed -n \ "s/'/'\\\\''/g; s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p" ;; #( *) - # `set' quotes correctly as required by POSIX, so do not add quotes. + # 'set' quotes correctly as required by POSIX, so do not add quotes. sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p" ;; esac | @@ -16169,7 +16192,6 @@ cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1 # Be more Bourne compatible DUALCASE=1; export DUALCASE # for MKS sh -as_nop=: if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1 then : emulate sh @@ -16178,12 +16200,13 @@ then : # is contrary to our usage. Disable this feature. alias -g '${1+"$@"}'='"$@"' setopt NO_GLOB_SUBST -else $as_nop - case `(set -o) 2>/dev/null` in #( +else case e in #( + e) case `(set -o) 2>/dev/null` in #( *posix*) : set -o posix ;; #( *) : ;; +esac ;; esac fi @@ -16255,7 +16278,7 @@ IFS=$as_save_IFS ;; esac -# We did not find ourselves, most probably we were run as `sh COMMAND' +# We did not find ourselves, most probably we were run as 'sh COMMAND' # in which case we are not to be found in the path. if test "x$as_myself" = x; then as_myself=$0 @@ -16284,7 +16307,6 @@ as_fn_error () } # as_fn_error - # as_fn_set_status STATUS # ----------------------- # Set $? to STATUS, without forking. @@ -16324,11 +16346,12 @@ then : { eval $1+=\$2 }' -else $as_nop - as_fn_append () +else case e in #( + e) as_fn_append () { eval $1=\$$1\$2 - } + } ;; +esac fi # as_fn_append # as_fn_arith ARG... @@ -16342,11 +16365,12 @@ then : { as_val=$(( $* )) }' -else $as_nop - as_fn_arith () +else case e in #( + e) as_fn_arith () { as_val=`expr "$@" || test $? -eq 1` - } + } ;; +esac fi # as_fn_arith @@ -16429,9 +16453,9 @@ if (echo >conf$$.file) 2>/dev/null; then if ln -s conf$$.file conf$$ 2>/dev/null; then as_ln_s='ln -s' # ... but there are two gotchas: - # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail. - # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable. - # In both cases, we have to default to `cp -pR'. + # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail. + # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable. + # In both cases, we have to default to 'cp -pR'. ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe || as_ln_s='cp -pR' elif ln conf$$.file conf$$ 2>/dev/null; then @@ -16512,10 +16536,12 @@ as_test_x='test -x' as_executable_p=as_fn_executable_p # Sed expression to map a string onto a valid CPP name. -as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'" +as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g" +as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated # Sed expression to map a string onto a valid variable name. -as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'" +as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g" +as_tr_sh="eval sed '$as_sed_sh'" # deprecated exec 6>&1 @@ -16530,8 +16556,8 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by libdnet $as_me 1.17.0, which was -generated by GNU Autoconf 2.71. Invocation command line was +This file was extended by libdnet $as_me 1.18.0, which was +generated by GNU Autoconf 2.72. Invocation command line was CONFIG_FILES = $CONFIG_FILES CONFIG_HEADERS = $CONFIG_HEADERS @@ -16563,7 +16589,7 @@ _ACEOF cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 ac_cs_usage="\ -\`$as_me' instantiates files and other configuration actions +'$as_me' instantiates files and other configuration actions from templates according to the current configuration. Unless the files and actions are specified as TAGs, all are instantiated by default. @@ -16598,11 +16624,11 @@ ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config='$ac_cs_config_escaped' ac_cs_version="\\ -libdnet config.status 1.17.0 -configured by $0, generated by GNU Autoconf 2.71, +libdnet config.status 1.18.0 +configured by $0, generated by GNU Autoconf 2.72, with options \\"\$ac_cs_config\\" -Copyright (C) 2021 Free Software Foundation, Inc. +Copyright (C) 2023 Free Software Foundation, Inc. This config.status script is free software; the Free Software Foundation gives unlimited permission to copy, distribute and modify it." @@ -16664,8 +16690,8 @@ do ac_need_defaults=false;; --he | --h) # Conflict between --help and --header - as_fn_error $? "ambiguous option: \`$1' -Try \`$0 --help' for more information.";; + as_fn_error $? "ambiguous option: '$1' +Try '$0 --help' for more information.";; --help | --hel | -h ) printf "%s\n" "$ac_cs_usage"; exit ;; -q | -quiet | --quiet | --quie | --qui | --qu | --q \ @@ -16673,8 +16699,8 @@ Try \`$0 --help' for more information.";; ac_cs_silent=: ;; # This is an error. - -*) as_fn_error $? "unrecognized option: \`$1' -Try \`$0 --help' for more information." ;; + -*) as_fn_error $? "unrecognized option: '$1' +Try '$0 --help' for more information." ;; *) as_fn_append ac_config_targets " $1" ac_need_defaults=false ;; @@ -17029,7 +17055,7 @@ do "test/dnet/Makefile") CONFIG_FILES="$CONFIG_FILES test/dnet/Makefile" ;; "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;; - *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;; + *) as_fn_error $? "invalid argument: '$ac_config_target'" "$LINENO" 5;; esac done @@ -17049,7 +17075,7 @@ fi # creating and moving files from /tmp can sometimes cause problems. # Hook for its removal unless debugging. # Note that there is a small window in which the directory will not be cleaned: -# after its creation but before its name has been assigned to `$tmp'. +# after its creation but before its name has been assigned to '$tmp'. $debug || { tmp= ac_tmp= @@ -17073,7 +17099,7 @@ ac_tmp=$tmp # Set up the scripts for CONFIG_FILES section. # No need to generate them if there are no CONFIG_FILES. -# This happens for instance with `./config.status config.h'. +# This happens for instance with './config.status config.h'. if test -n "$CONFIG_FILES"; then @@ -17231,13 +17257,13 @@ fi # test -n "$CONFIG_FILES" # Set up the scripts for CONFIG_HEADERS section. # No need to generate them if there are no CONFIG_HEADERS. -# This happens for instance with `./config.status Makefile'. +# This happens for instance with './config.status Makefile'. if test -n "$CONFIG_HEADERS"; then cat >"$ac_tmp/defines.awk" <<\_ACAWK || BEGIN { _ACEOF -# Transform confdefs.h into an awk script `defines.awk', embedded as +# Transform confdefs.h into an awk script 'defines.awk', embedded as # here-document in config.status, that substitutes the proper values into # config.h.in to produce config.h. @@ -17347,7 +17373,7 @@ do esac case $ac_mode$ac_tag in :[FHL]*:*);; - :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;; + :L* | :C*:*) as_fn_error $? "invalid tag '$ac_tag'" "$LINENO" 5;; :[FH]-) ac_tag=-:-;; :[FH]*) ac_tag=$ac_tag:$ac_tag.in;; esac @@ -17369,19 +17395,19 @@ do -) ac_f="$ac_tmp/stdin";; *) # Look for the file first in the build tree, then in the source tree # (if the path is not absolute). The absolute path cannot be DOS-style, - # because $ac_f cannot contain `:'. + # because $ac_f cannot contain ':'. test -f "$ac_f" || case $ac_f in [\\/$]*) false;; *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";; esac || - as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;; + as_fn_error 1 "cannot find input file: '$ac_f'" "$LINENO" 5;; esac case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac as_fn_append ac_file_inputs " '$ac_f'" done - # Let's still pretend it is `configure' which instantiates (i.e., don't + # Let's still pretend it is 'configure' which instantiates (i.e., don't # use $as_me), people would be surprised to read: # /* config.h. Generated by config.status. */ configure_input='Generated from '` @@ -17514,7 +17540,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 esac _ACEOF -# Neutralize VPATH when `$srcdir' = `.'. +# Neutralize VPATH when '$srcdir' = '.'. # Shell code in configure.ac might set extrasub. # FIXME: do we really want to maintain this feature? cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 @@ -17545,9 +17571,9 @@ test -z "$ac_datarootdir_hack$ac_datarootdir_seen" && { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } && { ac_out=`sed -n '/^[ ]*datarootdir[ ]*:*=/p' \ "$ac_tmp/out"`; test -z "$ac_out"; } && - { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir' + { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir' which seems to be undefined. Please make sure it is defined" >&5 -printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir' +printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir' which seems to be undefined. Please make sure it is defined" >&2;} rm -f "$ac_tmp/stdin" @@ -17702,15 +17728,15 @@ printf "%s\n" X/"$am_mf" | (exit $ac_status); } || am_rc=$? done if test $am_rc -ne 0; then - { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5 -printf "%s\n" "$as_me: error: in \`$ac_pwd':" >&2;} + { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5 +printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;} as_fn_error $? "Something went wrong bootstrapping makefile fragments for automatic dependency tracking. If GNU make was not used, consider re-running the configure script with MAKE=\"gmake\" (or whatever is necessary). You can also try re-running configure with the '--disable-dependency-tracking' option to at least be able to build the package (albeit without support for automatic dependency tracking). -See \`config.log' for more details" "$LINENO" 5; } +See 'config.log' for more details" "$LINENO" 5; } fi { am_dirpart=; unset am_dirpart;} { am_filepart=; unset am_filepart;} diff --git a/configure.ac b/configure.ac index b423b98..e1d71bf 100644 --- a/configure.ac +++ b/configure.ac @@ -1,12 +1,12 @@ dnl dnl configure.in dnl -dnl Copyright (c) 2023 Oliver Falk +dnl Copyright (c) 2023-2024 Oliver Falk dnl dnl $Id$ -AC_PREREQ([2.69]) -AC_INIT(libdnet, 1.17.0) +AC_PREREQ([2.71]) +AC_INIT([libdnet],[1.18.0]) AC_CONFIG_MACRO_DIR([m4]) AC_CONFIG_AUX_DIR(config) AC_SUBST(ac_aux_dir) @@ -21,10 +21,7 @@ dnl XXX - stop the insanity!@#$ AM_MAINTAINER_MODE dnl Check for system type. -dnl XXX - we do this to qualify our later feature checks, since some -dnl systems claim to support multiple features, but are quite b0rked. AC_CANONICAL_HOST -dnl XXX - spoof AC_CYGWIN case "$host_os" in *cygwin*) CYGWIN=yes;; *) CYGWIN=no;; @@ -38,8 +35,23 @@ fi dnl Checks for programs. AC_PROG_CC AC_PROG_INSTALL -AC_LIBTOOL_DLOPEN -AM_PROG_LIBTOOL +_LT_SET_OPTION([LT_INIT],[dlopen]) +m4_warn([obsolete],[_LT_SET_OPTION([LT_INIT],[dlopen]) +m4_warn([obsolete],[_LT_SET_OPTION([LT_INIT],[dlopen]) +m4_warn([obsolete],[_LT_SET_OPTION([LT_INIT],[dlopen]) +m4_warn([obsolete],[_LT_SET_OPTION([LT_INIT],[dlopen]) +m4_warn([obsolete],[AC_LIBTOOL_DLOPEN: Remove this warning and the call to _LT_SET_OPTION when you +put the 'dlopen' option into LT_INIT's first parameter.]) +: Remove this warning and the call to _LT_SET_OPTION when you +put the 'dlopen' option into LT_INIT's first parameter.]) +: Remove this warning and the call to _LT_SET_OPTION when you +put the 'dlopen' option into LT_INIT's first parameter.]) +: Remove this warning and the call to _LT_SET_OPTION when you +put the 'dlopen' option into LT_INIT's first parameter.]) +: Remove this warning and the call to _LT_SET_OPTION when you +put the 'dlopen' option into LT_INIT's first parameter.]) + +LT_INIT dnl Checks for Python. dnl XXX - use AM_PATH_PYTHON after automake upgrade @@ -65,7 +77,7 @@ AC_ARG_WITH(python, fi done if test "x$PYTHON" = "x"; then - AC_ERROR(python not found in $withval) + AC_MSG_ERROR(python not found in $withval) fi ;; esac @@ -152,7 +164,7 @@ AS_IF([test "${enable_check}" != "no"], [ CHECKINC="-I$withval/src" CHECKLIB="-L$withval/src -lcheck" else - AC_ERROR(check.h or libcheck.a not found in $withval) + AC_MSG_ERROR(check.h or libcheck.a not found in $withval) fi ;; esac ], @@ -172,8 +184,6 @@ AS_IF([test "${enable_check}" != "no"], [ AM_CONDITIONAL([HAVE_CHECK], [test "${have_check}" = "yes"]) -dnl Checks for header files. -AC_HEADER_STDC if test "$CYGWIN" = yes ; then AC_CHECK_HEADERS(Iphlpapi.h winsock2.h) else @@ -341,8 +351,9 @@ else AC_LIBOBJ([tun-none]) fi -AC_OUTPUT([Makefile dnet-config include/Makefile include/dnet/Makefile +AC_CONFIG_FILES([Makefile dnet-config include/Makefile include/dnet/Makefile man/Makefile src/Makefile python/Makefile python/setup.py python/dnet.pxd test/Makefile test/check/Makefile - test/dnet/Makefile], - [chmod 755 dnet-config]) + test/dnet/Makefile]) +AC_CONFIG_COMMANDS([default],[chmod 755 dnet-config],[]) +AC_OUTPUT diff --git a/include/Makefile.in b/include/Makefile.in index 8279d23..e96ee58 100644 --- a/include/Makefile.in +++ b/include/Makefile.in @@ -231,7 +231,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ diff --git a/include/dnet/Makefile.in b/include/dnet/Makefile.in index 9d8729d..c043d26 100644 --- a/include/dnet/Makefile.in +++ b/include/dnet/Makefile.in @@ -188,7 +188,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ diff --git a/include/dnet/arp.h b/include/dnet/arp.h index 85ba497..d2c982f 100644 --- a/include/dnet/arp.h +++ b/include/dnet/arp.h @@ -4,9 +4,8 @@ * Address Resolution Protocol. * RFC 826 * - * Copyright (c) 2000 Dug Song + * Copyright (c) 2023-2024 Oliver Falk * - * $Id$ */ #ifndef DNET_ARP_H @@ -38,6 +37,7 @@ struct arp_hdr { */ #define ARP_HRD_ETH 0x0001 /* ethernet hardware */ #define ARP_HRD_IEEE802 0x0006 /* IEEE 802 hardware */ +#define ARP_HRD_IEEE80211_RADIOTAP 0x0323 /* IEEE 802.11 + radiotap header */ /* * Protocol address format diff --git a/include/dnet/sctp.h b/include/dnet/sctp.h index ea2bfb3..f313bae 100644 --- a/include/dnet/sctp.h +++ b/include/dnet/sctp.h @@ -5,7 +5,6 @@ * * Copyright (c) 2008-2009 Daniel Roethlisberger * - * $Id$ */ #ifndef DNET_SCTP_H @@ -36,7 +35,7 @@ struct sctp_hdr { sctp_pack_p->sh_vtag = htonl(vtag); \ } while (0) -struct sctp_chunkhdr { +struct dnet_sctp_chunkhdr { uint8_t sch_type; /* chunk type */ uint8_t sch_flags; /* chunk flags */ uint16_t sch_length; /* chunk length */ @@ -70,7 +69,7 @@ struct sctp_chunkhdr { #define SCTP_TYPEFLAG_SKIP 2 #define sctp_pack_chunkhdr(hdr, type, flags, length) do { \ - struct sctp_chunkhdr *sctp_pack_chp = (struct sctp_chunkhdr *)(hdr);\ + struct dnet_sctp_chunkhdr *sctp_pack_chp = (struct dnet_sctp_chunkhdr *)(hdr);\ sctp_pack_chp->sch_type = type; \ sctp_pack_chp->sch_flags = flags; \ sctp_pack_chp->sch_length = htons(length); \ @@ -80,7 +79,7 @@ struct sctp_chunkhdr { * INIT chunk */ struct sctp_chunkhdr_init { - struct sctp_chunkhdr chunkhdr; + struct dnet_sctp_chunkhdr chunkhdr; uint32_t schi_itag; /* Initiate Tag */ uint32_t schi_arwnd; /* Advertised Receiver Window Credit */ @@ -105,7 +104,7 @@ struct sctp_chunkhdr_init { * INIT ACK chunk */ struct sctp_chunkhdr_init_ack { - struct sctp_chunkhdr chunkhdr; + struct dnet_sctp_chunkhdr chunkhdr; uint32_t schia_itag; /* Initiate Tag */ uint32_t schia_arwnd; /* Advertised Receiver Window Credit */ @@ -130,7 +129,7 @@ struct sctp_chunkhdr_init_ack { * ABORT chunk */ struct sctp_chunkhdr_abort { - struct sctp_chunkhdr chunkhdr; + struct dnet_sctp_chunkhdr chunkhdr; /* empty */ } __attribute__((__packed__)); @@ -145,7 +144,7 @@ struct sctp_chunkhdr_abort { * SHUTDOWN ACK chunk */ struct sctp_chunkhdr_shutdown_ack { - struct sctp_chunkhdr chunkhdr; + struct dnet_sctp_chunkhdr chunkhdr; /* empty */ } __attribute__((__packed__)); @@ -160,7 +159,7 @@ struct sctp_chunkhdr_shutdown_ack { * COOKIE ECHO chunk */ struct sctp_chunkhdr_cookie_echo { - struct sctp_chunkhdr chunkhdr; + struct dnet_sctp_chunkhdr chunkhdr; /* empty */ } __attribute__((__packed__)); diff --git a/libdnet.spec b/libdnet.spec index c43ab43..9233c07 100644 --- a/libdnet.spec +++ b/libdnet.spec @@ -1,6 +1,6 @@ Summary: Simple portable interface to lowlevel networking routines Name: libdnet -Version: 1.17.0 +Version: 1.18.0 Release: 1%{?dist} License: BSD URL: https://github.com/ofalk/%{name} @@ -89,6 +89,9 @@ popd %{python3_sitearch}/* %changelog +* Tue Feb 27 2024 Oliver Falk - 1.18.0-1 +- Release 1.18.0 + * Thu Oct 12 2023 Oliver Falk - 1.17.0-1 - Release 1.17.0 diff --git a/m4/libtool.m4 b/m4/libtool.m4 index e3adeda..79a2451 100644 --- a/m4/libtool.m4 +++ b/m4/libtool.m4 @@ -2887,9 +2887,6 @@ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) # before this can be enabled. hardcode_into_libs=yes - # Add ABI-specific directories to the system library path. - sys_lib_dlsearch_path_spec="/lib64 /usr/lib64 /lib /usr/lib" - # Ideally, we could use ldconfig to report *all* directores which are # searched for libraries, however this is still not possible. Aside from not # being certain /sbin/ldconfig is available, command @@ -2898,7 +2895,7 @@ linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*) # appending ld.so.conf contents (and includes) to the search path. if test -f /etc/ld.so.conf; then lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^[ ]*hwcap[ ]/d;s/[:, ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;s/"//g;/^$/d' | tr '\n' ' '` - sys_lib_dlsearch_path_spec="$sys_lib_dlsearch_path_spec $lt_ld_extra" + sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra" fi # We used to test for /lib/ld.so.1 and disable shared libraries on diff --git a/m4/ltoptions.m4 b/m4/ltoptions.m4 index 94b0829..b0b5e9c 100644 --- a/m4/ltoptions.m4 +++ b/m4/ltoptions.m4 @@ -1,7 +1,7 @@ # Helper functions for option handling. -*- Autoconf -*- # -# Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software -# Foundation, Inc. +# Copyright (C) 2004-2005, 2007-2009, 2011-2019, 2021-2022 Free +# Software Foundation, Inc. # Written by Gary V. Vaughan, 2004 # # This file is free software; the Free Software Foundation gives diff --git a/m4/ltsugar.m4 b/m4/ltsugar.m4 index 48bc934..902508b 100644 --- a/m4/ltsugar.m4 +++ b/m4/ltsugar.m4 @@ -1,6 +1,6 @@ # ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*- # -# Copyright (C) 2004-2005, 2007-2008, 2011-2015 Free Software +# Copyright (C) 2004-2005, 2007-2008, 2011-2019, 2021-2022 Free Software # Foundation, Inc. # Written by Gary V. Vaughan, 2004 # diff --git a/m4/lt~obsolete.m4 b/m4/lt~obsolete.m4 index c6b26f8..0f7a875 100644 --- a/m4/lt~obsolete.m4 +++ b/m4/lt~obsolete.m4 @@ -1,7 +1,7 @@ # lt~obsolete.m4 -- aclocal satisfying obsolete definitions. -*-Autoconf-*- # -# Copyright (C) 2004-2005, 2007, 2009, 2011-2015 Free Software -# Foundation, Inc. +# Copyright (C) 2004-2005, 2007, 2009, 2011-2019, 2021-2022 Free +# Software Foundation, Inc. # Written by Scott James Remnant, 2004. # # This file is free software; the Free Software Foundation gives diff --git a/man/Makefile.in b/man/Makefile.in index 8d26ffe..b56d025 100644 --- a/man/Makefile.in +++ b/man/Makefile.in @@ -172,7 +172,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ diff --git a/python/Makefile.in b/python/Makefile.in index 217ac6f..1e33597 100644 --- a/python/Makefile.in +++ b/python/Makefile.in @@ -349,7 +349,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ diff --git a/python/dnet.c b/python/dnet.c index f2ed0a9..1b459f3 100644 --- a/python/dnet.c +++ b/python/dnet.c @@ -1,4 +1,4 @@ -/* Generated by Cython 0.29.32 */ +/* Generated by Cython 3.0.8 */ /* BEGIN: Cython Metadata { @@ -9,20 +9,18 @@ "extra_objects": [ "../src/.libs/addr-util.o", "../src/.libs/addr.o", - "../src/.libs/arp-ioctl.o", + "../src/.libs/arp-bsd.o", "../src/.libs/blob.o", - "../src/.libs/eth-linux.o", + "../src/.libs/eth-none.o", "../src/.libs/fw-none.o", "../src/.libs/intf.o", "../src/.libs/ip-util.o", "../src/.libs/ip.o", "../src/.libs/ip6.o", - "../src/.libs/ndisc-linux.o", + "../src/.libs/ndisc-none.o", "../src/.libs/rand.o", - "../src/.libs/route-linux.o", - "../src/.libs/strlcat.o", - "../src/.libs/strlcpy.o", - "../src/.libs/tun-linux.o" + "../src/.libs/route-bsd.o", + "../src/.libs/tun-none.o" ], "include_dirs": [ "../include" @@ -39,20 +37,37 @@ END: Cython Metadata */ #ifndef PY_SSIZE_T_CLEAN #define PY_SSIZE_T_CLEAN #endif /* PY_SSIZE_T_CLEAN */ +#if defined(CYTHON_LIMITED_API) && 0 + #ifndef Py_LIMITED_API + #if CYTHON_LIMITED_API+0 > 0x03030000 + #define Py_LIMITED_API CYTHON_LIMITED_API + #else + #define Py_LIMITED_API 0x03030000 + #endif + #endif +#endif + #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+. +#elif PY_VERSION_HEX < 0x02070000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.7+ or Python 3.3+. +#else +#if defined(CYTHON_LIMITED_API) && CYTHON_LIMITED_API +#define __PYX_EXTRA_ABI_MODULE_NAME "limited" #else -#define CYTHON_ABI "0_29_32" -#define CYTHON_HEX_VERSION 0x001D20F0 +#define __PYX_EXTRA_ABI_MODULE_NAME "" +#endif +#define CYTHON_ABI "3_0_8" __PYX_EXTRA_ABI_MODULE_NAME +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." +#define CYTHON_HEX_VERSION 0x030008F0 #define CYTHON_FUTURE_DIVISION 1 #include #ifndef offsetof #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) #endif -#if !defined(WIN32) && !defined(MS_WINDOWS) +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) #ifndef __stdcall #define __stdcall #endif @@ -71,9 +86,7 @@ END: Cython Metadata */ #endif #define __PYX_COMMA , #ifndef HAVE_LONG_LONG - #if PY_VERSION_HEX >= 0x02070000 - #define HAVE_LONG_LONG - #endif + #define HAVE_LONG_LONG #endif #ifndef PY_LONG_LONG #define PY_LONG_LONG LONG_LONG @@ -81,13 +94,19 @@ END: Cython Metadata */ #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 __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 #define CYTHON_COMPILING_IN_NOGIL 0 #undef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 #undef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 0 #if PY_VERSION_HEX < 0x03050000 @@ -112,10 +131,19 @@ END: Cython Metadata */ #define CYTHON_UNPACK_METHODS 0 #undef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif #undef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #undef CYTHON_USE_TP_FINALIZE #define CYTHON_USE_TP_FINALIZE 0 #undef CYTHON_USE_DICT_VERSIONS @@ -123,46 +151,123 @@ END: Cython Metadata */ #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC - #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_HEX >= 0x07030900) + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PYSTON_VERSION) - #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 1 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 - #ifndef CYTHON_USE_TYPE_SLOTS - #define CYTHON_USE_TYPE_SLOTS 1 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #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_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS (PY_MAJOR_VERSION >= 3) + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1 && PYPY_VERSION_NUM >= 0x07030C00) + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_CLINE_IN_TRACEBACK + #define CYTHON_CLINE_IN_TRACEBACK 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 #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 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 #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_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_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 #undef CYTHON_FAST_PYCALL #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif #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_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 1 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif #undef CYTHON_USE_DICT_VERSIONS #define CYTHON_USE_DICT_VERSIONS 0 #undef CYTHON_USE_EXC_INFO_STACK @@ -170,10 +275,11 @@ END: Cython Metadata */ #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 #endif -#elif defined(PY_NOGIL) +#elif defined(Py_GIL_DISABLED) || defined(Py_NOGIL) #define CYTHON_COMPILING_IN_PYPY 0 - #define CYTHON_COMPILING_IN_PYSTON 0 #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 1 #ifndef CYTHON_USE_TYPE_SLOTS #define CYTHON_USE_TYPE_SLOTS 1 @@ -217,16 +323,17 @@ END: Cython Metadata */ #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 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 #define CYTHON_COMPILING_IN_NOGIL 0 #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) + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP #define CYTHON_USE_PYTYPE_LOOKUP 1 #endif #if PY_MAJOR_VERSION < 3 @@ -235,10 +342,7 @@ END: Cython Metadata */ #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) + #ifndef CYTHON_USE_PYLONG_INTERNALS #define CYTHON_USE_PYLONG_INTERNALS 1 #endif #ifndef CYTHON_USE_PYLIST_INTERNALS @@ -262,29 +366,47 @@ END: Cython Metadata */ #ifndef CYTHON_UNPACK_METHODS #define CYTHON_UNPACK_METHODS 1 #endif - #if PY_VERSION_HEX >= 0x030B00A4 - #undef CYTHON_FAST_THREAD_STATE - #define CYTHON_FAST_THREAD_STATE 0 - #elif !defined(CYTHON_FAST_THREAD_STATE) + #ifndef CYTHON_FAST_THREAD_STATE #define CYTHON_FAST_THREAD_STATE 1 #endif + #ifndef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL (PY_MAJOR_VERSION < 3 || PY_VERSION_HEX >= 0x03060000 && PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (PY_VERSION_HEX >= 0x030700A1) + #endif #ifndef CYTHON_FAST_PYCALL - #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #define CYTHON_FAST_PYCALL 1 #endif - #ifndef CYTHON_PEP489_MULTI_PHASE_INIT - #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 #endif - #ifndef CYTHON_USE_TP_FINALIZE - #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 #endif - #ifndef CYTHON_USE_DICT_VERSIONS - #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX >= 0x030600B1) + #if PY_VERSION_HEX < 0x030400a1 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #elif !defined(CYTHON_USE_TP_FINALIZE) + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #if PY_VERSION_HEX < 0x030600B1 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5) #endif - #if PY_VERSION_HEX >= 0x030B00A4 + #if PY_VERSION_HEX < 0x030700A3 #undef CYTHON_USE_EXC_INFO_STACK #define CYTHON_USE_EXC_INFO_STACK 0 #elif !defined(CYTHON_USE_EXC_INFO_STACK) - #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #define CYTHON_USE_EXC_INFO_STACK 1 #endif #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 @@ -293,6 +415,10 @@ END: Cython Metadata */ #if !defined(CYTHON_FAST_PYCCALL) #define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) #endif +#if !defined(CYTHON_VECTORCALL) +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL && PY_VERSION_HEX >= 0x030800B1) +#endif +#define CYTHON_BACKPORT_VECTORCALL (CYTHON_METH_FASTCALL && PY_VERSION_HEX < 0x030800B1) #if CYTHON_USE_PYLONG_INTERNALS #if PY_MAJOR_VERSION < 3 #include "longintrepr.h" @@ -321,6 +447,17 @@ END: Cython Metadata */ #define CYTHON_RESTRICT #endif #endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif #ifndef CYTHON_UNUSED # if defined(__GNUC__) # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) @@ -334,13 +471,16 @@ END: Cython Metadata */ # define CYTHON_UNUSED # endif #endif -#ifndef CYTHON_MAYBE_UNUSED_VAR +#ifndef CYTHON_UNUSED_VAR # if defined(__cplusplus) - template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } + template void CYTHON_UNUSED_VAR( const T& ) { } # else -# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# define CYTHON_UNUSED_VAR(x) (void)(x) # endif #endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif #ifndef CYTHON_NCP_UNUSED # if CYTHON_COMPILING_IN_CPYTHON # define CYTHON_NCP_UNUSED @@ -348,28 +488,59 @@ END: Cython Metadata */ # define CYTHON_NCP_UNUSED CYTHON_UNUSED # endif #endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #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; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + #endif + #endif + #if _MSC_VER < 1300 + #ifdef _WIN64 + typedef unsigned long long __pyx_uintptr_t; #else - typedef unsigned __int8 uint8_t; - typedef unsigned __int32 uint32_t; + typedef unsigned int __pyx_uintptr_t; + #endif + #else + #ifdef _WIN64 + typedef unsigned __int64 __pyx_uintptr_t; + #else + typedef unsigned __int32 __pyx_uintptr_t; #endif #endif #else - #include + #include + typedef uintptr_t __pyx_uintptr_t; #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]] + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif #endif #endif #ifndef CYTHON_FALLTHROUGH @@ -379,13 +550,26 @@ END: Cython Metadata */ #define CYTHON_FALLTHROUGH #endif #endif - #if defined(__clang__ ) && defined(__apple_build_version__) + #if defined(__clang__) && defined(__apple_build_version__) #if __apple_build_version__ < 7000000 #undef CYTHON_FALLTHROUGH #define CYTHON_FALLTHROUGH #endif #endif #endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) #ifndef CYTHON_INLINE #if defined(__clang__) @@ -401,85 +585,145 @@ END: Cython Metadata */ #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 + #define __Pyx_PyCode_New(a, p, 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) #else #define __Pyx_BUILTIN_MODULE_NAME "builtins" #define __Pyx_DefaultClassType PyType_Type -#if PY_VERSION_HEX >= 0x030B00A1 - static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, +#if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE PyObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, PyObject *code, PyObject *c, PyObject* n, PyObject *v, PyObject *fv, PyObject *cell, PyObject* fn, PyObject *name, int fline, PyObject *lnos) { - PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; - PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; - const char *fn_cstr=NULL; - const char *name_cstr=NULL; - PyCodeObject* co=NULL; + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030B0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; PyObject *type, *value, *traceback; PyErr_Fetch(&type, &value, &traceback); - if (!(kwds=PyDict_New())) goto end; - if (!(argcount=PyLong_FromLong(a))) goto end; - if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; - if (!(posonlyargcount=PyLong_FromLong(0))) goto end; - if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; - if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; - if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; - if (!(nlocals=PyLong_FromLong(l))) goto end; - if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; - if (!(stacksize=PyLong_FromLong(s))) goto end; - if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; - if (!(flags=PyLong_FromLong(f))) goto end; - if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; - if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; - if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; - if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; - if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; - if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; - if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here - if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; - Py_XDECREF((PyObject*)co); - co = (PyCodeObject*)call_result; - call_result = NULL; - if (0) { - cleanup_code_too: - Py_XDECREF((PyObject*)co); - co = NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030B0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); } - end: - Py_XDECREF(kwds); - Py_XDECREF(argcount); - Py_XDECREF(posonlyargcount); - Py_XDECREF(kwonlyargcount); - Py_XDECREF(nlocals); - Py_XDECREF(stacksize); - Py_XDECREF(replace); - Py_XDECREF(call_result); - Py_XDECREF(empty); + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); if (type) { PyErr_Restore(type, value, traceback); } - return co; + return result; } + #ifndef CO_OPTIMIZED + #define CO_OPTIMIZED 0x0001 + #endif + #ifndef CO_NEWLOCALS + #define CO_NEWLOCALS 0x0002 + #endif + #ifndef CO_VARARGS + #define CO_VARARGS 0x0004 + #endif + #ifndef CO_VARKEYWORDS + #define CO_VARKEYWORDS 0x0008 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x0200 + #endif + #ifndef CO_GENERATOR + #define CO_GENERATOR 0x0020 + #endif + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x0080 + #endif +#elif PY_VERSION_HEX >= 0x030B0000 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + PyObject *empty_bytes = PyBytes_FromStringAndSize("", 0); + if (!empty_bytes) return NULL; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, empty_bytes); + Py_DECREF(empty_bytes); + return result; + } +#elif PY_VERSION_HEX >= 0x030800B2 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, 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)\ + #define __Pyx_PyCode_New(a, p, 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 +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 +#endif +#ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 #endif #ifndef Py_TPFLAGS_CHECKTYPES #define Py_TPFLAGS_CHECKTYPES 0 @@ -493,6 +737,12 @@ END: Cython Metadata */ #ifndef Py_TPFLAGS_HAVE_FINALIZE #define Py_TPFLAGS_HAVE_FINALIZE 0 #endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif #ifndef METH_STACKLESS #define METH_STACKLESS 0 #endif @@ -507,31 +757,81 @@ END: Cython Metadata */ #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))))) +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#elif CYTHON_BACKPORT_VECTORCALL + typedef PyObject *(*__pyx_vectorcallfunc)(PyObject *callable, PyObject *const *args, + size_t nargsf, PyObject *kwnames); + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET ((size_t)1 << (8 * sizeof(size_t) - 1)) + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(((size_t)(n)) & ~__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_MAJOR_VERSION >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void *cfunc) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if __PYX_LIMITED_VERSION_HEX < 0x030900B1 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); #else -#define __Pyx_PyFastCFunction_Check(func) 0 + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 #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) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_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 +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() #elif PY_VERSION_HEX >= 0x03060000 #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() #elif PY_VERSION_HEX >= 0x03000000 @@ -539,6 +839,22 @@ END: Cython Metadata */ #else #define __Pyx_PyThreadState_Current _PyThreadState_Current #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE void *__Pyx_PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE(obj), name, func_ctype) +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) +#endif #if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) #include "pythread.h" #define Py_tss_NEEDS_INIT 0 @@ -569,7 +885,29 @@ 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) +#if PY_MAJOR_VERSION < 3 + #if CYTHON_COMPILING_IN_PYPY + #if PYPY_VERSION_NUM < 0x07030600 + #if defined(__cplusplus) && __cplusplus >= 201402L + [[deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")]] + #elif defined(__GNUC__) || defined(__clang__) + __attribute__ ((__deprecated__("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6"))) + #elif defined(_MSC_VER) + __declspec(deprecated("`with nogil:` inside a nogil function will not release the GIL in PyPy2 < 7.3.6")) + #endif + static CYTHON_INLINE int PyGILState_Check(void) { + return 0; + } + #else // PYPY_VERSION_NUM < 0x07030600 + #endif // PYPY_VERSION_NUM < 0x07030600 + #else + static CYTHON_INLINE int PyGILState_Check(void) { + PyThreadState * tstate = _PyThreadState_Current; + return tstate && (tstate == PyGILState_GetThisThreadState()); + } + #endif +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 || defined(_PyDict_NewPresized) #define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) #else #define __Pyx_PyDict_NewPresized(n) PyDict_New() @@ -581,34 +919,91 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B4 && PY_VERSION_HEX < 0x030d0000 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000) +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) + #define __Pyx_PyObject_GetIterNextFunc(obj) (Py_TYPE(obj)->tp_iternext) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) + #define __Pyx_PyObject_GetIterNextFunc(obj) PyIter_Next +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyObject_GenericSetAttr((PyObject*)tp, k, v) +#else + #define __Pyx_SetItemOnTypeDict(tp, k, v) PyDict_SetItem(tp->tp_dict, k, v) +#endif +#if CYTHON_USE_TYPE_SPECS && PY_VERSION_HEX >= 0x03080000 +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} #else -#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) #endif -#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) +#if CYTHON_COMPILING_IN_LIMITED_API #define CYTHON_PEP393_ENABLED 1 - #if defined(PyUnicode_IS_READY) - #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ - 0 : _PyUnicode_Ready((PyObject *)(op))) - #else #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GetLength(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#elif PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) #endif #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_KIND(u) ((int)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) - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) - #endif - #else - #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif #endif #else #define CYTHON_PEP393_ENABLED 0 @@ -618,11 +1013,11 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535U : 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((int)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_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = (Py_UNICODE) ch) #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) #endif #if CYTHON_COMPILING_IN_PYPY @@ -633,14 +1028,20 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #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) +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) || (PY_MAJOR_VERSION == 2 && PYPY_VERSION_NUM < 0x07030500) + #undef PyUnicode_Contains + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif #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)) @@ -669,8 +1070,14 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) #endif +#if CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif #ifndef PySet_CheckExact - #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) #endif #if PY_VERSION_HEX >= 0x030900A4 #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) @@ -680,15 +1087,42 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) #endif #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) #else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) +#endif +#if PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static CYTHON_INLINE PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } #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 __Pyx_Py3Int_Check(op) PyLong_Check(op) + #define __Pyx_Py3Int_CheckExact(op) PyLong_CheckExact(op) #define PyInt_FromString PyLong_FromString #define PyInt_FromUnicode PyLong_FromUnicode #define PyInt_FromLong PyLong_FromLong @@ -700,6 +1134,9 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask #define PyNumber_Int PyNumber_Long +#else + #define __Pyx_Py3Int_Check(op) (PyLong_Check(op) || PyInt_Check(op)) + #define __Pyx_Py3Int_CheckExact(op) (PyLong_CheckExact(op) || PyInt_CheckExact(op)) #endif #if PY_MAJOR_VERSION >= 3 #define PyBoolObject PyLongObject @@ -717,11 +1154,6 @@ static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_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 @@ -766,7 +1198,16 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_ERR(f_index, lineno, Ln_error) \ { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } -#ifndef __PYX_EXTERN_C +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else #ifdef __cplusplus #define __PYX_EXTERN_C extern "C" #else @@ -777,7 +1218,7 @@ static CYTHON_INLINE float __PYX_NAN() { #define __PYX_HAVE__dnet #define __PYX_HAVE_API__dnet /* Early includes */ -#include "bsd/string.h" +#include "string.h" #include "dnet.h" #ifdef _OPENMP #include @@ -827,9 +1268,10 @@ static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { #else #define __Pyx_sst_abs(value) ((value<0) ? -value : value) #endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); 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)) +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); #define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) #define __Pyx_PyBytes_FromString PyBytes_FromString #define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize @@ -847,9 +1289,9 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #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_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __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) @@ -857,11 +1299,22 @@ static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); #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) { +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const wchar_t *u) +{ + const wchar_t *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#else +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); } +#endif +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) #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 @@ -887,8 +1340,54 @@ static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); #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 CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif #if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +#include static int __Pyx_sys_getdefaultencoding_not_ascii; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -909,7 +1408,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { char ascii_chars[128]; int c; for (c = 0; c < 128; c++) { - ascii_chars[c] = c; + ascii_chars[c] = (char) c; } __Pyx_sys_getdefaultencoding_not_ascii = 1; ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); @@ -939,6 +1438,7 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #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 +#include static char* __PYX_DEFAULT_STRING_ENCODING; static int __Pyx_init_sys_getdefaultencoding_params(void) { PyObject* sys; @@ -974,23 +1474,29 @@ static int __Pyx_init_sys_getdefaultencoding_params(void) { #endif /* __GNUC__ */ static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#if !CYTHON_USE_MODULE_STATE 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; +#endif static int __pyx_lineno; static int __pyx_clineno = 0; -static const char * __pyx_cfilenm= __FILE__; +static const char * __pyx_cfilenm = __FILE__; static const char *__pyx_filename; +/* #### Code section: filename_table ### */ static const char *__pyx_f[] = { "dnet.pyx", - "stringsource", + "", }; +/* #### Code section: utility_code_proto_before_types ### */ +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* #### Code section: numeric_typedefs ### */ +/* #### Code section: complex_type_declarations ### */ +/* #### Code section: type_declarations ### */ /*--- Type declarations ---*/ struct __pyx_obj_4dnet_eth; @@ -1004,6 +1510,18 @@ struct __pyx_obj_4dnet_fw; struct __pyx_obj_4dnet_rand; struct __pyx_obj_4dnet___rand_xrange; struct __pyx_obj_4dnet_tun; +struct __pyx_defaults; +typedef struct __pyx_defaults __pyx_defaults; +struct __pyx_defaults1; +typedef struct __pyx_defaults1 __pyx_defaults1; +struct __pyx_defaults2; +typedef struct __pyx_defaults2 __pyx_defaults2; +struct __pyx_defaults3; +typedef struct __pyx_defaults3 __pyx_defaults3; +struct __pyx_defaults4; +typedef struct __pyx_defaults4 __pyx_defaults4; +struct __pyx_defaults5; +typedef struct __pyx_defaults5 __pyx_defaults5; /* "dnet.pyx":1398 * @@ -1018,6 +1536,39 @@ enum { __pyx_e_4dnet_TEASBOXSIZE = 0x80, __pyx_e_4dnet_TEASBOXSHIFT = 7 }; +struct __pyx_defaults { + PyObject *__pyx_arg_dst; + PyObject *__pyx_arg_src; + PyObject *__pyx_arg_etype; +}; +struct __pyx_defaults1 { + PyObject *__pyx_arg_tos; + PyObject *__pyx_arg_len; + PyObject *__pyx_arg_ttl; + PyObject *__pyx_arg_p; + PyObject *__pyx_arg_src; + PyObject *__pyx_arg_dst; +}; +struct __pyx_defaults2 { + PyObject *__pyx_arg_nxt; + PyObject *__pyx_arg_hlim; + PyObject *__pyx_arg_src; + PyObject *__pyx_arg_dst; +}; +struct __pyx_defaults3 { + PyObject *__pyx_arg_op; + PyObject *__pyx_arg_sha; + PyObject *__pyx_arg_spa; + PyObject *__pyx_arg_dha; + PyObject *__pyx_arg_dpa; +}; +struct __pyx_defaults4 { + PyObject *__pyx_arg_flags; + PyObject *__pyx_arg_win; +}; +struct __pyx_defaults5 { + PyObject *__pyx_arg_ulen; +}; /* "dnet.pyx":104 * ETH_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff\xff\xff", 6) @@ -1174,6 +1725,7 @@ struct __pyx_obj_4dnet_tun { int mtu; }; +/* #### Code section: utility_code_proto ### */ /* --- Runtime support code (head) --- */ /* Refnanny.proto */ @@ -1182,11 +1734,11 @@ struct __pyx_obj_4dnet_tun { #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 (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); void (*FinishContext)(void**); } __Pyx_RefNannyAPIStruct; static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; @@ -1196,28 +1748,40 @@ struct __pyx_obj_4dnet_tun { #define __Pyx_RefNannySetupContext(name, acquire_gil)\ if (acquire_gil) {\ PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ PyGILState_Release(__pyx_gilstate_save);\ } else {\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ } #else #define __Pyx_RefNannySetupContext(name, acquire_gil)\ - __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__)) + #define __Pyx_RefNannyFinishContextNogil() __Pyx_RefNannyFinishContext() #endif + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } #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) + #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); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) #else #define __Pyx_RefNannyDeclarations #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() #define __Pyx_RefNannyFinishContext() #define __Pyx_INCREF(r) Py_INCREF(r) #define __Pyx_DECREF(r) Py_DECREF(r) @@ -1228,6 +1792,10 @@ struct __pyx_obj_4dnet_tun { #define __Pyx_XGOTREF(r) #define __Pyx_XGIVEREF(r) #endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) #define __Pyx_XDECREF_SET(r, v) do {\ PyObject *tmp = (PyObject *) r;\ r = v; __Pyx_XDECREF(tmp);\ @@ -1239,48 +1807,30 @@ struct __pyx_obj_4dnet_tun { #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); +/* 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_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) -#endif - -/* GetBuiltinName.proto */ -static PyObject *__Pyx_GetBuiltinName(PyObject *name); - -/* GCCDiagnostics.proto */ -#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) -#define __Pyx_HAS_GCC_DIAGNOSTIC +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) #endif -/* BuildPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, - int prepend_sign, char padding_char); - -/* IncludeStringH.proto */ -#include - -/* CIntToPyUnicode.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); - -/* PyObjectFormatAndDecref.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); -static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); - -/* JoinPyUnicode.proto */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - Py_UCS4 max_char); - /* 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 +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif #else #define __Pyx_PyThreadState_declare #define __Pyx_PyThreadState_assign -#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() #endif /* PyErrFetchRestore.proto */ @@ -1292,7 +1842,7 @@ static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_co #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 +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 #define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) #else #define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) @@ -1308,9 +1858,106 @@ static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject #define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) #endif +/* 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 + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* BuildPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, + int prepend_sign, char padding_char); + +/* IncludeStringH.proto */ +#include + +/* CIntToPyUnicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); + +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); + +/* JoinPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + /* RaiseException.proto */ static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* 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); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_VARARGS(args, i) PySequence_GetItem(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GET_ITEM(args, i) +#else + #define __Pyx_Arg_VARARGS(args, i) PyTuple_GetItem(args, i) +#endif +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_Arg_NewRef_VARARGS(arg) __Pyx_NewRef(arg) + #define __Pyx_Arg_XDECREF_VARARGS(arg) Py_XDECREF(arg) +#else + #define __Pyx_Arg_NewRef_VARARGS(arg) arg + #define __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_Arg_FASTCALL(args, i) args[i] + #define __Pyx_NumKwargs_FASTCALL(kwds) PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif + #define __Pyx_Arg_NewRef_FASTCALL(arg) arg /* no-op, __Pyx_Arg_FASTCALL is direct and this needs + to have the same reference counting */ + #define __Pyx_Arg_XDECREF_FASTCALL(arg) +#else + #define __Pyx_Arg_FASTCALL __Pyx_Arg_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS + #define __Pyx_Arg_NewRef_FASTCALL(arg) __Pyx_Arg_NewRef_VARARGS(arg) + #define __Pyx_Arg_XDECREF_FASTCALL(arg) __Pyx_Arg_XDECREF_VARARGS(arg) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_VARARGS(args, start), stop - start) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(&__Pyx_Arg_FASTCALL(args, start), stop - start) +#else +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#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); @@ -1319,8 +1966,9 @@ static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, 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,\ +static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject *const *kwvalues, + PyObject **argnames[], + PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args, const char* function_name); /* ListAppend.proto */ @@ -1330,7 +1978,11 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { Py_ssize_t len = Py_SIZE(list); if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else PyList_SET_ITEM(list, len, x); + #endif __Pyx_SET_SIZE(list, len + 1); return 0; } @@ -1340,42 +1992,39 @@ static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { #define __Pyx_PyList_Append(L,x) PyList_Append(L,x) #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 - /* PyFunctionFastCall.proto */ #if CYTHON_FAST_PYCALL +#if !CYTHON_VECTORCALL #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 -#if CYTHON_FAST_PYCALL - static size_t __pyx_pyframe_localsplus_offset = 0; +#if !CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03080000 #include "frameobject.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif + #define __Pxy_PyFrame_Initialize_Offsets() + #define __Pyx_PyFrame_GetLocalsplus(frame) ((frame)->f_localsplus) +#else + 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 // CYTHON_FAST_PYCALL +#endif +#endif #endif /* PyObjectCall.proto */ @@ -1385,14 +2034,18 @@ static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg #define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) #endif -/* PyObjectCall2Args.proto */ -static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); - /* PyObjectCallMethO.proto */ #if CYTHON_COMPILING_IN_CPYTHON static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); #endif +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs); + +/* PyObjectCall2Args.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + /* PyObjectCallOneArg.proto */ static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); @@ -1406,7 +2059,7 @@ static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); /* KeywordStringCheck.proto */ -static int __Pyx_CheckKeywordStrings(PyObject *kwdict, const char* function_name, int kw_allowed); +static int __Pyx_CheckKeywordStrings(PyObject *kw, const char* function_name, int kw_allowed); /* PyDictVersioning.proto */ #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS @@ -1436,18 +2089,18 @@ static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UIN /* GetModuleGlobalName.proto */ #if CYTHON_USE_DICT_VERSIONS -#define __Pyx_GetModuleGlobalName(var, name) {\ +#define __Pyx_GetModuleGlobalName(var, name) do {\ 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) {\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ PY_UINT64_T __pyx_dict_version;\ PyObject *__pyx_dict_cached_value;\ (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ -} +} while(0) 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) @@ -1465,32 +2118,20 @@ static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr #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 /* ArgTypeTest.proto */ #define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ - ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + ((likely(__Pyx_IS_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); -/* 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 - -/* GetAttr.proto */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); - /* GetAttr3.proto */ static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); + /* RaiseTooManyValuesToUnpack.proto */ static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); @@ -1548,8 +2189,34 @@ static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); /* ImportFrom.proto */ static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + /* HasAttr.proto */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* IncludeStructmemberH.proto */ +#include + +/* FixUpExtensionType.proto */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); +#endif + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); /* PyObject_GenericGetAttrNoDict.proto */ #if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 @@ -1565,11 +2232,150 @@ static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_nam #define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr #endif -/* PyObjectGetAttrStrNoError.proto */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); - /* SetupReduce.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API static int __Pyx_setup_reduce(PyObject* type_obj); +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type); +#else +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases); +#endif + +/* PyMethodNew.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *typesModule=NULL, *methodType=NULL, *result=NULL; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + typesModule = PyImport_ImportModule("types"); + if (!typesModule) return NULL; + methodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + if (!methodType) return NULL; + result = PyObject_CallFunctionObjArgs(methodType, func, self, NULL); + Py_DECREF(methodType); + return result; +} +#elif PY_MAJOR_VERSION >= 3 +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#else + #define __Pyx_PyMethod_New PyMethod_New +#endif + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_BACKPORT_VECTORCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif + PyObject *func_dict; + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + void *defaults; + int defaults_pyobjects; + size_t defaults_size; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m, + size_t size, + int pyobjects); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_BACKPORT_VECTORCALL +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); /* CLineInTraceback.proto */ #ifdef CYTHON_CLINE_IN_TRACEBACK @@ -1579,6 +2385,7 @@ static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); #endif /* CodeObjectCache.proto */ +#if !CYTHON_COMPILING_IN_LIMITED_API typedef struct { PyCodeObject* code_object; int code_line; @@ -1592,6 +2399,7 @@ 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); +#endif /* AddTraceback.proto */ static void __Pyx_AddTraceback(const char *funcname, int c_line, @@ -1627,38 +2435,46 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) /* CIntToPy.proto */ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +static __Pyx_TypeName __Pyx_PyType_GetName(PyTypeObject* tp); +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#else +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + /* FastTypeChecks.proto */ #if CYTHON_COMPILING_IN_CPYTHON #define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, 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_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) #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_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) #define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) /* CheckBinaryVersion.proto */ -static int __Pyx_check_binary_version(void); +static unsigned long __Pyx_get_runtime_version(void); +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); /* InitStrings.proto */ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t); +/* #### Code section: module_declarations ### */ -/* Module declarations from 'dnet' */ -static PyTypeObject *__pyx_ptype_4dnet_eth = 0; -static PyTypeObject *__pyx_ptype_4dnet_ip = 0; -static PyTypeObject *__pyx_ptype_4dnet_addr = 0; -static PyTypeObject *__pyx_ptype_4dnet___addr_ip4_iter = 0; -static PyTypeObject *__pyx_ptype_4dnet_arp = 0; -static PyTypeObject *__pyx_ptype_4dnet_intf = 0; -static PyTypeObject *__pyx_ptype_4dnet_route = 0; -static PyTypeObject *__pyx_ptype_4dnet_fw = 0; -static PyTypeObject *__pyx_ptype_4dnet_rand = 0; -static PyTypeObject *__pyx_ptype_4dnet___rand_xrange = 0; -static PyTypeObject *__pyx_ptype_4dnet_tun = 0; +/* Module declarations from "dnet" */ static PyObject *__pyx_f_4dnet___memcpy(char *, PyObject *, int); /*proto*/ static PyObject *__pyx_f_4dnet___oserror(void); /*proto*/ static int __pyx_f_4dnet___arp_callback(struct arp_entry *, void *); /*proto*/ @@ -1670,17 +2486,22 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *); /*proto*/ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *, struct fw_rule *); /*proto*/ static int __pyx_f_4dnet___fw_callback(struct fw_rule *, void *); /*proto*/ static PyObject *__pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(struct __pyx_obj_4dnet___addr_ip4_iter *, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +/* #### Code section: before_global_var ### */ #define __Pyx_MODULE_NAME "dnet" extern int __pyx_module_is_main_dnet; int __pyx_module_is_main_dnet = 0; -/* Implementation of 'dnet' */ +/* Implementation of "dnet" */ +/* #### Code section: global_var ### */ static PyObject *__pyx_builtin_ValueError; static PyObject *__pyx_builtin_OSError; static PyObject *__pyx_builtin_TypeError; static PyObject *__pyx_builtin_OverflowError; static PyObject *__pyx_builtin_NotImplementedError; static PyObject *__pyx_builtin_StopIteration; +/* #### Code section: string_decls ### */ +static const char __pyx_k_a[] = "a"; static const char __pyx_k_d[] = "d"; static const char __pyx_k_i[] = "i"; static const char __pyx_k_l[] = "l"; @@ -1688,12 +2509,14 @@ static const char __pyx_k_n[] = "n"; static const char __pyx_k_p[] = "p"; static const char __pyx_k_r[] = "r"; static const char __pyx_k_s[] = "s"; +static const char __pyx_k__3[] = "."; static const char __pyx_k_dh[] = "dh"; static const char __pyx_k_dp[] = "dp"; static const char __pyx_k_ea[] = "ea"; static const char __pyx_k_fc[] = "fc"; static const char __pyx_k_fl[] = "fl"; static const char __pyx_k_fw[] = "fw"; +static const char __pyx_k_gc[] = "gc"; static const char __pyx_k_gw[] = "gw"; static const char __pyx_k_ha[] = "ha"; static const char __pyx_k_ia[] = "ia"; @@ -1705,6 +2528,7 @@ static const char __pyx_k_sh[] = "sh"; static const char __pyx_k_sp[] = "sp"; static const char __pyx_k_BSD[] = "BSD"; static const char __pyx_k_ack[] = "ack"; +static const char __pyx_k_add[] = "add"; static const char __pyx_k_arg[] = "arg"; static const char __pyx_k_arp[] = "arp"; static const char __pyx_k_buf[] = "buf"; @@ -1714,17 +2538,20 @@ static const char __pyx_k_dir[] = "dir"; static const char __pyx_k_dpa[] = "dpa"; static const char __pyx_k_dst[] = "dst"; static const char __pyx_k_eth[] = "eth"; +static const char __pyx_k_get[] = "get"; static const char __pyx_k_hdr[] = "hdr"; static const char __pyx_k_int[] = "__int__"; static const char __pyx_k_ip6[] = "ip6"; static const char __pyx_k_len[] = "len"; static const char __pyx_k_max[] = "max"; static const char __pyx_k_mtu[] = "mtu"; +static const char __pyx_k_net[] = "net"; static const char __pyx_k_new[] = "__new__"; static const char __pyx_k_nxt[] = "nxt"; static const char __pyx_k_off[] = "off"; static const char __pyx_k_pkt[] = "pkt"; static const char __pyx_k_seq[] = "seq"; +static const char __pyx_k_set[] = "set"; static const char __pyx_k_sha[] = "sha"; static const char __pyx_k_spa[] = "spa"; static const char __pyx_k_src[] = "src"; @@ -1735,6 +2562,7 @@ static const char __pyx_k_tun[] = "tun"; static const char __pyx_k_url[] = "__url__"; static const char __pyx_k_urp[] = "urp"; static const char __pyx_k_win[] = "win"; +static const char __pyx_k__120[] = "?"; static const char __pyx_k_addr[] = "addr"; static const char __pyx_k_code[] = "code"; static const char __pyx_k_copy[] = "__copy__"; @@ -1747,6 +2575,10 @@ static const char __pyx_k_main[] = "__main__"; static const char __pyx_k_name[] = "name"; static const char __pyx_k_plen[] = "plen"; static const char __pyx_k_rand[] = "rand"; +static const char __pyx_k_recv[] = "recv"; +static const char __pyx_k_rule[] = "rule"; +static const char __pyx_k_self[] = "self"; +static const char __pyx_k_send[] = "send"; static const char __pyx_k_stop[] = "stop"; static const char __pyx_k_test[] = "__test__"; static const char __pyx_k_type[] = "type"; @@ -1754,17 +2586,25 @@ static const char __pyx_k_ulen[] = "ulen"; static const char __pyx_k_IP_DF[] = "IP_DF"; static const char __pyx_k_IP_MF[] = "IP_MF"; static const char __pyx_k_IP_RF[] = "IP_RF"; +static const char __pyx_k_arg_2[] = "_arg"; +static const char __pyx_k_bcast[] = "bcast"; +static const char __pyx_k_close[] = "close"; static const char __pyx_k_dport[] = "dport"; static const char __pyx_k_entry[] = "entry"; static const char __pyx_k_etype[] = "etype"; static const char __pyx_k_flags[] = "flags"; +static const char __pyx_k_frame[] = "frame"; +static const char __pyx_k_ifent[] = "ifent"; static const char __pyx_k_itype[] = "itype"; static const char __pyx_k_not_a[] = "not a "; static const char __pyx_k_proto[] = "proto"; static const char __pyx_k_route[] = "route"; static const char __pyx_k_sport[] = "sport"; static const char __pyx_k_start[] = "start"; -static const char __pyx_k_1_16_2[] = "1.16.2"; +static const char __pyx_k_state[] = "state"; +static const char __pyx_k_uint8[] = "uint8"; +static const char __pyx_k_value[] = "value"; +static const char __pyx_k_1_18_0[] = "1.18.0"; static const char __pyx_k_TH_ACK[] = "TH_ACK"; static const char __pyx_k_TH_CWR[] = "TH_CWR"; static const char __pyx_k_TH_ECE[] = "TH_ECE"; @@ -1774,38 +2614,71 @@ static const char __pyx_k_TH_SYN[] = "TH_SYN"; static const char __pyx_k_TH_URG[] = "TH_URG"; static const char __pyx_k_append[] = "append"; static const char __pyx_k_author[] = "__author__"; +static const char __pyx_k_delete[] = "delete"; static const char __pyx_k_device[] = "device"; +static const char __pyx_k_dict_2[] = "_dict"; +static const char __pyx_k_enable[] = "enable"; +static const char __pyx_k_fileno[] = "fileno"; +static const char __pyx_k_fw_add[] = "fw.add"; static const char __pyx_k_import[] = "__import__"; static const char __pyx_k_name_2[] = "__name__"; static const char __pyx_k_pickle[] = "pickle"; static const char __pyx_k_reduce[] = "__reduce__"; +static const char __pyx_k_uint16[] = "uint16"; +static const char __pyx_k_uint32[] = "uint32"; static const char __pyx_k_update[] = "update"; +static const char __pyx_k_xrange[] = "xrange"; static const char __pyx_k_ETH_MIN[] = "ETH_MIN"; static const char __pyx_k_ETH_MTU[] = "ETH_MTU"; static const char __pyx_k_OSError[] = "OSError"; static const char __pyx_k_TH_PUSH[] = "TH_PUSH"; static const char __pyx_k_addrtxt[] = "addrtxt"; +static const char __pyx_k_arp_add[] = "arp.add"; +static const char __pyx_k_arp_get[] = "arp.get"; +static const char __pyx_k_disable[] = "disable"; +static const char __pyx_k_eth_get[] = "eth.get"; +static const char __pyx_k_eth_set[] = "eth.set"; +static const char __pyx_k_fw_loop[] = "fw.loop"; +static const char __pyx_k_get_dst[] = "get_dst"; +static const char __pyx_k_get_src[] = "get_src"; static const char __pyx_k_ip_aton[] = "ip_aton"; static const char __pyx_k_ip_ntoa[] = "ip_ntoa"; +static const char __pyx_k_ip_send[] = "ip.send"; static const char __pyx_k_license[] = "__license__"; static const char __pyx_k_version[] = "__version__"; +static const char __pyx_k_addr_net[] = "addr.net"; static const char __pyx_k_addrtype[] = "addrtype"; +static const char __pyx_k_arp_loop[] = "arp.loop"; static const char __pyx_k_callback[] = "callback"; static const char __pyx_k_dnet_pyx[] = "dnet.pyx"; static const char __pyx_k_dst_addr[] = "dst_addr"; static const char __pyx_k_eth_aton[] = "eth_aton"; static const char __pyx_k_eth_ntoa[] = "eth_ntoa"; +static const char __pyx_k_eth_send[] = "eth.send"; static const char __pyx_k_getstate[] = "__getstate__"; +static const char __pyx_k_intf_get[] = "intf.get"; +static const char __pyx_k_intf_set[] = "intf.set"; static const char __pyx_k_ip6_aton[] = "ip6_aton"; static const char __pyx_k_ip6_ntoa[] = "ip6_ntoa"; static const char __pyx_k_pyx_type[] = "__pyx_type"; +static const char __pyx_k_rand_add[] = "rand.add"; +static const char __pyx_k_rand_get[] = "rand.get"; +static const char __pyx_k_rand_set[] = "rand.set"; static const char __pyx_k_setstate[] = "__setstate__"; +static const char __pyx_k_tun_recv[] = "tun.recv"; +static const char __pyx_k_tun_send[] = "tun.send"; static const char __pyx_k_FW_DIR_IN[] = "FW_DIR_IN"; static const char __pyx_k_TypeError[] = "TypeError"; static const char __pyx_k_copyright[] = "__copyright__"; +static const char __pyx_k_fw_delete[] = "fw.delete"; +static const char __pyx_k_intf_loop[] = "intf.loop"; +static const char __pyx_k_isenabled[] = "isenabled"; static const char __pyx_k_link_addr[] = "link_addr"; static const char __pyx_k_pyx_state[] = "__pyx_state"; static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_route_add[] = "route.add"; +static const char __pyx_k_route_get[] = "route.get"; +static const char __pyx_k_tun_close[] = "tun.close"; static const char __pyx_k_ARP_PRO_IP[] = "ARP_PRO_IP"; static const char __pyx_k_FW_DIR_OUT[] = "FW_DIR_OUT"; static const char __pyx_k_IP_HDR_LEN[] = "IP_HDR_LEN"; @@ -1816,7 +2689,12 @@ static const char __pyx_k_IP_OPT_LEN[] = "IP_OPT_LEN"; static const char __pyx_k_IP_TTL_MAX[] = "IP_TTL_MAX"; static const char __pyx_k_TCP_OPT_CC[] = "TCP_OPT_CC"; static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_addr_bcast[] = "addr.bcast"; +static const char __pyx_k_arp_delete[] = "arp.delete"; static const char __pyx_k_pyx_result[] = "__pyx_result"; +static const char __pyx_k_rand_uint8[] = "rand.uint8"; +static const char __pyx_k_route_loop[] = "route.loop"; +static const char __pyx_k_tun_fileno[] = "tun.fileno"; static const char __pyx_k_ARP_HDR_LEN[] = "ARP_HDR_LEN"; static const char __pyx_k_ARP_HRD_ETH[] = "ARP_HRD_ETH"; static const char __pyx_k_ETH_CRC_LEN[] = "ETH_CRC_LEN"; @@ -1844,10 +2722,13 @@ static const char __pyx_k_TCP_OPT_NOP[] = "TCP_OPT_NOP"; static const char __pyx_k_TCP_OPT_REC[] = "TCP_OPT_REC"; static const char __pyx_k_TCP_WIN_MAX[] = "TCP_WIN_MAX"; static const char __pyx_k_UDP_HDR_LEN[] = "UDP_HDR_LEN"; +static const char __pyx_k_addr___copy[] = "addr.__copy__"; static const char __pyx_k_alias_addrs[] = "alias_addrs"; static const char __pyx_k_ip_checksum[] = "ip_checksum"; static const char __pyx_k_ip_pack_hdr[] = "ip_pack_hdr"; static const char __pyx_k_iter_append[] = "__iter_append"; +static const char __pyx_k_rand_uint16[] = "rand.uint16"; +static const char __pyx_k_rand_uint32[] = "rand.uint32"; static const char __pyx_k_rand_xrange[] = "__rand_xrange"; static const char __pyx_k_ADDR_TYPE_IP[] = "ADDR_TYPE_IP"; static const char __pyx_k_ARP_OP_REPLY[] = "ARP_OP_REPLY"; @@ -1872,13 +2753,18 @@ static const char __pyx_k_TCP_OPT_SNAP[] = "TCP_OPT_SNAP"; static const char __pyx_k_TCP_PORT_MAX[] = "TCP_PORT_MAX"; static const char __pyx_k_UDP_PORT_MAX[] = "UDP_PORT_MAX"; static const char __pyx_k_eth_pack_hdr[] = "eth_pack_hdr"; +static const char __pyx_k_intf_get_dst[] = "intf.get_dst"; +static const char __pyx_k_intf_get_src[] = "intf.get_src"; static const char __pyx_k_ip6_checksum[] = "ip6_checksum"; static const char __pyx_k_ip6_pack_hdr[] = "ip6_pack_hdr"; static const char __pyx_k_ip_cksum_add[] = "ip_cksum_add"; +static const char __pyx_k_is_coroutine[] = "_is_coroutine"; static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; -static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_route_delete[] = "route.delete"; +static const char __pyx_k_stringsource[] = ""; static const char __pyx_k_tcp_pack_hdr[] = "tcp_pack_hdr"; static const char __pyx_k_udp_pack_hdr[] = "udp_pack_hdr"; +static const char __pyx_k_use_setstate[] = "use_setstate"; static const char __pyx_k_ADDR_TYPE_ETH[] = "ADDR_TYPE_ETH"; static const char __pyx_k_ADDR_TYPE_IP6[] = "ADDR_TYPE_IP6"; static const char __pyx_k_ARP_ETHIP_LEN[] = "ARP_ETHIP_LEN"; @@ -1899,6 +2785,7 @@ static const char __pyx_k_TCP_OPT_POSVC[] = "TCP_OPT_POSVC"; static const char __pyx_k_TCP_OPT_SNACK[] = "TCP_OPT_SNACK"; static const char __pyx_k_addr_ip4_iter[] = "__addr_ip4_iter"; static const char __pyx_k_icmp_pack_hdr[] = "icmp_pack_hdr"; +static const char __pyx_k_rand_xrange_2[] = "rand.xrange"; static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; static const char __pyx_k_ADDR_TYPE_NONE[] = "ADDR_TYPE_NONE"; static const char __pyx_k_ARP_OP_REQUEST[] = "ARP_OP_REQUEST"; @@ -1946,348 +2833,64 @@ static const char __pyx_k_INTF_FLAG_LOOPBACK[] = "INTF_FLAG_LOOPBACK"; static const char __pyx_k_INTF_TYPE_LOOPBACK[] = "INTF_TYPE_LOOPBACK"; static const char __pyx_k_TCP_OPT_ALTSUMDATA[] = "TCP_OPT_ALTSUMDATA"; static const char __pyx_k_arp_pack_hdr_ethip[] = "arp_pack_hdr_ethip"; +static const char __pyx_k_asyncio_coroutines[] = "asyncio.coroutines"; static const char __pyx_k_byte_binary_string[] = "-byte binary string: "; static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_fw___reduce_cython[] = "fw.__reduce_cython__"; static const char __pyx_k_invalid_IP_address[] = "invalid IP address"; +static const char __pyx_k_ip___reduce_cython[] = "ip.__reduce_cython__"; static const char __pyx_k_ETH_TYPE_MPLS_MCAST[] = "ETH_TYPE_MPLS_MCAST"; static const char __pyx_k_INTF_FLAG_BROADCAST[] = "INTF_FLAG_BROADCAST"; static const char __pyx_k_INTF_FLAG_MULTICAST[] = "INTF_FLAG_MULTICAST"; static const char __pyx_k_IP_ADDR_MCAST_LOCAL[] = "IP_ADDR_MCAST_LOCAL"; static const char __pyx_k_NotImplementedError[] = "NotImplementedError"; +static const char __pyx_k_arp___reduce_cython[] = "arp.__reduce_cython__"; +static const char __pyx_k_eth___reduce_cython[] = "eth.__reduce_cython__"; static const char __pyx_k_not_a_4_byte_string[] = "not a 4-byte string"; static const char __pyx_k_not_a_6_byte_string[] = "not a 6-byte string"; +static const char __pyx_k_tun___reduce_cython[] = "tun.__reduce_cython__"; +static const char __pyx_k_addr___reduce_cython[] = "addr.__reduce_cython__"; +static const char __pyx_k_fw___setstate_cython[] = "fw.__setstate_cython__"; +static const char __pyx_k_intf___reduce_cython[] = "intf.__reduce_cython__"; static const char __pyx_k_invalid_IPv6_address[] = "invalid IPv6 address"; +static const char __pyx_k_ip___setstate_cython[] = "ip.__setstate_cython__"; static const char __pyx_k_non_Ethernet_address[] = "non-Ethernet address"; static const char __pyx_k_not_a_16_byte_string[] = "not a 16-byte string"; +static const char __pyx_k_rand___reduce_cython[] = "rand.__reduce_cython__"; static const char __pyx_k_INTF_FLAG_POINTOPOINT[] = "INTF_FLAG_POINTOPOINT"; +static const char __pyx_k_arp___setstate_cython[] = "arp.__setstate_cython__"; +static const char __pyx_k_eth___setstate_cython[] = "eth.__setstate_cython__"; +static const char __pyx_k_route___reduce_cython[] = "route.__reduce_cython__"; +static const char __pyx_k_tun___setstate_cython[] = "tun.__setstate_cython__"; +static const char __pyx_k_addr___setstate_cython[] = "addr.__setstate_cython__"; +static const char __pyx_k_intf___setstate_cython[] = "intf.__setstate_cython__"; +static const char __pyx_k_rand___setstate_cython[] = "rand.__setstate_cython__"; static const char __pyx_k_invalid_network_address[] = "invalid network address"; +static const char __pyx_k_route___setstate_cython[] = "route.__setstate_cython__"; static const char __pyx_k_stop_must_be_an_integer[] = "stop must be an integer"; static const char __pyx_k_invalid_Ethernet_address[] = "invalid Ethernet address"; static const char __pyx_k_start_must_be_an_integer[] = "start must be an integer"; static const char __pyx_k_invalid_network_address_2[] = ""; -static const char __pyx_k_Copyright_c_2023_Oliver_Falk[] = "Copyright (c) 2023 Oliver Falk"; +static const char __pyx_k_rand_xrange___reduce_cython[] = "__rand_xrange.__reduce_cython__"; static const char __pyx_k_pyx_unpickle___addr_ip4_iter[] = "__pyx_unpickle___addr_ip4_iter"; +static const char __pyx_k_addr_ip4_iter___reduce_cython[] = "__addr_ip4_iter.__reduce_cython__"; +static const char __pyx_k_rand_xrange___setstate_cython[] = "__rand_xrange.__setstate_cython__"; +static const char __pyx_k_addr_ip4_iter___setstate_cytho[] = "__addr_ip4_iter.__setstate_cython__"; static const char __pyx_k_https_github_com_ofalk_libdnet[] = "https://github.com/ofalk/libdnet"; static const char __pyx_k_Oliver_Falk_oliver_linux_kernel[] = "Oliver Falk "; static const char __pyx_k_Pickling_of_struct_members_such[] = "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)"; static const char __pyx_k_self_arp_cannot_be_converted_to[] = "self.arp cannot be converted to a Python object for pickling"; static const char __pyx_k_self_eth_cannot_be_converted_to[] = "self.eth cannot be converted to a Python object for pickling"; static const char __pyx_k_self_tun_cannot_be_converted_to[] = "self.tun cannot be converted to a Python object for pickling"; -static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xd0a7020, 0x6aff466, 0x6c108d3) = (cur, max))"; +static const char __pyx_k_Copyright_c_2023_2024_Oliver_Fal[] = "Copyright (c) 2023-2024 Oliver Falk"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))"; static const char __pyx_k_dumb_networking_library_This_mod[] = "dumb networking library\n\nThis module provides a simplified interface to several low-level\nnetworking routines, including network address manipulation, kernel\narp(4) cache and route(4) table lookup and manipulation, network\nfirewalling, network interface lookup and manipulation, IP tunnelling,\nand raw IP packet and Ethernet frame transmission.\n"; static const char __pyx_k_self_fw_cannot_be_converted_to_a[] = "self.fw cannot be converted to a Python object for pickling"; static const char __pyx_k_self_intf_cannot_be_converted_to[] = "self.intf cannot be converted to a Python object for pickling"; static const char __pyx_k_self_ip_cannot_be_converted_to_a[] = "self.ip cannot be converted to a Python object for pickling"; static const char __pyx_k_self_rand_cannot_be_converted_to[] = "self.rand cannot be converted to a Python object for pickling"; static const char __pyx_k_self_route_cannot_be_converted_t[] = "self.route cannot be converted to a Python object for pickling"; -static PyObject *__pyx_kp_u_1_16_2; -static PyObject *__pyx_n_s_ADDR_TYPE_ETH; -static PyObject *__pyx_n_s_ADDR_TYPE_IP; -static PyObject *__pyx_n_s_ADDR_TYPE_IP6; -static PyObject *__pyx_n_s_ADDR_TYPE_NONE; -static PyObject *__pyx_n_s_ARP_ETHIP_LEN; -static PyObject *__pyx_n_s_ARP_HDR_LEN; -static PyObject *__pyx_n_s_ARP_HRD_ETH; -static PyObject *__pyx_n_s_ARP_HRD_IEEE802; -static PyObject *__pyx_n_s_ARP_OP_REPLY; -static PyObject *__pyx_n_s_ARP_OP_REQUEST; -static PyObject *__pyx_n_s_ARP_OP_REVREPLY; -static PyObject *__pyx_n_s_ARP_OP_REVREQUEST; -static PyObject *__pyx_n_s_ARP_PRO_IP; -static PyObject *__pyx_n_u_BSD; -static PyObject *__pyx_kp_u_Copyright_c_2023_Oliver_Falk; -static PyObject *__pyx_n_s_ETH_ADDR_BITS; -static PyObject *__pyx_n_s_ETH_ADDR_BROADCAST; -static PyObject *__pyx_n_s_ETH_ADDR_LEN; -static PyObject *__pyx_n_s_ETH_ADDR_UNSPEC; -static PyObject *__pyx_n_s_ETH_CRC_LEN; -static PyObject *__pyx_n_s_ETH_HDR_LEN; -static PyObject *__pyx_n_s_ETH_LEN_MAX; -static PyObject *__pyx_n_s_ETH_LEN_MIN; -static PyObject *__pyx_n_s_ETH_MIN; -static PyObject *__pyx_n_s_ETH_MTU; -static PyObject *__pyx_n_s_ETH_TYPE_8021Q; -static PyObject *__pyx_n_s_ETH_TYPE_ARP; -static PyObject *__pyx_n_s_ETH_TYPE_IP; -static PyObject *__pyx_n_s_ETH_TYPE_IPV6; -static PyObject *__pyx_n_s_ETH_TYPE_LEN; -static PyObject *__pyx_n_s_ETH_TYPE_LOOPBACK; -static PyObject *__pyx_n_s_ETH_TYPE_MPLS; -static PyObject *__pyx_n_s_ETH_TYPE_MPLS_MCAST; -static PyObject *__pyx_n_s_ETH_TYPE_PPPOE; -static PyObject *__pyx_n_s_ETH_TYPE_PPPOEDISC; -static PyObject *__pyx_n_s_ETH_TYPE_PUP; -static PyObject *__pyx_n_s_ETH_TYPE_REVARP; -static PyObject *__pyx_n_s_FW_DIR_IN; -static PyObject *__pyx_n_s_FW_DIR_OUT; -static PyObject *__pyx_n_s_FW_OP_ALLOW; -static PyObject *__pyx_n_s_FW_OP_BLOCK; -static PyObject *__pyx_n_s_INTF_FLAG_BROADCAST; -static PyObject *__pyx_n_s_INTF_FLAG_LOOPBACK; -static PyObject *__pyx_n_s_INTF_FLAG_MULTICAST; -static PyObject *__pyx_n_s_INTF_FLAG_NOARP; -static PyObject *__pyx_n_s_INTF_FLAG_POINTOPOINT; -static PyObject *__pyx_n_s_INTF_FLAG_UP; -static PyObject *__pyx_n_s_INTF_TYPE_ETH; -static PyObject *__pyx_n_s_INTF_TYPE_LOOPBACK; -static PyObject *__pyx_n_s_INTF_TYPE_OTHER; -static PyObject *__pyx_n_s_INTF_TYPE_TUN; -static PyObject *__pyx_n_s_IP6_ADDR_BITS; -static PyObject *__pyx_n_s_IP6_ADDR_LEN; -static PyObject *__pyx_n_s_IP6_ADDR_LOOPBACK; -static PyObject *__pyx_n_s_IP6_ADDR_UNSPEC; -static PyObject *__pyx_n_s_IP6_HDR_LEN; -static PyObject *__pyx_n_s_IP6_HLIM_DEFAULT; -static PyObject *__pyx_n_s_IP6_HLIM_MAX; -static PyObject *__pyx_n_s_IP6_LEN_MAX; -static PyObject *__pyx_n_s_IP6_LEN_MIN; -static PyObject *__pyx_n_s_IP6_MTU_MIN; -static PyObject *__pyx_n_s_IP_ADDR_ANY; -static PyObject *__pyx_n_s_IP_ADDR_BITS; -static PyObject *__pyx_n_s_IP_ADDR_BROADCAST; -static PyObject *__pyx_n_s_IP_ADDR_LEN; -static PyObject *__pyx_n_s_IP_ADDR_LOOPBACK; -static PyObject *__pyx_n_s_IP_ADDR_MCAST_ALL; -static PyObject *__pyx_n_s_IP_ADDR_MCAST_LOCAL; -static PyObject *__pyx_n_s_IP_DF; -static PyObject *__pyx_n_s_IP_HDR_LEN; -static PyObject *__pyx_n_s_IP_HDR_LEN_MAX; -static PyObject *__pyx_n_s_IP_LEN_MAX; -static PyObject *__pyx_n_s_IP_LEN_MIN; -static PyObject *__pyx_n_s_IP_MF; -static PyObject *__pyx_n_s_IP_OFFMASK; -static PyObject *__pyx_n_s_IP_OPT_LEN; -static PyObject *__pyx_n_s_IP_OPT_LEN_MAX; -static PyObject *__pyx_n_s_IP_PROTO_AH; -static PyObject *__pyx_n_s_IP_PROTO_ESP; -static PyObject *__pyx_n_s_IP_PROTO_GRE; -static PyObject *__pyx_n_s_IP_PROTO_ICMP; -static PyObject *__pyx_n_s_IP_PROTO_ICMPV6; -static PyObject *__pyx_n_s_IP_PROTO_IGMP; -static PyObject *__pyx_n_s_IP_PROTO_IP; -static PyObject *__pyx_n_s_IP_PROTO_IPV6; -static PyObject *__pyx_n_s_IP_PROTO_MAX; -static PyObject *__pyx_n_s_IP_PROTO_RAW; -static PyObject *__pyx_n_s_IP_PROTO_RESERVED; -static PyObject *__pyx_n_s_IP_PROTO_TCP; -static PyObject *__pyx_n_s_IP_PROTO_UDP; -static PyObject *__pyx_n_s_IP_RF; -static PyObject *__pyx_n_s_IP_TOS_DEFAULT; -static PyObject *__pyx_n_s_IP_TTL_DEFAULT; -static PyObject *__pyx_n_s_IP_TTL_MAX; -static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; -static PyObject *__pyx_n_s_NotImplementedError; -static PyObject *__pyx_n_s_OSError; -static PyObject *__pyx_kp_u_Oliver_Falk_oliver_linux_kernel; -static PyObject *__pyx_n_s_OverflowError; -static PyObject *__pyx_n_s_PickleError; -static PyObject *__pyx_kp_s_Pickling_of_struct_members_such; -static PyObject *__pyx_n_s_StopIteration; -static PyObject *__pyx_n_s_TCP_HDR_LEN; -static PyObject *__pyx_n_s_TCP_OPT_ALTSUM; -static PyObject *__pyx_n_s_TCP_OPT_ALTSUMDATA; -static PyObject *__pyx_n_s_TCP_OPT_BUBBA; -static PyObject *__pyx_n_s_TCP_OPT_CC; -static PyObject *__pyx_n_s_TCP_OPT_CCECHO; -static PyObject *__pyx_n_s_TCP_OPT_CCNEW; -static PyObject *__pyx_n_s_TCP_OPT_CORRUPT; -static PyObject *__pyx_n_s_TCP_OPT_ECHO; -static PyObject *__pyx_n_s_TCP_OPT_ECHOREPLY; -static PyObject *__pyx_n_s_TCP_OPT_EOL; -static PyObject *__pyx_n_s_TCP_OPT_MAX; -static PyObject *__pyx_n_s_TCP_OPT_MD5; -static PyObject *__pyx_n_s_TCP_OPT_MSS; -static PyObject *__pyx_n_s_TCP_OPT_NOP; -static PyObject *__pyx_n_s_TCP_OPT_POCONN; -static PyObject *__pyx_n_s_TCP_OPT_POSVC; -static PyObject *__pyx_n_s_TCP_OPT_REC; -static PyObject *__pyx_n_s_TCP_OPT_SACK; -static PyObject *__pyx_n_s_TCP_OPT_SACKOK; -static PyObject *__pyx_n_s_TCP_OPT_SCPS; -static PyObject *__pyx_n_s_TCP_OPT_SKEETER; -static PyObject *__pyx_n_s_TCP_OPT_SNACK; -static PyObject *__pyx_n_s_TCP_OPT_SNAP; -static PyObject *__pyx_n_s_TCP_OPT_TCPCOMP; -static PyObject *__pyx_n_s_TCP_OPT_TIMESTAMP; -static PyObject *__pyx_n_s_TCP_OPT_TRAILSUM; -static PyObject *__pyx_n_s_TCP_OPT_WSCALE; -static PyObject *__pyx_n_s_TCP_PORT_MAX; -static PyObject *__pyx_n_s_TCP_WIN_MAX; -static PyObject *__pyx_n_s_TH_ACK; -static PyObject *__pyx_n_s_TH_CWR; -static PyObject *__pyx_n_s_TH_ECE; -static PyObject *__pyx_n_s_TH_FIN; -static PyObject *__pyx_n_s_TH_PUSH; -static PyObject *__pyx_n_s_TH_RST; -static PyObject *__pyx_n_s_TH_SYN; -static PyObject *__pyx_n_s_TH_URG; -static PyObject *__pyx_n_s_TypeError; -static PyObject *__pyx_n_s_UDP_HDR_LEN; -static PyObject *__pyx_n_s_UDP_PORT_MAX; -static PyObject *__pyx_n_s_ValueError; -static PyObject *__pyx_n_s_ack; -static PyObject *__pyx_n_s_addr; -static PyObject *__pyx_n_u_addr; -static PyObject *__pyx_n_s_addr_ip4_iter; -static PyObject *__pyx_n_s_addrtxt; -static PyObject *__pyx_n_s_addrtype; -static PyObject *__pyx_n_u_alias_addrs; -static PyObject *__pyx_n_s_append; -static PyObject *__pyx_n_s_arg; -static PyObject *__pyx_n_s_arp; -static PyObject *__pyx_n_s_arp_pack_hdr_ethip; -static PyObject *__pyx_n_s_author; -static PyObject *__pyx_n_s_buf; -static PyObject *__pyx_kp_u_byte_binary_string; -static PyObject *__pyx_n_s_callback; -static PyObject *__pyx_n_s_cline_in_traceback; -static PyObject *__pyx_n_s_code; -static PyObject *__pyx_n_s_copy; -static PyObject *__pyx_n_s_copyright; -static PyObject *__pyx_n_s_cur; -static PyObject *__pyx_n_s_d; -static PyObject *__pyx_n_u_d; -static PyObject *__pyx_n_s_device; -static PyObject *__pyx_n_u_device; -static PyObject *__pyx_n_s_dh; -static PyObject *__pyx_n_s_dha; -static PyObject *__pyx_n_s_dict; -static PyObject *__pyx_n_u_dir; -static PyObject *__pyx_n_s_dnet; -static PyObject *__pyx_kp_s_dnet_pyx; -static PyObject *__pyx_n_s_dp; -static PyObject *__pyx_n_s_dpa; -static PyObject *__pyx_n_s_dport; -static PyObject *__pyx_n_u_dport; -static PyObject *__pyx_n_s_dst; -static PyObject *__pyx_n_u_dst; -static PyObject *__pyx_n_u_dst_addr; -static PyObject *__pyx_n_s_ea; -static PyObject *__pyx_n_s_entry; -static PyObject *__pyx_n_s_eth; -static PyObject *__pyx_n_s_eth_aton; -static PyObject *__pyx_n_s_eth_ntoa; -static PyObject *__pyx_n_s_eth_pack_hdr; -static PyObject *__pyx_n_s_etype; -static PyObject *__pyx_n_s_fc; -static PyObject *__pyx_n_s_fl; -static PyObject *__pyx_n_s_flags; -static PyObject *__pyx_n_u_flags; -static PyObject *__pyx_n_s_fw; -static PyObject *__pyx_n_s_getstate; -static PyObject *__pyx_n_s_gw; -static PyObject *__pyx_n_s_ha; -static PyObject *__pyx_n_s_hdr; -static PyObject *__pyx_n_s_hlim; -static PyObject *__pyx_kp_u_https_github_com_ofalk_libdnet; -static PyObject *__pyx_n_s_i; -static PyObject *__pyx_n_s_ia; -static PyObject *__pyx_n_s_icmp_pack_hdr; -static PyObject *__pyx_n_s_id; -static PyObject *__pyx_n_s_import; -static PyObject *__pyx_n_s_int; -static PyObject *__pyx_n_s_intf; -static PyObject *__pyx_kp_u_invalid_Ethernet_address; -static PyObject *__pyx_kp_u_invalid_IP_address; -static PyObject *__pyx_kp_u_invalid_IPv6_address; -static PyObject *__pyx_kp_u_invalid_network_address; -static PyObject *__pyx_kp_u_invalid_network_address_2; -static PyObject *__pyx_n_s_ip; -static PyObject *__pyx_n_s_ip6; -static PyObject *__pyx_n_s_ip6_aton; -static PyObject *__pyx_n_s_ip6_checksum; -static PyObject *__pyx_n_s_ip6_ntoa; -static PyObject *__pyx_n_s_ip6_pack_hdr; -static PyObject *__pyx_n_s_ip_aton; -static PyObject *__pyx_n_s_ip_checksum; -static PyObject *__pyx_n_s_ip_cksum_add; -static PyObject *__pyx_n_s_ip_cksum_carry; -static PyObject *__pyx_n_s_ip_ntoa; -static PyObject *__pyx_n_s_ip_pack_hdr; -static PyObject *__pyx_n_s_iter_append; -static PyObject *__pyx_n_s_itype; -static PyObject *__pyx_n_s_l; -static PyObject *__pyx_n_s_len; -static PyObject *__pyx_n_s_license; -static PyObject *__pyx_n_u_link_addr; -static PyObject *__pyx_n_s_loop; -static PyObject *__pyx_n_s_main; -static PyObject *__pyx_n_s_max; -static PyObject *__pyx_n_s_mtu; -static PyObject *__pyx_n_u_mtu; -static PyObject *__pyx_n_s_n; -static PyObject *__pyx_n_u_name; -static PyObject *__pyx_n_s_name_2; -static PyObject *__pyx_n_s_new; -static PyObject *__pyx_kp_u_non_Ethernet_address; -static PyObject *__pyx_kp_u_non_IP_address; -static PyObject *__pyx_kp_u_non_IPv6_address; -static PyObject *__pyx_kp_u_not_a; -static PyObject *__pyx_kp_u_not_a_16_byte_string; -static PyObject *__pyx_kp_u_not_a_4_byte_string; -static PyObject *__pyx_kp_u_not_a_6_byte_string; -static PyObject *__pyx_n_s_nxt; -static PyObject *__pyx_n_s_off; -static PyObject *__pyx_n_s_op; -static PyObject *__pyx_n_u_op; -static PyObject *__pyx_n_s_p; -static PyObject *__pyx_n_s_pa; -static PyObject *__pyx_n_s_pickle; -static PyObject *__pyx_n_s_pkt; -static PyObject *__pyx_n_s_plen; -static PyObject *__pyx_n_u_proto; -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___addr_ip4_iter; -static PyObject *__pyx_n_s_r; -static PyObject *__pyx_n_s_rand; -static PyObject *__pyx_n_s_rand_xrange; -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_route; -static PyObject *__pyx_n_s_s; -static PyObject *__pyx_kp_s_self_arp_cannot_be_converted_to; -static PyObject *__pyx_kp_s_self_eth_cannot_be_converted_to; -static PyObject *__pyx_kp_s_self_fw_cannot_be_converted_to_a; -static PyObject *__pyx_kp_s_self_intf_cannot_be_converted_to; -static PyObject *__pyx_kp_s_self_ip_cannot_be_converted_to_a; -static PyObject *__pyx_kp_s_self_rand_cannot_be_converted_to; -static PyObject *__pyx_kp_s_self_route_cannot_be_converted_t; -static PyObject *__pyx_kp_s_self_tun_cannot_be_converted_to; -static PyObject *__pyx_n_s_seq; -static PyObject *__pyx_n_s_setstate; -static PyObject *__pyx_n_s_setstate_cython; -static PyObject *__pyx_n_s_sh; -static PyObject *__pyx_n_s_sha; -static PyObject *__pyx_n_s_sp; -static PyObject *__pyx_n_s_spa; -static PyObject *__pyx_n_s_sport; -static PyObject *__pyx_n_u_sport; -static PyObject *__pyx_n_s_src; -static PyObject *__pyx_n_u_src; -static PyObject *__pyx_n_s_start; -static PyObject *__pyx_kp_u_start_must_be_an_integer; -static PyObject *__pyx_n_s_stop; -static PyObject *__pyx_kp_u_stop_must_be_an_integer; -static PyObject *__pyx_kp_s_stringsource; -static PyObject *__pyx_n_s_sum; -static PyObject *__pyx_n_s_tcp_pack_hdr; -static PyObject *__pyx_n_s_test; -static PyObject *__pyx_n_s_tos; -static PyObject *__pyx_n_s_ttl; -static PyObject *__pyx_n_s_tun; -static PyObject *__pyx_n_u_type; -static PyObject *__pyx_n_s_udp_pack_hdr; -static PyObject *__pyx_n_s_ulen; -static PyObject *__pyx_n_s_update; -static PyObject *__pyx_n_s_url; -static PyObject *__pyx_n_s_urp; -static PyObject *__pyx_n_s_version; -static PyObject *__pyx_n_s_win; +/* #### Code section: decls ### */ static PyObject *__pyx_pf_4dnet___iter_append(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_entry, PyObject *__pyx_v_l); /* proto */ static int __pyx_pf_4dnet_3eth___init__(struct __pyx_obj_4dnet_eth *__pyx_v_self, PyObject *__pyx_v_device); /* proto */ static PyObject *__pyx_pf_4dnet_3eth_2get(struct __pyx_obj_4dnet_eth *__pyx_v_self); /* proto */ @@ -2298,6 +2901,7 @@ static PyObject *__pyx_pf_4dnet_3eth_10__reduce_cython__(CYTHON_UNUSED struct __ static PyObject *__pyx_pf_4dnet_3eth_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_eth *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ static PyObject *__pyx_pf_4dnet_2eth_ntoa(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_buf); /* proto */ static PyObject *__pyx_pf_4dnet_4eth_aton(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_buf); /* proto */ +static PyObject *__pyx_pf_4dnet_38__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_4dnet_6eth_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src, PyObject *__pyx_v_etype); /* proto */ static int __pyx_pf_4dnet_2ip___init__(struct __pyx_obj_4dnet_ip *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_4dnet_2ip_2send(struct __pyx_obj_4dnet_ip *__pyx_v_self, PyObject *__pyx_v_pkt); /* proto */ @@ -2309,10 +2913,12 @@ static PyObject *__pyx_pf_4dnet_10ip_aton(CYTHON_UNUSED PyObject *__pyx_self, Py static PyObject *__pyx_pf_4dnet_12ip_checksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pkt); /* proto */ static PyObject *__pyx_pf_4dnet_14ip_cksum_add(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_buf, int __pyx_v_sum); /* proto */ static PyObject *__pyx_pf_4dnet_16ip_cksum_carry(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_sum); /* proto */ +static PyObject *__pyx_pf_4dnet_40__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_4dnet_18ip_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_tos, PyObject *__pyx_v_len, PyObject *__pyx_v_id, PyObject *__pyx_v_off, PyObject *__pyx_v_ttl, PyObject *__pyx_v_p, PyObject *__pyx_v_src, PyObject *__pyx_v_dst); /* proto */ static PyObject *__pyx_pf_4dnet_20ip6_ntoa(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_buf); /* proto */ static PyObject *__pyx_pf_4dnet_22ip6_aton(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_buf); /* proto */ static PyObject *__pyx_pf_4dnet_24ip6_checksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_buf); /* proto */ +static PyObject *__pyx_pf_4dnet_42__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_4dnet_26ip6_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_fc, PyObject *__pyx_v_fl, PyObject *__pyx_v_plen, PyObject *__pyx_v_nxt, PyObject *__pyx_v_hlim, PyObject *__pyx_v_src, PyObject *__pyx_v_dst); /* proto */ static int __pyx_pf_4dnet_4addr___init__(struct __pyx_obj_4dnet_addr *__pyx_v_self, PyObject *__pyx_v_addrtxt, CYTHON_UNUSED PyObject *__pyx_v_addrtype); /* proto */ static PyObject *__pyx_pf_4dnet_4addr_8addrtype___get__(struct __pyx_obj_4dnet_addr *__pyx_v_self); /* proto */ @@ -2328,7 +2934,7 @@ static PyObject *__pyx_pf_4dnet_4addr_3ip6___get__(struct __pyx_obj_4dnet_addr * static int __pyx_pf_4dnet_4addr_3ip6_2__set__(struct __pyx_obj_4dnet_addr *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ static PyObject *__pyx_pf_4dnet_4addr_2bcast(struct __pyx_obj_4dnet_addr *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_4dnet_4addr_4net(struct __pyx_obj_4dnet_addr *__pyx_v_self); /* proto */ -static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ +static PyObject *__pyx_pf_4dnet_4addr_6__add__(struct __pyx_obj_4dnet_addr *__pyx_v_self, PyObject *__pyx_v_other); /* proto */ static PyObject *__pyx_pf_4dnet_4addr_8__copy__(struct __pyx_obj_4dnet_addr *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_4dnet_4addr_10__eq__(struct __pyx_obj_4dnet_addr *__pyx_v_x, struct __pyx_obj_4dnet_addr *__pyx_v_y); /* proto */ static PyObject *__pyx_pf_4dnet_4addr_12__ne__(struct __pyx_obj_4dnet_addr *__pyx_v_x, struct __pyx_obj_4dnet_addr *__pyx_v_y); /* proto */ @@ -2359,9 +2965,12 @@ static PyObject *__pyx_pf_4dnet_3arp_10__iter__(struct __pyx_obj_4dnet_arp *__py static void __pyx_pf_4dnet_3arp_12__dealloc__(struct __pyx_obj_4dnet_arp *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_4dnet_3arp_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_arp *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_4dnet_3arp_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_arp *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_4dnet_44__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_4dnet_28arp_pack_hdr_ethip(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_op, PyObject *__pyx_v_sha, PyObject *__pyx_v_spa, PyObject *__pyx_v_dha, PyObject *__pyx_v_dpa); /* proto */ static PyObject *__pyx_pf_4dnet_30icmp_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_itype, PyObject *__pyx_v_code); /* proto */ +static PyObject *__pyx_pf_4dnet_46__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_4dnet_32tcp_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_sport, PyObject *__pyx_v_dport, PyObject *__pyx_v_seq, PyObject *__pyx_v_ack, PyObject *__pyx_v_flags, PyObject *__pyx_v_win, PyObject *__pyx_v_urp); /* proto */ +static PyObject *__pyx_pf_4dnet_48__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ static PyObject *__pyx_pf_4dnet_34udp_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_sport, PyObject *__pyx_v_dport, PyObject *__pyx_v_ulen); /* proto */ static int __pyx_pf_4dnet_4intf___init__(struct __pyx_obj_4dnet_intf *__pyx_v_self); /* proto */ static PyObject *__pyx_pf_4dnet_4intf_2get(struct __pyx_obj_4dnet_intf *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ @@ -2429,150 +3038,2532 @@ static PyObject *__pyx_tp_new_4dnet_fw(PyTypeObject *t, PyObject *a, PyObject *k static PyObject *__pyx_tp_new_4dnet_rand(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_4dnet___rand_xrange(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ static PyObject *__pyx_tp_new_4dnet_tun(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ -static PyObject *__pyx_int_0; -static PyObject *__pyx_int_1; -static PyObject *__pyx_int_2; -static PyObject *__pyx_int_3; -static PyObject *__pyx_int_4; -static PyObject *__pyx_int_5; -static PyObject *__pyx_int_6; -static PyObject *__pyx_int_7; -static PyObject *__pyx_int_8; -static PyObject *__pyx_int_9; -static PyObject *__pyx_int_10; -static PyObject *__pyx_int_11; -static PyObject *__pyx_int_12; -static PyObject *__pyx_int_13; -static PyObject *__pyx_int_14; -static PyObject *__pyx_int_15; -static PyObject *__pyx_int_16; -static PyObject *__pyx_int_17; -static PyObject *__pyx_int_18; -static PyObject *__pyx_int_19; -static PyObject *__pyx_int_20; -static PyObject *__pyx_int_21; -static PyObject *__pyx_int_22; -static PyObject *__pyx_int_23; -static PyObject *__pyx_int_24; -static PyObject *__pyx_int_26; -static PyObject *__pyx_int_27; -static PyObject *__pyx_int_32; -static PyObject *__pyx_int_40; -static PyObject *__pyx_int_41; -static PyObject *__pyx_int_47; -static PyObject *__pyx_int_48; -static PyObject *__pyx_int_50; -static PyObject *__pyx_int_51; -static PyObject *__pyx_int_53; -static PyObject *__pyx_int_58; -static PyObject *__pyx_int_64; -static PyObject *__pyx_int_128; -static PyObject *__pyx_int_255; -static PyObject *__pyx_int_512; -static PyObject *__pyx_int_1024; -static PyObject *__pyx_int_1280; -static PyObject *__pyx_int_1500; -static PyObject *__pyx_int_1518; -static PyObject *__pyx_int_2048; -static PyObject *__pyx_int_2054; -static PyObject *__pyx_int_8191; -static PyObject *__pyx_int_8192; -static PyObject *__pyx_int_16384; -static PyObject *__pyx_int_32768; -static PyObject *__pyx_int_32821; -static PyObject *__pyx_int_33024; -static PyObject *__pyx_int_34525; -static PyObject *__pyx_int_34887; -static PyObject *__pyx_int_34888; -static PyObject *__pyx_int_34915; -static PyObject *__pyx_int_34916; -static PyObject *__pyx_int_36864; -static PyObject *__pyx_int_65535; -static PyObject *__pyx_int_112194662; -static PyObject *__pyx_int_113314003; -static PyObject *__pyx_int_218787872; -static PyObject *__pyx_k__3; -static PyObject *__pyx_k__4; -static PyObject *__pyx_k__5; -static PyObject *__pyx_k__8; -static PyObject *__pyx_k__9; -static PyObject *__pyx_k__10; -static PyObject *__pyx_k__11; -static PyObject *__pyx_k__12; -static PyObject *__pyx_k__13; -static PyObject *__pyx_k__14; -static PyObject *__pyx_k__15; -static PyObject *__pyx_k__16; -static PyObject *__pyx_k__17; -static PyObject *__pyx_k__18; -static PyObject *__pyx_k__23; -static PyObject *__pyx_k__24; -static PyObject *__pyx_k__25; -static PyObject *__pyx_k__26; -static PyObject *__pyx_k__27; -static PyObject *__pyx_k__28; -static PyObject *__pyx_k__29; -static PyObject *__pyx_k__30; -static PyObject *__pyx_tuple_; -static PyObject *__pyx_tuple__2; -static PyObject *__pyx_tuple__6; -static PyObject *__pyx_tuple__7; -static PyObject *__pyx_tuple__19; -static PyObject *__pyx_tuple__20; -static PyObject *__pyx_tuple__21; -static PyObject *__pyx_tuple__22; -static PyObject *__pyx_tuple__31; -static PyObject *__pyx_tuple__32; -static PyObject *__pyx_tuple__33; -static PyObject *__pyx_tuple__34; -static PyObject *__pyx_tuple__35; -static PyObject *__pyx_tuple__36; -static PyObject *__pyx_tuple__37; -static PyObject *__pyx_tuple__38; -static PyObject *__pyx_tuple__39; -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__46; -static PyObject *__pyx_tuple__48; -static PyObject *__pyx_tuple__50; -static PyObject *__pyx_tuple__52; -static PyObject *__pyx_tuple__54; -static PyObject *__pyx_tuple__56; -static PyObject *__pyx_tuple__58; -static PyObject *__pyx_tuple__60; -static PyObject *__pyx_tuple__62; -static PyObject *__pyx_tuple__64; -static PyObject *__pyx_tuple__66; -static PyObject *__pyx_tuple__68; -static PyObject *__pyx_tuple__70; -static PyObject *__pyx_tuple__72; -static PyObject *__pyx_tuple__74; -static PyObject *__pyx_tuple__76; -static PyObject *__pyx_tuple__78; -static PyObject *__pyx_tuple__80; -static PyObject *__pyx_codeobj__45; -static PyObject *__pyx_codeobj__47; -static PyObject *__pyx_codeobj__49; -static PyObject *__pyx_codeobj__51; -static PyObject *__pyx_codeobj__53; -static PyObject *__pyx_codeobj__55; -static PyObject *__pyx_codeobj__57; -static PyObject *__pyx_codeobj__59; -static PyObject *__pyx_codeobj__61; -static PyObject *__pyx_codeobj__63; -static PyObject *__pyx_codeobj__65; -static PyObject *__pyx_codeobj__67; -static PyObject *__pyx_codeobj__69; -static PyObject *__pyx_codeobj__71; -static PyObject *__pyx_codeobj__73; -static PyObject *__pyx_codeobj__75; -static PyObject *__pyx_codeobj__77; -static PyObject *__pyx_codeobj__79; -static PyObject *__pyx_codeobj__81; -/* Late includes */ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + #ifdef __Pyx_CyFunction_USED + PyTypeObject *__pyx_CyFunctionType; + #endif + #ifdef __Pyx_FusedFunction_USED + PyTypeObject *__pyx_FusedFunctionType; + #endif + #ifdef __Pyx_Generator_USED + PyTypeObject *__pyx_GeneratorType; + #endif + #ifdef __Pyx_IterableCoroutine_USED + PyTypeObject *__pyx_IterableCoroutineType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineAwaitType; + #endif + #ifdef __Pyx_Coroutine_USED + PyTypeObject *__pyx_CoroutineType; + #endif + #if CYTHON_USE_MODULE_STATE + PyObject *__pyx_type_4dnet_eth; + PyObject *__pyx_type_4dnet_ip; + PyObject *__pyx_type_4dnet_addr; + PyObject *__pyx_type_4dnet___addr_ip4_iter; + PyObject *__pyx_type_4dnet_arp; + PyObject *__pyx_type_4dnet_intf; + PyObject *__pyx_type_4dnet_route; + PyObject *__pyx_type_4dnet_fw; + PyObject *__pyx_type_4dnet_rand; + PyObject *__pyx_type_4dnet___rand_xrange; + PyObject *__pyx_type_4dnet_tun; + #endif + PyTypeObject *__pyx_ptype_4dnet_eth; + PyTypeObject *__pyx_ptype_4dnet_ip; + PyTypeObject *__pyx_ptype_4dnet_addr; + PyTypeObject *__pyx_ptype_4dnet___addr_ip4_iter; + PyTypeObject *__pyx_ptype_4dnet_arp; + PyTypeObject *__pyx_ptype_4dnet_intf; + PyTypeObject *__pyx_ptype_4dnet_route; + PyTypeObject *__pyx_ptype_4dnet_fw; + PyTypeObject *__pyx_ptype_4dnet_rand; + PyTypeObject *__pyx_ptype_4dnet___rand_xrange; + PyTypeObject *__pyx_ptype_4dnet_tun; + PyObject *__pyx_kp_u_1_18_0; + PyObject *__pyx_n_s_ADDR_TYPE_ETH; + PyObject *__pyx_n_s_ADDR_TYPE_IP; + PyObject *__pyx_n_s_ADDR_TYPE_IP6; + PyObject *__pyx_n_s_ADDR_TYPE_NONE; + PyObject *__pyx_n_s_ARP_ETHIP_LEN; + PyObject *__pyx_n_s_ARP_HDR_LEN; + PyObject *__pyx_n_s_ARP_HRD_ETH; + PyObject *__pyx_n_s_ARP_HRD_IEEE802; + PyObject *__pyx_n_s_ARP_OP_REPLY; + PyObject *__pyx_n_s_ARP_OP_REQUEST; + PyObject *__pyx_n_s_ARP_OP_REVREPLY; + PyObject *__pyx_n_s_ARP_OP_REVREQUEST; + PyObject *__pyx_n_s_ARP_PRO_IP; + PyObject *__pyx_n_u_BSD; + PyObject *__pyx_kp_u_Copyright_c_2023_2024_Oliver_Fal; + PyObject *__pyx_n_s_ETH_ADDR_BITS; + PyObject *__pyx_n_s_ETH_ADDR_BROADCAST; + PyObject *__pyx_n_s_ETH_ADDR_LEN; + PyObject *__pyx_n_s_ETH_ADDR_UNSPEC; + PyObject *__pyx_n_s_ETH_CRC_LEN; + PyObject *__pyx_n_s_ETH_HDR_LEN; + PyObject *__pyx_n_s_ETH_LEN_MAX; + PyObject *__pyx_n_s_ETH_LEN_MIN; + PyObject *__pyx_n_s_ETH_MIN; + PyObject *__pyx_n_s_ETH_MTU; + PyObject *__pyx_n_s_ETH_TYPE_8021Q; + PyObject *__pyx_n_s_ETH_TYPE_ARP; + PyObject *__pyx_n_s_ETH_TYPE_IP; + PyObject *__pyx_n_s_ETH_TYPE_IPV6; + PyObject *__pyx_n_s_ETH_TYPE_LEN; + PyObject *__pyx_n_s_ETH_TYPE_LOOPBACK; + PyObject *__pyx_n_s_ETH_TYPE_MPLS; + PyObject *__pyx_n_s_ETH_TYPE_MPLS_MCAST; + PyObject *__pyx_n_s_ETH_TYPE_PPPOE; + PyObject *__pyx_n_s_ETH_TYPE_PPPOEDISC; + PyObject *__pyx_n_s_ETH_TYPE_PUP; + PyObject *__pyx_n_s_ETH_TYPE_REVARP; + PyObject *__pyx_n_s_FW_DIR_IN; + PyObject *__pyx_n_s_FW_DIR_OUT; + PyObject *__pyx_n_s_FW_OP_ALLOW; + PyObject *__pyx_n_s_FW_OP_BLOCK; + PyObject *__pyx_n_s_INTF_FLAG_BROADCAST; + PyObject *__pyx_n_s_INTF_FLAG_LOOPBACK; + PyObject *__pyx_n_s_INTF_FLAG_MULTICAST; + PyObject *__pyx_n_s_INTF_FLAG_NOARP; + PyObject *__pyx_n_s_INTF_FLAG_POINTOPOINT; + PyObject *__pyx_n_s_INTF_FLAG_UP; + PyObject *__pyx_n_s_INTF_TYPE_ETH; + PyObject *__pyx_n_s_INTF_TYPE_LOOPBACK; + PyObject *__pyx_n_s_INTF_TYPE_OTHER; + PyObject *__pyx_n_s_INTF_TYPE_TUN; + PyObject *__pyx_n_s_IP6_ADDR_BITS; + PyObject *__pyx_n_s_IP6_ADDR_LEN; + PyObject *__pyx_n_s_IP6_ADDR_LOOPBACK; + PyObject *__pyx_n_s_IP6_ADDR_UNSPEC; + PyObject *__pyx_n_s_IP6_HDR_LEN; + PyObject *__pyx_n_s_IP6_HLIM_DEFAULT; + PyObject *__pyx_n_s_IP6_HLIM_MAX; + PyObject *__pyx_n_s_IP6_LEN_MAX; + PyObject *__pyx_n_s_IP6_LEN_MIN; + PyObject *__pyx_n_s_IP6_MTU_MIN; + PyObject *__pyx_n_s_IP_ADDR_ANY; + PyObject *__pyx_n_s_IP_ADDR_BITS; + PyObject *__pyx_n_s_IP_ADDR_BROADCAST; + PyObject *__pyx_n_s_IP_ADDR_LEN; + PyObject *__pyx_n_s_IP_ADDR_LOOPBACK; + PyObject *__pyx_n_s_IP_ADDR_MCAST_ALL; + PyObject *__pyx_n_s_IP_ADDR_MCAST_LOCAL; + PyObject *__pyx_n_s_IP_DF; + PyObject *__pyx_n_s_IP_HDR_LEN; + PyObject *__pyx_n_s_IP_HDR_LEN_MAX; + PyObject *__pyx_n_s_IP_LEN_MAX; + PyObject *__pyx_n_s_IP_LEN_MIN; + PyObject *__pyx_n_s_IP_MF; + PyObject *__pyx_n_s_IP_OFFMASK; + PyObject *__pyx_n_s_IP_OPT_LEN; + PyObject *__pyx_n_s_IP_OPT_LEN_MAX; + PyObject *__pyx_n_s_IP_PROTO_AH; + PyObject *__pyx_n_s_IP_PROTO_ESP; + PyObject *__pyx_n_s_IP_PROTO_GRE; + PyObject *__pyx_n_s_IP_PROTO_ICMP; + PyObject *__pyx_n_s_IP_PROTO_ICMPV6; + PyObject *__pyx_n_s_IP_PROTO_IGMP; + PyObject *__pyx_n_s_IP_PROTO_IP; + PyObject *__pyx_n_s_IP_PROTO_IPV6; + PyObject *__pyx_n_s_IP_PROTO_MAX; + PyObject *__pyx_n_s_IP_PROTO_RAW; + PyObject *__pyx_n_s_IP_PROTO_RESERVED; + PyObject *__pyx_n_s_IP_PROTO_TCP; + PyObject *__pyx_n_s_IP_PROTO_UDP; + PyObject *__pyx_n_s_IP_RF; + PyObject *__pyx_n_s_IP_TOS_DEFAULT; + PyObject *__pyx_n_s_IP_TTL_DEFAULT; + PyObject *__pyx_n_s_IP_TTL_MAX; + PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; + PyObject *__pyx_n_s_NotImplementedError; + PyObject *__pyx_n_s_OSError; + PyObject *__pyx_kp_u_Oliver_Falk_oliver_linux_kernel; + PyObject *__pyx_n_s_OverflowError; + PyObject *__pyx_n_s_PickleError; + PyObject *__pyx_kp_s_Pickling_of_struct_members_such; + PyObject *__pyx_n_s_StopIteration; + PyObject *__pyx_n_s_TCP_HDR_LEN; + PyObject *__pyx_n_s_TCP_OPT_ALTSUM; + PyObject *__pyx_n_s_TCP_OPT_ALTSUMDATA; + PyObject *__pyx_n_s_TCP_OPT_BUBBA; + PyObject *__pyx_n_s_TCP_OPT_CC; + PyObject *__pyx_n_s_TCP_OPT_CCECHO; + PyObject *__pyx_n_s_TCP_OPT_CCNEW; + PyObject *__pyx_n_s_TCP_OPT_CORRUPT; + PyObject *__pyx_n_s_TCP_OPT_ECHO; + PyObject *__pyx_n_s_TCP_OPT_ECHOREPLY; + PyObject *__pyx_n_s_TCP_OPT_EOL; + PyObject *__pyx_n_s_TCP_OPT_MAX; + PyObject *__pyx_n_s_TCP_OPT_MD5; + PyObject *__pyx_n_s_TCP_OPT_MSS; + PyObject *__pyx_n_s_TCP_OPT_NOP; + PyObject *__pyx_n_s_TCP_OPT_POCONN; + PyObject *__pyx_n_s_TCP_OPT_POSVC; + PyObject *__pyx_n_s_TCP_OPT_REC; + PyObject *__pyx_n_s_TCP_OPT_SACK; + PyObject *__pyx_n_s_TCP_OPT_SACKOK; + PyObject *__pyx_n_s_TCP_OPT_SCPS; + PyObject *__pyx_n_s_TCP_OPT_SKEETER; + PyObject *__pyx_n_s_TCP_OPT_SNACK; + PyObject *__pyx_n_s_TCP_OPT_SNAP; + PyObject *__pyx_n_s_TCP_OPT_TCPCOMP; + PyObject *__pyx_n_s_TCP_OPT_TIMESTAMP; + PyObject *__pyx_n_s_TCP_OPT_TRAILSUM; + PyObject *__pyx_n_s_TCP_OPT_WSCALE; + PyObject *__pyx_n_s_TCP_PORT_MAX; + PyObject *__pyx_n_s_TCP_WIN_MAX; + PyObject *__pyx_n_s_TH_ACK; + PyObject *__pyx_n_s_TH_CWR; + PyObject *__pyx_n_s_TH_ECE; + PyObject *__pyx_n_s_TH_FIN; + PyObject *__pyx_n_s_TH_PUSH; + PyObject *__pyx_n_s_TH_RST; + PyObject *__pyx_n_s_TH_SYN; + PyObject *__pyx_n_s_TH_URG; + PyObject *__pyx_n_s_TypeError; + PyObject *__pyx_n_s_UDP_HDR_LEN; + PyObject *__pyx_n_s_UDP_PORT_MAX; + PyObject *__pyx_n_s_ValueError; + PyObject *__pyx_n_s__120; + PyObject *__pyx_kp_u__3; + PyObject *__pyx_n_s_a; + PyObject *__pyx_n_s_ack; + PyObject *__pyx_n_s_add; + PyObject *__pyx_n_s_addr; + PyObject *__pyx_n_u_addr; + PyObject *__pyx_n_s_addr___copy; + PyObject *__pyx_n_s_addr___reduce_cython; + PyObject *__pyx_n_s_addr___setstate_cython; + PyObject *__pyx_n_s_addr_bcast; + PyObject *__pyx_n_s_addr_ip4_iter; + PyObject *__pyx_n_s_addr_ip4_iter___reduce_cython; + PyObject *__pyx_n_s_addr_ip4_iter___setstate_cytho; + PyObject *__pyx_n_s_addr_net; + PyObject *__pyx_n_s_addrtxt; + PyObject *__pyx_n_s_addrtype; + PyObject *__pyx_n_u_alias_addrs; + PyObject *__pyx_n_s_append; + PyObject *__pyx_n_s_arg; + PyObject *__pyx_n_s_arg_2; + PyObject *__pyx_n_s_arp; + PyObject *__pyx_n_s_arp___reduce_cython; + PyObject *__pyx_n_s_arp___setstate_cython; + PyObject *__pyx_n_s_arp_add; + PyObject *__pyx_n_s_arp_delete; + PyObject *__pyx_n_s_arp_get; + PyObject *__pyx_n_s_arp_loop; + PyObject *__pyx_n_s_arp_pack_hdr_ethip; + PyObject *__pyx_n_s_asyncio_coroutines; + PyObject *__pyx_n_s_author; + PyObject *__pyx_n_s_bcast; + PyObject *__pyx_n_s_buf; + PyObject *__pyx_kp_u_byte_binary_string; + PyObject *__pyx_n_s_callback; + PyObject *__pyx_n_s_cline_in_traceback; + PyObject *__pyx_n_s_close; + PyObject *__pyx_n_s_code; + PyObject *__pyx_n_s_copy; + PyObject *__pyx_n_s_copyright; + PyObject *__pyx_n_s_cur; + PyObject *__pyx_n_s_d; + PyObject *__pyx_n_u_d; + PyObject *__pyx_n_s_delete; + PyObject *__pyx_n_s_device; + PyObject *__pyx_n_u_device; + PyObject *__pyx_n_s_dh; + PyObject *__pyx_n_s_dha; + PyObject *__pyx_n_s_dict; + PyObject *__pyx_n_s_dict_2; + PyObject *__pyx_n_u_dir; + PyObject *__pyx_kp_u_disable; + PyObject *__pyx_n_s_dnet; + PyObject *__pyx_kp_s_dnet_pyx; + PyObject *__pyx_n_s_dp; + PyObject *__pyx_n_s_dpa; + PyObject *__pyx_n_s_dport; + PyObject *__pyx_n_u_dport; + PyObject *__pyx_n_s_dst; + PyObject *__pyx_n_u_dst; + PyObject *__pyx_n_u_dst_addr; + PyObject *__pyx_n_s_ea; + PyObject *__pyx_kp_u_enable; + PyObject *__pyx_n_s_entry; + PyObject *__pyx_n_s_eth; + PyObject *__pyx_n_s_eth___reduce_cython; + PyObject *__pyx_n_s_eth___setstate_cython; + PyObject *__pyx_n_s_eth_aton; + PyObject *__pyx_n_s_eth_get; + PyObject *__pyx_n_s_eth_ntoa; + PyObject *__pyx_n_s_eth_pack_hdr; + PyObject *__pyx_n_s_eth_send; + PyObject *__pyx_n_s_eth_set; + PyObject *__pyx_n_s_etype; + PyObject *__pyx_n_s_fc; + PyObject *__pyx_n_s_fileno; + PyObject *__pyx_n_s_fl; + PyObject *__pyx_n_s_flags; + PyObject *__pyx_n_u_flags; + PyObject *__pyx_n_s_frame; + PyObject *__pyx_n_s_fw; + PyObject *__pyx_n_s_fw___reduce_cython; + PyObject *__pyx_n_s_fw___setstate_cython; + PyObject *__pyx_n_s_fw_add; + PyObject *__pyx_n_s_fw_delete; + PyObject *__pyx_n_s_fw_loop; + PyObject *__pyx_kp_u_gc; + PyObject *__pyx_n_s_get; + PyObject *__pyx_n_s_get_dst; + PyObject *__pyx_n_s_get_src; + PyObject *__pyx_n_s_getstate; + PyObject *__pyx_n_s_gw; + PyObject *__pyx_n_s_ha; + PyObject *__pyx_n_s_hdr; + PyObject *__pyx_n_s_hlim; + PyObject *__pyx_kp_u_https_github_com_ofalk_libdnet; + PyObject *__pyx_n_s_i; + PyObject *__pyx_n_s_ia; + PyObject *__pyx_n_s_icmp_pack_hdr; + PyObject *__pyx_n_s_id; + PyObject *__pyx_n_s_ifent; + PyObject *__pyx_n_s_import; + PyObject *__pyx_n_s_int; + PyObject *__pyx_n_s_intf; + PyObject *__pyx_n_s_intf___reduce_cython; + PyObject *__pyx_n_s_intf___setstate_cython; + PyObject *__pyx_n_s_intf_get; + PyObject *__pyx_n_s_intf_get_dst; + PyObject *__pyx_n_s_intf_get_src; + PyObject *__pyx_n_s_intf_loop; + PyObject *__pyx_n_s_intf_set; + PyObject *__pyx_kp_u_invalid_Ethernet_address; + PyObject *__pyx_kp_u_invalid_IP_address; + PyObject *__pyx_kp_u_invalid_IPv6_address; + PyObject *__pyx_kp_u_invalid_network_address; + PyObject *__pyx_kp_u_invalid_network_address_2; + PyObject *__pyx_n_s_ip; + PyObject *__pyx_n_s_ip6; + PyObject *__pyx_n_s_ip6_aton; + PyObject *__pyx_n_s_ip6_checksum; + PyObject *__pyx_n_s_ip6_ntoa; + PyObject *__pyx_n_s_ip6_pack_hdr; + PyObject *__pyx_n_s_ip___reduce_cython; + PyObject *__pyx_n_s_ip___setstate_cython; + PyObject *__pyx_n_s_ip_aton; + PyObject *__pyx_n_s_ip_checksum; + PyObject *__pyx_n_s_ip_cksum_add; + PyObject *__pyx_n_s_ip_cksum_carry; + PyObject *__pyx_n_s_ip_ntoa; + PyObject *__pyx_n_s_ip_pack_hdr; + PyObject *__pyx_n_s_ip_send; + PyObject *__pyx_n_s_is_coroutine; + PyObject *__pyx_kp_u_isenabled; + PyObject *__pyx_n_s_iter_append; + PyObject *__pyx_n_s_itype; + PyObject *__pyx_n_s_l; + PyObject *__pyx_n_s_len; + PyObject *__pyx_n_s_license; + PyObject *__pyx_n_u_link_addr; + PyObject *__pyx_n_s_loop; + PyObject *__pyx_n_s_main; + PyObject *__pyx_n_s_max; + PyObject *__pyx_n_s_mtu; + PyObject *__pyx_n_u_mtu; + PyObject *__pyx_n_s_n; + PyObject *__pyx_n_s_name; + PyObject *__pyx_n_u_name; + PyObject *__pyx_n_s_name_2; + PyObject *__pyx_n_s_net; + PyObject *__pyx_n_s_new; + PyObject *__pyx_kp_u_non_Ethernet_address; + PyObject *__pyx_kp_u_non_IP_address; + PyObject *__pyx_kp_u_non_IPv6_address; + PyObject *__pyx_kp_u_not_a; + PyObject *__pyx_kp_u_not_a_16_byte_string; + PyObject *__pyx_kp_u_not_a_4_byte_string; + PyObject *__pyx_kp_u_not_a_6_byte_string; + PyObject *__pyx_n_s_nxt; + PyObject *__pyx_n_s_off; + PyObject *__pyx_n_s_op; + PyObject *__pyx_n_u_op; + PyObject *__pyx_n_s_p; + PyObject *__pyx_n_s_pa; + PyObject *__pyx_n_s_pickle; + PyObject *__pyx_n_s_pkt; + PyObject *__pyx_n_s_plen; + PyObject *__pyx_n_u_proto; + PyObject *__pyx_n_s_pyx_PickleError; + PyObject *__pyx_n_s_pyx_checksum; + PyObject *__pyx_n_s_pyx_result; + PyObject *__pyx_n_s_pyx_state; + PyObject *__pyx_n_s_pyx_type; + PyObject *__pyx_n_s_pyx_unpickle___addr_ip4_iter; + PyObject *__pyx_n_s_r; + PyObject *__pyx_n_s_rand; + PyObject *__pyx_n_s_rand___reduce_cython; + PyObject *__pyx_n_s_rand___setstate_cython; + PyObject *__pyx_n_s_rand_add; + PyObject *__pyx_n_s_rand_get; + PyObject *__pyx_n_s_rand_set; + PyObject *__pyx_n_s_rand_uint16; + PyObject *__pyx_n_s_rand_uint32; + PyObject *__pyx_n_s_rand_uint8; + PyObject *__pyx_n_s_rand_xrange; + PyObject *__pyx_n_s_rand_xrange_2; + PyObject *__pyx_n_s_rand_xrange___reduce_cython; + PyObject *__pyx_n_s_rand_xrange___setstate_cython; + PyObject *__pyx_n_s_recv; + PyObject *__pyx_n_s_reduce; + PyObject *__pyx_n_s_reduce_cython; + PyObject *__pyx_n_s_reduce_ex; + PyObject *__pyx_n_s_route; + PyObject *__pyx_n_s_route___reduce_cython; + PyObject *__pyx_n_s_route___setstate_cython; + PyObject *__pyx_n_s_route_add; + PyObject *__pyx_n_s_route_delete; + PyObject *__pyx_n_s_route_get; + PyObject *__pyx_n_s_route_loop; + PyObject *__pyx_n_s_rule; + PyObject *__pyx_n_s_s; + PyObject *__pyx_n_s_self; + PyObject *__pyx_kp_s_self_arp_cannot_be_converted_to; + PyObject *__pyx_kp_s_self_eth_cannot_be_converted_to; + PyObject *__pyx_kp_s_self_fw_cannot_be_converted_to_a; + PyObject *__pyx_kp_s_self_intf_cannot_be_converted_to; + PyObject *__pyx_kp_s_self_ip_cannot_be_converted_to_a; + PyObject *__pyx_kp_s_self_rand_cannot_be_converted_to; + PyObject *__pyx_kp_s_self_route_cannot_be_converted_t; + PyObject *__pyx_kp_s_self_tun_cannot_be_converted_to; + PyObject *__pyx_n_s_send; + PyObject *__pyx_n_s_seq; + PyObject *__pyx_n_s_set; + PyObject *__pyx_n_s_setstate; + PyObject *__pyx_n_s_setstate_cython; + PyObject *__pyx_n_s_sh; + PyObject *__pyx_n_s_sha; + PyObject *__pyx_n_s_sp; + PyObject *__pyx_n_s_spa; + PyObject *__pyx_n_s_sport; + PyObject *__pyx_n_u_sport; + PyObject *__pyx_n_s_src; + PyObject *__pyx_n_u_src; + PyObject *__pyx_n_s_start; + PyObject *__pyx_kp_u_start_must_be_an_integer; + PyObject *__pyx_n_s_state; + PyObject *__pyx_n_s_stop; + PyObject *__pyx_kp_u_stop_must_be_an_integer; + PyObject *__pyx_kp_s_stringsource; + PyObject *__pyx_n_s_sum; + PyObject *__pyx_n_s_tcp_pack_hdr; + PyObject *__pyx_n_s_test; + PyObject *__pyx_n_s_tos; + PyObject *__pyx_n_s_ttl; + PyObject *__pyx_n_s_tun; + PyObject *__pyx_n_s_tun___reduce_cython; + PyObject *__pyx_n_s_tun___setstate_cython; + PyObject *__pyx_n_s_tun_close; + PyObject *__pyx_n_s_tun_fileno; + PyObject *__pyx_n_s_tun_recv; + PyObject *__pyx_n_s_tun_send; + PyObject *__pyx_n_u_type; + PyObject *__pyx_n_s_udp_pack_hdr; + PyObject *__pyx_n_s_uint16; + PyObject *__pyx_n_s_uint32; + PyObject *__pyx_n_s_uint8; + PyObject *__pyx_n_s_ulen; + PyObject *__pyx_n_s_update; + PyObject *__pyx_n_s_url; + PyObject *__pyx_n_s_urp; + PyObject *__pyx_n_s_use_setstate; + PyObject *__pyx_n_s_value; + PyObject *__pyx_n_s_version; + PyObject *__pyx_n_s_win; + PyObject *__pyx_n_s_xrange; + PyObject *__pyx_int_0; + PyObject *__pyx_int_1; + PyObject *__pyx_int_2; + PyObject *__pyx_int_3; + PyObject *__pyx_int_4; + PyObject *__pyx_int_5; + PyObject *__pyx_int_6; + PyObject *__pyx_int_7; + PyObject *__pyx_int_8; + PyObject *__pyx_int_9; + PyObject *__pyx_int_10; + PyObject *__pyx_int_11; + PyObject *__pyx_int_12; + PyObject *__pyx_int_13; + PyObject *__pyx_int_14; + PyObject *__pyx_int_15; + PyObject *__pyx_int_16; + PyObject *__pyx_int_17; + PyObject *__pyx_int_18; + PyObject *__pyx_int_19; + PyObject *__pyx_int_20; + PyObject *__pyx_int_21; + PyObject *__pyx_int_22; + PyObject *__pyx_int_23; + PyObject *__pyx_int_24; + PyObject *__pyx_int_26; + PyObject *__pyx_int_27; + PyObject *__pyx_int_32; + PyObject *__pyx_int_40; + PyObject *__pyx_int_41; + PyObject *__pyx_int_47; + PyObject *__pyx_int_48; + PyObject *__pyx_int_50; + PyObject *__pyx_int_51; + PyObject *__pyx_int_53; + PyObject *__pyx_int_58; + PyObject *__pyx_int_64; + PyObject *__pyx_int_128; + PyObject *__pyx_int_255; + PyObject *__pyx_int_512; + PyObject *__pyx_int_1024; + PyObject *__pyx_int_1280; + PyObject *__pyx_int_1500; + PyObject *__pyx_int_1518; + PyObject *__pyx_int_2048; + PyObject *__pyx_int_2054; + PyObject *__pyx_int_8191; + PyObject *__pyx_int_8192; + PyObject *__pyx_int_16384; + PyObject *__pyx_int_32768; + PyObject *__pyx_int_32821; + PyObject *__pyx_int_33024; + PyObject *__pyx_int_34525; + PyObject *__pyx_int_34887; + PyObject *__pyx_int_34888; + PyObject *__pyx_int_34915; + PyObject *__pyx_int_34916; + PyObject *__pyx_int_36864; + PyObject *__pyx_int_65535; + PyObject *__pyx_int_112194662; + PyObject *__pyx_int_113314003; + PyObject *__pyx_int_218787872; + PyObject *__pyx_k_; + PyObject *__pyx_tuple__2; + PyObject *__pyx_tuple__4; + PyObject *__pyx_tuple__6; + PyObject *__pyx_tuple__8; + PyObject *__pyx_tuple__10; + PyObject *__pyx_tuple__12; + PyObject *__pyx_tuple__14; + PyObject *__pyx_tuple__16; + PyObject *__pyx_tuple__19; + PyObject *__pyx_tuple__21; + PyObject *__pyx_tuple__25; + PyObject *__pyx_tuple__27; + PyObject *__pyx_tuple__29; + PyObject *__pyx_tuple__31; + PyObject *__pyx_tuple__33; + PyObject *__pyx_tuple__35; + PyObject *__pyx_tuple__39; + PyObject *__pyx_tuple__41; + PyObject *__pyx_tuple__43; + PyObject *__pyx_tuple__45; + PyObject *__pyx_tuple__47; + PyObject *__pyx_tuple__51; + PyObject *__pyx_tuple__54; + PyObject *__pyx_tuple__56; + PyObject *__pyx_tuple__59; + PyObject *__pyx_tuple__61; + PyObject *__pyx_tuple__64; + PyObject *__pyx_tuple__66; + PyObject *__pyx_tuple__68; + PyObject *__pyx_tuple__70; + PyObject *__pyx_tuple__72; + PyObject *__pyx_tuple__74; + PyObject *__pyx_tuple__76; + PyObject *__pyx_tuple__78; + PyObject *__pyx_tuple__83; + PyObject *__pyx_tuple__85; + PyObject *__pyx_tuple__91; + PyObject *__pyx_tuple__97; + PyObject *__pyx_tuple__99; + PyObject *__pyx_codeobj__5; + PyObject *__pyx_codeobj__7; + PyObject *__pyx_codeobj__9; + PyObject *__pyx_tuple__105; + PyObject *__pyx_tuple__113; + PyObject *__pyx_tuple__118; + PyObject *__pyx_codeobj__11; + PyObject *__pyx_codeobj__13; + PyObject *__pyx_codeobj__15; + PyObject *__pyx_codeobj__17; + PyObject *__pyx_codeobj__18; + PyObject *__pyx_codeobj__20; + PyObject *__pyx_codeobj__22; + PyObject *__pyx_codeobj__23; + PyObject *__pyx_codeobj__24; + PyObject *__pyx_codeobj__26; + PyObject *__pyx_codeobj__28; + PyObject *__pyx_codeobj__30; + PyObject *__pyx_codeobj__32; + PyObject *__pyx_codeobj__34; + PyObject *__pyx_codeobj__36; + PyObject *__pyx_codeobj__37; + PyObject *__pyx_codeobj__38; + PyObject *__pyx_codeobj__40; + PyObject *__pyx_codeobj__42; + PyObject *__pyx_codeobj__44; + PyObject *__pyx_codeobj__46; + PyObject *__pyx_codeobj__48; + PyObject *__pyx_codeobj__49; + PyObject *__pyx_codeobj__50; + PyObject *__pyx_codeobj__52; + PyObject *__pyx_codeobj__53; + PyObject *__pyx_codeobj__55; + PyObject *__pyx_codeobj__57; + PyObject *__pyx_codeobj__58; + PyObject *__pyx_codeobj__60; + PyObject *__pyx_codeobj__62; + PyObject *__pyx_codeobj__63; + PyObject *__pyx_codeobj__65; + PyObject *__pyx_codeobj__67; + PyObject *__pyx_codeobj__69; + PyObject *__pyx_codeobj__71; + PyObject *__pyx_codeobj__73; + PyObject *__pyx_codeobj__75; + PyObject *__pyx_codeobj__77; + PyObject *__pyx_codeobj__79; + PyObject *__pyx_codeobj__80; + PyObject *__pyx_codeobj__81; + PyObject *__pyx_codeobj__82; + PyObject *__pyx_codeobj__84; + PyObject *__pyx_codeobj__86; + PyObject *__pyx_codeobj__87; + PyObject *__pyx_codeobj__88; + PyObject *__pyx_codeobj__89; + PyObject *__pyx_codeobj__90; + PyObject *__pyx_codeobj__92; + PyObject *__pyx_codeobj__93; + PyObject *__pyx_codeobj__94; + PyObject *__pyx_codeobj__95; + PyObject *__pyx_codeobj__96; + PyObject *__pyx_codeobj__98; + PyObject *__pyx_codeobj__100; + PyObject *__pyx_codeobj__101; + PyObject *__pyx_codeobj__102; + PyObject *__pyx_codeobj__103; + PyObject *__pyx_codeobj__104; + PyObject *__pyx_codeobj__106; + PyObject *__pyx_codeobj__107; + PyObject *__pyx_codeobj__108; + PyObject *__pyx_codeobj__109; + PyObject *__pyx_codeobj__110; + PyObject *__pyx_codeobj__111; + PyObject *__pyx_codeobj__112; + PyObject *__pyx_codeobj__114; + PyObject *__pyx_codeobj__115; + PyObject *__pyx_codeobj__116; + PyObject *__pyx_codeobj__117; + PyObject *__pyx_codeobj__119; +} __pyx_mstate; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { + extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate(o) ((__pyx_mstate *)__Pyx_PyModule_GetState(o)) + +#define __pyx_mstate_global (__pyx_mstate(PyState_FindModule(&__pyx_moduledef))) + +#define __pyx_m (PyState_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstate __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstate *__pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_clear(PyObject *m) { + __pyx_mstate *clear_module_state = __pyx_mstate(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_CLEAR(clear_module_state->__pyx_FusedFunctionType); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_eth); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_eth); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_ip); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_ip); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_addr); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_addr); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet___addr_ip4_iter); + Py_CLEAR(clear_module_state->__pyx_type_4dnet___addr_ip4_iter); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_arp); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_arp); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_intf); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_intf); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_route); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_route); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_fw); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_fw); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_rand); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_rand); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet___rand_xrange); + Py_CLEAR(clear_module_state->__pyx_type_4dnet___rand_xrange); + Py_CLEAR(clear_module_state->__pyx_ptype_4dnet_tun); + Py_CLEAR(clear_module_state->__pyx_type_4dnet_tun); + Py_CLEAR(clear_module_state->__pyx_kp_u_1_18_0); + Py_CLEAR(clear_module_state->__pyx_n_s_ADDR_TYPE_ETH); + Py_CLEAR(clear_module_state->__pyx_n_s_ADDR_TYPE_IP); + Py_CLEAR(clear_module_state->__pyx_n_s_ADDR_TYPE_IP6); + Py_CLEAR(clear_module_state->__pyx_n_s_ADDR_TYPE_NONE); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_ETHIP_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_HDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_HRD_ETH); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_HRD_IEEE802); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_OP_REPLY); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_OP_REQUEST); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_OP_REVREPLY); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_OP_REVREQUEST); + Py_CLEAR(clear_module_state->__pyx_n_s_ARP_PRO_IP); + Py_CLEAR(clear_module_state->__pyx_n_u_BSD); + Py_CLEAR(clear_module_state->__pyx_kp_u_Copyright_c_2023_2024_Oliver_Fal); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_ADDR_BITS); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_ADDR_BROADCAST); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_ADDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_ADDR_UNSPEC); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_CRC_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_HDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_LEN_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_LEN_MIN); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_MIN); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_MTU); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_8021Q); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_ARP); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_IP); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_IPV6); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_LOOPBACK); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_MPLS); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_MPLS_MCAST); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_PPPOE); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_PPPOEDISC); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_PUP); + Py_CLEAR(clear_module_state->__pyx_n_s_ETH_TYPE_REVARP); + Py_CLEAR(clear_module_state->__pyx_n_s_FW_DIR_IN); + Py_CLEAR(clear_module_state->__pyx_n_s_FW_DIR_OUT); + Py_CLEAR(clear_module_state->__pyx_n_s_FW_OP_ALLOW); + Py_CLEAR(clear_module_state->__pyx_n_s_FW_OP_BLOCK); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_FLAG_BROADCAST); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_FLAG_LOOPBACK); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_FLAG_MULTICAST); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_FLAG_NOARP); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_FLAG_POINTOPOINT); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_FLAG_UP); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_TYPE_ETH); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_TYPE_LOOPBACK); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_TYPE_OTHER); + Py_CLEAR(clear_module_state->__pyx_n_s_INTF_TYPE_TUN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_ADDR_BITS); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_ADDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_ADDR_LOOPBACK); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_ADDR_UNSPEC); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_HDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_HLIM_DEFAULT); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_HLIM_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_LEN_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_LEN_MIN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP6_MTU_MIN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_ADDR_ANY); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_ADDR_BITS); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_ADDR_BROADCAST); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_ADDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_ADDR_LOOPBACK); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_ADDR_MCAST_ALL); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_ADDR_MCAST_LOCAL); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_DF); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_HDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_HDR_LEN_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_LEN_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_LEN_MIN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_MF); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_OFFMASK); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_OPT_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_OPT_LEN_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_AH); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_ESP); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_GRE); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_ICMP); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_ICMPV6); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_IGMP); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_IP); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_IPV6); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_RAW); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_RESERVED); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_TCP); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_PROTO_UDP); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_RF); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_TOS_DEFAULT); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_TTL_DEFAULT); + Py_CLEAR(clear_module_state->__pyx_n_s_IP_TTL_MAX); + Py_CLEAR(clear_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_CLEAR(clear_module_state->__pyx_n_s_NotImplementedError); + Py_CLEAR(clear_module_state->__pyx_n_s_OSError); + Py_CLEAR(clear_module_state->__pyx_kp_u_Oliver_Falk_oliver_linux_kernel); + Py_CLEAR(clear_module_state->__pyx_n_s_OverflowError); + Py_CLEAR(clear_module_state->__pyx_n_s_PickleError); + Py_CLEAR(clear_module_state->__pyx_kp_s_Pickling_of_struct_members_such); + Py_CLEAR(clear_module_state->__pyx_n_s_StopIteration); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_HDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_ALTSUM); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_ALTSUMDATA); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_BUBBA); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_CC); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_CCECHO); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_CCNEW); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_CORRUPT); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_ECHO); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_ECHOREPLY); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_EOL); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_MD5); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_MSS); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_NOP); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_POCONN); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_POSVC); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_REC); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_SACK); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_SACKOK); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_SCPS); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_SKEETER); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_SNACK); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_SNAP); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_TCPCOMP); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_TIMESTAMP); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_TRAILSUM); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_OPT_WSCALE); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_PORT_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_TCP_WIN_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_TH_ACK); + Py_CLEAR(clear_module_state->__pyx_n_s_TH_CWR); + Py_CLEAR(clear_module_state->__pyx_n_s_TH_ECE); + Py_CLEAR(clear_module_state->__pyx_n_s_TH_FIN); + Py_CLEAR(clear_module_state->__pyx_n_s_TH_PUSH); + Py_CLEAR(clear_module_state->__pyx_n_s_TH_RST); + Py_CLEAR(clear_module_state->__pyx_n_s_TH_SYN); + Py_CLEAR(clear_module_state->__pyx_n_s_TH_URG); + Py_CLEAR(clear_module_state->__pyx_n_s_TypeError); + Py_CLEAR(clear_module_state->__pyx_n_s_UDP_HDR_LEN); + Py_CLEAR(clear_module_state->__pyx_n_s_UDP_PORT_MAX); + Py_CLEAR(clear_module_state->__pyx_n_s_ValueError); + Py_CLEAR(clear_module_state->__pyx_n_s__120); + Py_CLEAR(clear_module_state->__pyx_kp_u__3); + Py_CLEAR(clear_module_state->__pyx_n_s_a); + Py_CLEAR(clear_module_state->__pyx_n_s_ack); + Py_CLEAR(clear_module_state->__pyx_n_s_add); + Py_CLEAR(clear_module_state->__pyx_n_s_addr); + Py_CLEAR(clear_module_state->__pyx_n_u_addr); + Py_CLEAR(clear_module_state->__pyx_n_s_addr___copy); + Py_CLEAR(clear_module_state->__pyx_n_s_addr___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_addr___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_addr_bcast); + Py_CLEAR(clear_module_state->__pyx_n_s_addr_ip4_iter); + Py_CLEAR(clear_module_state->__pyx_n_s_addr_ip4_iter___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_addr_ip4_iter___setstate_cytho); + Py_CLEAR(clear_module_state->__pyx_n_s_addr_net); + Py_CLEAR(clear_module_state->__pyx_n_s_addrtxt); + Py_CLEAR(clear_module_state->__pyx_n_s_addrtype); + Py_CLEAR(clear_module_state->__pyx_n_u_alias_addrs); + Py_CLEAR(clear_module_state->__pyx_n_s_append); + Py_CLEAR(clear_module_state->__pyx_n_s_arg); + Py_CLEAR(clear_module_state->__pyx_n_s_arg_2); + Py_CLEAR(clear_module_state->__pyx_n_s_arp); + Py_CLEAR(clear_module_state->__pyx_n_s_arp___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_arp___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_arp_add); + Py_CLEAR(clear_module_state->__pyx_n_s_arp_delete); + Py_CLEAR(clear_module_state->__pyx_n_s_arp_get); + Py_CLEAR(clear_module_state->__pyx_n_s_arp_loop); + Py_CLEAR(clear_module_state->__pyx_n_s_arp_pack_hdr_ethip); + Py_CLEAR(clear_module_state->__pyx_n_s_asyncio_coroutines); + Py_CLEAR(clear_module_state->__pyx_n_s_author); + Py_CLEAR(clear_module_state->__pyx_n_s_bcast); + Py_CLEAR(clear_module_state->__pyx_n_s_buf); + Py_CLEAR(clear_module_state->__pyx_kp_u_byte_binary_string); + Py_CLEAR(clear_module_state->__pyx_n_s_callback); + Py_CLEAR(clear_module_state->__pyx_n_s_cline_in_traceback); + Py_CLEAR(clear_module_state->__pyx_n_s_close); + Py_CLEAR(clear_module_state->__pyx_n_s_code); + Py_CLEAR(clear_module_state->__pyx_n_s_copy); + Py_CLEAR(clear_module_state->__pyx_n_s_copyright); + Py_CLEAR(clear_module_state->__pyx_n_s_cur); + Py_CLEAR(clear_module_state->__pyx_n_s_d); + Py_CLEAR(clear_module_state->__pyx_n_u_d); + Py_CLEAR(clear_module_state->__pyx_n_s_delete); + Py_CLEAR(clear_module_state->__pyx_n_s_device); + Py_CLEAR(clear_module_state->__pyx_n_u_device); + Py_CLEAR(clear_module_state->__pyx_n_s_dh); + Py_CLEAR(clear_module_state->__pyx_n_s_dha); + Py_CLEAR(clear_module_state->__pyx_n_s_dict); + Py_CLEAR(clear_module_state->__pyx_n_s_dict_2); + Py_CLEAR(clear_module_state->__pyx_n_u_dir); + Py_CLEAR(clear_module_state->__pyx_kp_u_disable); + Py_CLEAR(clear_module_state->__pyx_n_s_dnet); + Py_CLEAR(clear_module_state->__pyx_kp_s_dnet_pyx); + Py_CLEAR(clear_module_state->__pyx_n_s_dp); + Py_CLEAR(clear_module_state->__pyx_n_s_dpa); + Py_CLEAR(clear_module_state->__pyx_n_s_dport); + Py_CLEAR(clear_module_state->__pyx_n_u_dport); + Py_CLEAR(clear_module_state->__pyx_n_s_dst); + Py_CLEAR(clear_module_state->__pyx_n_u_dst); + Py_CLEAR(clear_module_state->__pyx_n_u_dst_addr); + Py_CLEAR(clear_module_state->__pyx_n_s_ea); + Py_CLEAR(clear_module_state->__pyx_kp_u_enable); + Py_CLEAR(clear_module_state->__pyx_n_s_entry); + Py_CLEAR(clear_module_state->__pyx_n_s_eth); + Py_CLEAR(clear_module_state->__pyx_n_s_eth___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_eth___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_eth_aton); + Py_CLEAR(clear_module_state->__pyx_n_s_eth_get); + Py_CLEAR(clear_module_state->__pyx_n_s_eth_ntoa); + Py_CLEAR(clear_module_state->__pyx_n_s_eth_pack_hdr); + Py_CLEAR(clear_module_state->__pyx_n_s_eth_send); + Py_CLEAR(clear_module_state->__pyx_n_s_eth_set); + Py_CLEAR(clear_module_state->__pyx_n_s_etype); + Py_CLEAR(clear_module_state->__pyx_n_s_fc); + Py_CLEAR(clear_module_state->__pyx_n_s_fileno); + Py_CLEAR(clear_module_state->__pyx_n_s_fl); + Py_CLEAR(clear_module_state->__pyx_n_s_flags); + Py_CLEAR(clear_module_state->__pyx_n_u_flags); + Py_CLEAR(clear_module_state->__pyx_n_s_frame); + Py_CLEAR(clear_module_state->__pyx_n_s_fw); + Py_CLEAR(clear_module_state->__pyx_n_s_fw___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_fw___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_fw_add); + Py_CLEAR(clear_module_state->__pyx_n_s_fw_delete); + Py_CLEAR(clear_module_state->__pyx_n_s_fw_loop); + Py_CLEAR(clear_module_state->__pyx_kp_u_gc); + Py_CLEAR(clear_module_state->__pyx_n_s_get); + Py_CLEAR(clear_module_state->__pyx_n_s_get_dst); + Py_CLEAR(clear_module_state->__pyx_n_s_get_src); + Py_CLEAR(clear_module_state->__pyx_n_s_getstate); + Py_CLEAR(clear_module_state->__pyx_n_s_gw); + Py_CLEAR(clear_module_state->__pyx_n_s_ha); + Py_CLEAR(clear_module_state->__pyx_n_s_hdr); + Py_CLEAR(clear_module_state->__pyx_n_s_hlim); + Py_CLEAR(clear_module_state->__pyx_kp_u_https_github_com_ofalk_libdnet); + Py_CLEAR(clear_module_state->__pyx_n_s_i); + Py_CLEAR(clear_module_state->__pyx_n_s_ia); + Py_CLEAR(clear_module_state->__pyx_n_s_icmp_pack_hdr); + Py_CLEAR(clear_module_state->__pyx_n_s_id); + Py_CLEAR(clear_module_state->__pyx_n_s_ifent); + Py_CLEAR(clear_module_state->__pyx_n_s_import); + Py_CLEAR(clear_module_state->__pyx_n_s_int); + Py_CLEAR(clear_module_state->__pyx_n_s_intf); + Py_CLEAR(clear_module_state->__pyx_n_s_intf___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_intf___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_intf_get); + Py_CLEAR(clear_module_state->__pyx_n_s_intf_get_dst); + Py_CLEAR(clear_module_state->__pyx_n_s_intf_get_src); + Py_CLEAR(clear_module_state->__pyx_n_s_intf_loop); + Py_CLEAR(clear_module_state->__pyx_n_s_intf_set); + Py_CLEAR(clear_module_state->__pyx_kp_u_invalid_Ethernet_address); + Py_CLEAR(clear_module_state->__pyx_kp_u_invalid_IP_address); + Py_CLEAR(clear_module_state->__pyx_kp_u_invalid_IPv6_address); + Py_CLEAR(clear_module_state->__pyx_kp_u_invalid_network_address); + Py_CLEAR(clear_module_state->__pyx_kp_u_invalid_network_address_2); + Py_CLEAR(clear_module_state->__pyx_n_s_ip); + Py_CLEAR(clear_module_state->__pyx_n_s_ip6); + Py_CLEAR(clear_module_state->__pyx_n_s_ip6_aton); + Py_CLEAR(clear_module_state->__pyx_n_s_ip6_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_ip6_ntoa); + Py_CLEAR(clear_module_state->__pyx_n_s_ip6_pack_hdr); + Py_CLEAR(clear_module_state->__pyx_n_s_ip___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ip___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_ip_aton); + Py_CLEAR(clear_module_state->__pyx_n_s_ip_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_ip_cksum_add); + Py_CLEAR(clear_module_state->__pyx_n_s_ip_cksum_carry); + Py_CLEAR(clear_module_state->__pyx_n_s_ip_ntoa); + Py_CLEAR(clear_module_state->__pyx_n_s_ip_pack_hdr); + Py_CLEAR(clear_module_state->__pyx_n_s_ip_send); + Py_CLEAR(clear_module_state->__pyx_n_s_is_coroutine); + Py_CLEAR(clear_module_state->__pyx_kp_u_isenabled); + Py_CLEAR(clear_module_state->__pyx_n_s_iter_append); + Py_CLEAR(clear_module_state->__pyx_n_s_itype); + Py_CLEAR(clear_module_state->__pyx_n_s_l); + Py_CLEAR(clear_module_state->__pyx_n_s_len); + Py_CLEAR(clear_module_state->__pyx_n_s_license); + Py_CLEAR(clear_module_state->__pyx_n_u_link_addr); + Py_CLEAR(clear_module_state->__pyx_n_s_loop); + Py_CLEAR(clear_module_state->__pyx_n_s_main); + Py_CLEAR(clear_module_state->__pyx_n_s_max); + Py_CLEAR(clear_module_state->__pyx_n_s_mtu); + Py_CLEAR(clear_module_state->__pyx_n_u_mtu); + Py_CLEAR(clear_module_state->__pyx_n_s_n); + Py_CLEAR(clear_module_state->__pyx_n_s_name); + Py_CLEAR(clear_module_state->__pyx_n_u_name); + Py_CLEAR(clear_module_state->__pyx_n_s_name_2); + Py_CLEAR(clear_module_state->__pyx_n_s_net); + Py_CLEAR(clear_module_state->__pyx_n_s_new); + Py_CLEAR(clear_module_state->__pyx_kp_u_non_Ethernet_address); + Py_CLEAR(clear_module_state->__pyx_kp_u_non_IP_address); + Py_CLEAR(clear_module_state->__pyx_kp_u_non_IPv6_address); + Py_CLEAR(clear_module_state->__pyx_kp_u_not_a); + Py_CLEAR(clear_module_state->__pyx_kp_u_not_a_16_byte_string); + Py_CLEAR(clear_module_state->__pyx_kp_u_not_a_4_byte_string); + Py_CLEAR(clear_module_state->__pyx_kp_u_not_a_6_byte_string); + Py_CLEAR(clear_module_state->__pyx_n_s_nxt); + Py_CLEAR(clear_module_state->__pyx_n_s_off); + Py_CLEAR(clear_module_state->__pyx_n_s_op); + Py_CLEAR(clear_module_state->__pyx_n_u_op); + Py_CLEAR(clear_module_state->__pyx_n_s_p); + Py_CLEAR(clear_module_state->__pyx_n_s_pa); + Py_CLEAR(clear_module_state->__pyx_n_s_pickle); + Py_CLEAR(clear_module_state->__pyx_n_s_pkt); + Py_CLEAR(clear_module_state->__pyx_n_s_plen); + Py_CLEAR(clear_module_state->__pyx_n_u_proto); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_PickleError); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_checksum); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_result); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_state); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_type); + Py_CLEAR(clear_module_state->__pyx_n_s_pyx_unpickle___addr_ip4_iter); + Py_CLEAR(clear_module_state->__pyx_n_s_r); + Py_CLEAR(clear_module_state->__pyx_n_s_rand); + Py_CLEAR(clear_module_state->__pyx_n_s_rand___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_rand___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_add); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_get); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_set); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_uint16); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_uint32); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_uint8); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_xrange); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_xrange_2); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_xrange___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_rand_xrange___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_recv); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_reduce_ex); + Py_CLEAR(clear_module_state->__pyx_n_s_route); + Py_CLEAR(clear_module_state->__pyx_n_s_route___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_route___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_route_add); + Py_CLEAR(clear_module_state->__pyx_n_s_route_delete); + Py_CLEAR(clear_module_state->__pyx_n_s_route_get); + Py_CLEAR(clear_module_state->__pyx_n_s_route_loop); + Py_CLEAR(clear_module_state->__pyx_n_s_rule); + Py_CLEAR(clear_module_state->__pyx_n_s_s); + Py_CLEAR(clear_module_state->__pyx_n_s_self); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_arp_cannot_be_converted_to); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_eth_cannot_be_converted_to); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_fw_cannot_be_converted_to_a); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_intf_cannot_be_converted_to); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_ip_cannot_be_converted_to_a); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_rand_cannot_be_converted_to); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_route_cannot_be_converted_t); + Py_CLEAR(clear_module_state->__pyx_kp_s_self_tun_cannot_be_converted_to); + Py_CLEAR(clear_module_state->__pyx_n_s_send); + Py_CLEAR(clear_module_state->__pyx_n_s_seq); + Py_CLEAR(clear_module_state->__pyx_n_s_set); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_sh); + Py_CLEAR(clear_module_state->__pyx_n_s_sha); + Py_CLEAR(clear_module_state->__pyx_n_s_sp); + Py_CLEAR(clear_module_state->__pyx_n_s_spa); + Py_CLEAR(clear_module_state->__pyx_n_s_sport); + Py_CLEAR(clear_module_state->__pyx_n_u_sport); + Py_CLEAR(clear_module_state->__pyx_n_s_src); + Py_CLEAR(clear_module_state->__pyx_n_u_src); + Py_CLEAR(clear_module_state->__pyx_n_s_start); + Py_CLEAR(clear_module_state->__pyx_kp_u_start_must_be_an_integer); + Py_CLEAR(clear_module_state->__pyx_n_s_state); + Py_CLEAR(clear_module_state->__pyx_n_s_stop); + Py_CLEAR(clear_module_state->__pyx_kp_u_stop_must_be_an_integer); + Py_CLEAR(clear_module_state->__pyx_kp_s_stringsource); + Py_CLEAR(clear_module_state->__pyx_n_s_sum); + Py_CLEAR(clear_module_state->__pyx_n_s_tcp_pack_hdr); + Py_CLEAR(clear_module_state->__pyx_n_s_test); + Py_CLEAR(clear_module_state->__pyx_n_s_tos); + Py_CLEAR(clear_module_state->__pyx_n_s_ttl); + Py_CLEAR(clear_module_state->__pyx_n_s_tun); + Py_CLEAR(clear_module_state->__pyx_n_s_tun___reduce_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_tun___setstate_cython); + Py_CLEAR(clear_module_state->__pyx_n_s_tun_close); + Py_CLEAR(clear_module_state->__pyx_n_s_tun_fileno); + Py_CLEAR(clear_module_state->__pyx_n_s_tun_recv); + Py_CLEAR(clear_module_state->__pyx_n_s_tun_send); + Py_CLEAR(clear_module_state->__pyx_n_u_type); + Py_CLEAR(clear_module_state->__pyx_n_s_udp_pack_hdr); + Py_CLEAR(clear_module_state->__pyx_n_s_uint16); + Py_CLEAR(clear_module_state->__pyx_n_s_uint32); + Py_CLEAR(clear_module_state->__pyx_n_s_uint8); + Py_CLEAR(clear_module_state->__pyx_n_s_ulen); + Py_CLEAR(clear_module_state->__pyx_n_s_update); + Py_CLEAR(clear_module_state->__pyx_n_s_url); + Py_CLEAR(clear_module_state->__pyx_n_s_urp); + Py_CLEAR(clear_module_state->__pyx_n_s_use_setstate); + Py_CLEAR(clear_module_state->__pyx_n_s_value); + Py_CLEAR(clear_module_state->__pyx_n_s_version); + Py_CLEAR(clear_module_state->__pyx_n_s_win); + Py_CLEAR(clear_module_state->__pyx_n_s_xrange); + Py_CLEAR(clear_module_state->__pyx_int_0); + Py_CLEAR(clear_module_state->__pyx_int_1); + Py_CLEAR(clear_module_state->__pyx_int_2); + Py_CLEAR(clear_module_state->__pyx_int_3); + Py_CLEAR(clear_module_state->__pyx_int_4); + Py_CLEAR(clear_module_state->__pyx_int_5); + Py_CLEAR(clear_module_state->__pyx_int_6); + Py_CLEAR(clear_module_state->__pyx_int_7); + Py_CLEAR(clear_module_state->__pyx_int_8); + Py_CLEAR(clear_module_state->__pyx_int_9); + Py_CLEAR(clear_module_state->__pyx_int_10); + Py_CLEAR(clear_module_state->__pyx_int_11); + Py_CLEAR(clear_module_state->__pyx_int_12); + Py_CLEAR(clear_module_state->__pyx_int_13); + Py_CLEAR(clear_module_state->__pyx_int_14); + Py_CLEAR(clear_module_state->__pyx_int_15); + Py_CLEAR(clear_module_state->__pyx_int_16); + Py_CLEAR(clear_module_state->__pyx_int_17); + Py_CLEAR(clear_module_state->__pyx_int_18); + Py_CLEAR(clear_module_state->__pyx_int_19); + Py_CLEAR(clear_module_state->__pyx_int_20); + Py_CLEAR(clear_module_state->__pyx_int_21); + Py_CLEAR(clear_module_state->__pyx_int_22); + Py_CLEAR(clear_module_state->__pyx_int_23); + Py_CLEAR(clear_module_state->__pyx_int_24); + Py_CLEAR(clear_module_state->__pyx_int_26); + Py_CLEAR(clear_module_state->__pyx_int_27); + Py_CLEAR(clear_module_state->__pyx_int_32); + Py_CLEAR(clear_module_state->__pyx_int_40); + Py_CLEAR(clear_module_state->__pyx_int_41); + Py_CLEAR(clear_module_state->__pyx_int_47); + Py_CLEAR(clear_module_state->__pyx_int_48); + Py_CLEAR(clear_module_state->__pyx_int_50); + Py_CLEAR(clear_module_state->__pyx_int_51); + Py_CLEAR(clear_module_state->__pyx_int_53); + Py_CLEAR(clear_module_state->__pyx_int_58); + Py_CLEAR(clear_module_state->__pyx_int_64); + Py_CLEAR(clear_module_state->__pyx_int_128); + Py_CLEAR(clear_module_state->__pyx_int_255); + Py_CLEAR(clear_module_state->__pyx_int_512); + Py_CLEAR(clear_module_state->__pyx_int_1024); + Py_CLEAR(clear_module_state->__pyx_int_1280); + Py_CLEAR(clear_module_state->__pyx_int_1500); + Py_CLEAR(clear_module_state->__pyx_int_1518); + Py_CLEAR(clear_module_state->__pyx_int_2048); + Py_CLEAR(clear_module_state->__pyx_int_2054); + Py_CLEAR(clear_module_state->__pyx_int_8191); + Py_CLEAR(clear_module_state->__pyx_int_8192); + Py_CLEAR(clear_module_state->__pyx_int_16384); + Py_CLEAR(clear_module_state->__pyx_int_32768); + Py_CLEAR(clear_module_state->__pyx_int_32821); + Py_CLEAR(clear_module_state->__pyx_int_33024); + Py_CLEAR(clear_module_state->__pyx_int_34525); + Py_CLEAR(clear_module_state->__pyx_int_34887); + Py_CLEAR(clear_module_state->__pyx_int_34888); + Py_CLEAR(clear_module_state->__pyx_int_34915); + Py_CLEAR(clear_module_state->__pyx_int_34916); + Py_CLEAR(clear_module_state->__pyx_int_36864); + Py_CLEAR(clear_module_state->__pyx_int_65535); + Py_CLEAR(clear_module_state->__pyx_int_112194662); + Py_CLEAR(clear_module_state->__pyx_int_113314003); + Py_CLEAR(clear_module_state->__pyx_int_218787872); + Py_CLEAR(clear_module_state->__pyx_k_); + Py_CLEAR(clear_module_state->__pyx_tuple__2); + Py_CLEAR(clear_module_state->__pyx_tuple__4); + Py_CLEAR(clear_module_state->__pyx_tuple__6); + Py_CLEAR(clear_module_state->__pyx_tuple__8); + Py_CLEAR(clear_module_state->__pyx_tuple__10); + Py_CLEAR(clear_module_state->__pyx_tuple__12); + Py_CLEAR(clear_module_state->__pyx_tuple__14); + Py_CLEAR(clear_module_state->__pyx_tuple__16); + Py_CLEAR(clear_module_state->__pyx_tuple__19); + Py_CLEAR(clear_module_state->__pyx_tuple__21); + Py_CLEAR(clear_module_state->__pyx_tuple__25); + Py_CLEAR(clear_module_state->__pyx_tuple__27); + Py_CLEAR(clear_module_state->__pyx_tuple__29); + Py_CLEAR(clear_module_state->__pyx_tuple__31); + Py_CLEAR(clear_module_state->__pyx_tuple__33); + Py_CLEAR(clear_module_state->__pyx_tuple__35); + Py_CLEAR(clear_module_state->__pyx_tuple__39); + Py_CLEAR(clear_module_state->__pyx_tuple__41); + Py_CLEAR(clear_module_state->__pyx_tuple__43); + Py_CLEAR(clear_module_state->__pyx_tuple__45); + Py_CLEAR(clear_module_state->__pyx_tuple__47); + Py_CLEAR(clear_module_state->__pyx_tuple__51); + Py_CLEAR(clear_module_state->__pyx_tuple__54); + Py_CLEAR(clear_module_state->__pyx_tuple__56); + Py_CLEAR(clear_module_state->__pyx_tuple__59); + Py_CLEAR(clear_module_state->__pyx_tuple__61); + Py_CLEAR(clear_module_state->__pyx_tuple__64); + Py_CLEAR(clear_module_state->__pyx_tuple__66); + Py_CLEAR(clear_module_state->__pyx_tuple__68); + Py_CLEAR(clear_module_state->__pyx_tuple__70); + Py_CLEAR(clear_module_state->__pyx_tuple__72); + Py_CLEAR(clear_module_state->__pyx_tuple__74); + Py_CLEAR(clear_module_state->__pyx_tuple__76); + Py_CLEAR(clear_module_state->__pyx_tuple__78); + Py_CLEAR(clear_module_state->__pyx_tuple__83); + Py_CLEAR(clear_module_state->__pyx_tuple__85); + Py_CLEAR(clear_module_state->__pyx_tuple__91); + Py_CLEAR(clear_module_state->__pyx_tuple__97); + Py_CLEAR(clear_module_state->__pyx_tuple__99); + Py_CLEAR(clear_module_state->__pyx_codeobj__5); + Py_CLEAR(clear_module_state->__pyx_codeobj__7); + Py_CLEAR(clear_module_state->__pyx_codeobj__9); + Py_CLEAR(clear_module_state->__pyx_tuple__105); + Py_CLEAR(clear_module_state->__pyx_tuple__113); + Py_CLEAR(clear_module_state->__pyx_tuple__118); + Py_CLEAR(clear_module_state->__pyx_codeobj__11); + Py_CLEAR(clear_module_state->__pyx_codeobj__13); + Py_CLEAR(clear_module_state->__pyx_codeobj__15); + Py_CLEAR(clear_module_state->__pyx_codeobj__17); + Py_CLEAR(clear_module_state->__pyx_codeobj__18); + Py_CLEAR(clear_module_state->__pyx_codeobj__20); + Py_CLEAR(clear_module_state->__pyx_codeobj__22); + Py_CLEAR(clear_module_state->__pyx_codeobj__23); + Py_CLEAR(clear_module_state->__pyx_codeobj__24); + Py_CLEAR(clear_module_state->__pyx_codeobj__26); + Py_CLEAR(clear_module_state->__pyx_codeobj__28); + Py_CLEAR(clear_module_state->__pyx_codeobj__30); + Py_CLEAR(clear_module_state->__pyx_codeobj__32); + Py_CLEAR(clear_module_state->__pyx_codeobj__34); + Py_CLEAR(clear_module_state->__pyx_codeobj__36); + Py_CLEAR(clear_module_state->__pyx_codeobj__37); + Py_CLEAR(clear_module_state->__pyx_codeobj__38); + Py_CLEAR(clear_module_state->__pyx_codeobj__40); + Py_CLEAR(clear_module_state->__pyx_codeobj__42); + Py_CLEAR(clear_module_state->__pyx_codeobj__44); + Py_CLEAR(clear_module_state->__pyx_codeobj__46); + Py_CLEAR(clear_module_state->__pyx_codeobj__48); + Py_CLEAR(clear_module_state->__pyx_codeobj__49); + Py_CLEAR(clear_module_state->__pyx_codeobj__50); + Py_CLEAR(clear_module_state->__pyx_codeobj__52); + Py_CLEAR(clear_module_state->__pyx_codeobj__53); + Py_CLEAR(clear_module_state->__pyx_codeobj__55); + Py_CLEAR(clear_module_state->__pyx_codeobj__57); + Py_CLEAR(clear_module_state->__pyx_codeobj__58); + Py_CLEAR(clear_module_state->__pyx_codeobj__60); + Py_CLEAR(clear_module_state->__pyx_codeobj__62); + Py_CLEAR(clear_module_state->__pyx_codeobj__63); + Py_CLEAR(clear_module_state->__pyx_codeobj__65); + Py_CLEAR(clear_module_state->__pyx_codeobj__67); + Py_CLEAR(clear_module_state->__pyx_codeobj__69); + Py_CLEAR(clear_module_state->__pyx_codeobj__71); + Py_CLEAR(clear_module_state->__pyx_codeobj__73); + Py_CLEAR(clear_module_state->__pyx_codeobj__75); + Py_CLEAR(clear_module_state->__pyx_codeobj__77); + Py_CLEAR(clear_module_state->__pyx_codeobj__79); + Py_CLEAR(clear_module_state->__pyx_codeobj__80); + Py_CLEAR(clear_module_state->__pyx_codeobj__81); + Py_CLEAR(clear_module_state->__pyx_codeobj__82); + Py_CLEAR(clear_module_state->__pyx_codeobj__84); + Py_CLEAR(clear_module_state->__pyx_codeobj__86); + Py_CLEAR(clear_module_state->__pyx_codeobj__87); + Py_CLEAR(clear_module_state->__pyx_codeobj__88); + Py_CLEAR(clear_module_state->__pyx_codeobj__89); + Py_CLEAR(clear_module_state->__pyx_codeobj__90); + Py_CLEAR(clear_module_state->__pyx_codeobj__92); + Py_CLEAR(clear_module_state->__pyx_codeobj__93); + Py_CLEAR(clear_module_state->__pyx_codeobj__94); + Py_CLEAR(clear_module_state->__pyx_codeobj__95); + Py_CLEAR(clear_module_state->__pyx_codeobj__96); + Py_CLEAR(clear_module_state->__pyx_codeobj__98); + Py_CLEAR(clear_module_state->__pyx_codeobj__100); + Py_CLEAR(clear_module_state->__pyx_codeobj__101); + Py_CLEAR(clear_module_state->__pyx_codeobj__102); + Py_CLEAR(clear_module_state->__pyx_codeobj__103); + Py_CLEAR(clear_module_state->__pyx_codeobj__104); + Py_CLEAR(clear_module_state->__pyx_codeobj__106); + Py_CLEAR(clear_module_state->__pyx_codeobj__107); + Py_CLEAR(clear_module_state->__pyx_codeobj__108); + Py_CLEAR(clear_module_state->__pyx_codeobj__109); + Py_CLEAR(clear_module_state->__pyx_codeobj__110); + Py_CLEAR(clear_module_state->__pyx_codeobj__111); + Py_CLEAR(clear_module_state->__pyx_codeobj__112); + Py_CLEAR(clear_module_state->__pyx_codeobj__114); + Py_CLEAR(clear_module_state->__pyx_codeobj__115); + Py_CLEAR(clear_module_state->__pyx_codeobj__116); + Py_CLEAR(clear_module_state->__pyx_codeobj__117); + Py_CLEAR(clear_module_state->__pyx_codeobj__119); + return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstate *traverse_module_state = __pyx_mstate(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + Py_VISIT(traverse_module_state->__pyx_empty_tuple); + Py_VISIT(traverse_module_state->__pyx_empty_bytes); + Py_VISIT(traverse_module_state->__pyx_empty_unicode); + #ifdef __Pyx_CyFunction_USED + Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + #endif + #ifdef __Pyx_FusedFunction_USED + Py_VISIT(traverse_module_state->__pyx_FusedFunctionType); + #endif + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_eth); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_eth); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_ip); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_ip); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_addr); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_addr); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet___addr_ip4_iter); + Py_VISIT(traverse_module_state->__pyx_type_4dnet___addr_ip4_iter); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_arp); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_arp); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_intf); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_intf); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_route); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_route); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_fw); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_fw); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_rand); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_rand); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet___rand_xrange); + Py_VISIT(traverse_module_state->__pyx_type_4dnet___rand_xrange); + Py_VISIT(traverse_module_state->__pyx_ptype_4dnet_tun); + Py_VISIT(traverse_module_state->__pyx_type_4dnet_tun); + Py_VISIT(traverse_module_state->__pyx_kp_u_1_18_0); + Py_VISIT(traverse_module_state->__pyx_n_s_ADDR_TYPE_ETH); + Py_VISIT(traverse_module_state->__pyx_n_s_ADDR_TYPE_IP); + Py_VISIT(traverse_module_state->__pyx_n_s_ADDR_TYPE_IP6); + Py_VISIT(traverse_module_state->__pyx_n_s_ADDR_TYPE_NONE); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_ETHIP_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_HDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_HRD_ETH); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_HRD_IEEE802); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_OP_REPLY); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_OP_REQUEST); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_OP_REVREPLY); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_OP_REVREQUEST); + Py_VISIT(traverse_module_state->__pyx_n_s_ARP_PRO_IP); + Py_VISIT(traverse_module_state->__pyx_n_u_BSD); + Py_VISIT(traverse_module_state->__pyx_kp_u_Copyright_c_2023_2024_Oliver_Fal); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_ADDR_BITS); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_ADDR_BROADCAST); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_ADDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_ADDR_UNSPEC); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_CRC_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_HDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_LEN_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_LEN_MIN); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_MIN); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_MTU); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_8021Q); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_ARP); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_IP); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_IPV6); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_LOOPBACK); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_MPLS); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_MPLS_MCAST); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_PPPOE); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_PPPOEDISC); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_PUP); + Py_VISIT(traverse_module_state->__pyx_n_s_ETH_TYPE_REVARP); + Py_VISIT(traverse_module_state->__pyx_n_s_FW_DIR_IN); + Py_VISIT(traverse_module_state->__pyx_n_s_FW_DIR_OUT); + Py_VISIT(traverse_module_state->__pyx_n_s_FW_OP_ALLOW); + Py_VISIT(traverse_module_state->__pyx_n_s_FW_OP_BLOCK); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_FLAG_BROADCAST); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_FLAG_LOOPBACK); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_FLAG_MULTICAST); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_FLAG_NOARP); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_FLAG_POINTOPOINT); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_FLAG_UP); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_TYPE_ETH); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_TYPE_LOOPBACK); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_TYPE_OTHER); + Py_VISIT(traverse_module_state->__pyx_n_s_INTF_TYPE_TUN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_ADDR_BITS); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_ADDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_ADDR_LOOPBACK); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_ADDR_UNSPEC); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_HDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_HLIM_DEFAULT); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_HLIM_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_LEN_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_LEN_MIN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP6_MTU_MIN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_ADDR_ANY); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_ADDR_BITS); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_ADDR_BROADCAST); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_ADDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_ADDR_LOOPBACK); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_ADDR_MCAST_ALL); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_ADDR_MCAST_LOCAL); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_DF); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_HDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_HDR_LEN_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_LEN_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_LEN_MIN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_MF); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_OFFMASK); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_OPT_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_OPT_LEN_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_AH); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_ESP); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_GRE); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_ICMP); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_ICMPV6); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_IGMP); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_IP); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_IPV6); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_RAW); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_RESERVED); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_TCP); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_PROTO_UDP); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_RF); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_TOS_DEFAULT); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_TTL_DEFAULT); + Py_VISIT(traverse_module_state->__pyx_n_s_IP_TTL_MAX); + Py_VISIT(traverse_module_state->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0); + Py_VISIT(traverse_module_state->__pyx_n_s_NotImplementedError); + Py_VISIT(traverse_module_state->__pyx_n_s_OSError); + Py_VISIT(traverse_module_state->__pyx_kp_u_Oliver_Falk_oliver_linux_kernel); + Py_VISIT(traverse_module_state->__pyx_n_s_OverflowError); + Py_VISIT(traverse_module_state->__pyx_n_s_PickleError); + Py_VISIT(traverse_module_state->__pyx_kp_s_Pickling_of_struct_members_such); + Py_VISIT(traverse_module_state->__pyx_n_s_StopIteration); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_HDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_ALTSUM); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_ALTSUMDATA); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_BUBBA); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_CC); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_CCECHO); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_CCNEW); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_CORRUPT); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_ECHO); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_ECHOREPLY); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_EOL); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_MD5); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_MSS); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_NOP); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_POCONN); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_POSVC); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_REC); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_SACK); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_SACKOK); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_SCPS); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_SKEETER); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_SNACK); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_SNAP); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_TCPCOMP); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_TIMESTAMP); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_TRAILSUM); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_OPT_WSCALE); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_PORT_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_TCP_WIN_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_TH_ACK); + Py_VISIT(traverse_module_state->__pyx_n_s_TH_CWR); + Py_VISIT(traverse_module_state->__pyx_n_s_TH_ECE); + Py_VISIT(traverse_module_state->__pyx_n_s_TH_FIN); + Py_VISIT(traverse_module_state->__pyx_n_s_TH_PUSH); + Py_VISIT(traverse_module_state->__pyx_n_s_TH_RST); + Py_VISIT(traverse_module_state->__pyx_n_s_TH_SYN); + Py_VISIT(traverse_module_state->__pyx_n_s_TH_URG); + Py_VISIT(traverse_module_state->__pyx_n_s_TypeError); + Py_VISIT(traverse_module_state->__pyx_n_s_UDP_HDR_LEN); + Py_VISIT(traverse_module_state->__pyx_n_s_UDP_PORT_MAX); + Py_VISIT(traverse_module_state->__pyx_n_s_ValueError); + Py_VISIT(traverse_module_state->__pyx_n_s__120); + Py_VISIT(traverse_module_state->__pyx_kp_u__3); + Py_VISIT(traverse_module_state->__pyx_n_s_a); + Py_VISIT(traverse_module_state->__pyx_n_s_ack); + Py_VISIT(traverse_module_state->__pyx_n_s_add); + Py_VISIT(traverse_module_state->__pyx_n_s_addr); + Py_VISIT(traverse_module_state->__pyx_n_u_addr); + Py_VISIT(traverse_module_state->__pyx_n_s_addr___copy); + Py_VISIT(traverse_module_state->__pyx_n_s_addr___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_addr___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_addr_bcast); + Py_VISIT(traverse_module_state->__pyx_n_s_addr_ip4_iter); + Py_VISIT(traverse_module_state->__pyx_n_s_addr_ip4_iter___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_addr_ip4_iter___setstate_cytho); + Py_VISIT(traverse_module_state->__pyx_n_s_addr_net); + Py_VISIT(traverse_module_state->__pyx_n_s_addrtxt); + Py_VISIT(traverse_module_state->__pyx_n_s_addrtype); + Py_VISIT(traverse_module_state->__pyx_n_u_alias_addrs); + Py_VISIT(traverse_module_state->__pyx_n_s_append); + Py_VISIT(traverse_module_state->__pyx_n_s_arg); + Py_VISIT(traverse_module_state->__pyx_n_s_arg_2); + Py_VISIT(traverse_module_state->__pyx_n_s_arp); + Py_VISIT(traverse_module_state->__pyx_n_s_arp___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_arp___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_arp_add); + Py_VISIT(traverse_module_state->__pyx_n_s_arp_delete); + Py_VISIT(traverse_module_state->__pyx_n_s_arp_get); + Py_VISIT(traverse_module_state->__pyx_n_s_arp_loop); + Py_VISIT(traverse_module_state->__pyx_n_s_arp_pack_hdr_ethip); + Py_VISIT(traverse_module_state->__pyx_n_s_asyncio_coroutines); + Py_VISIT(traverse_module_state->__pyx_n_s_author); + Py_VISIT(traverse_module_state->__pyx_n_s_bcast); + Py_VISIT(traverse_module_state->__pyx_n_s_buf); + Py_VISIT(traverse_module_state->__pyx_kp_u_byte_binary_string); + Py_VISIT(traverse_module_state->__pyx_n_s_callback); + Py_VISIT(traverse_module_state->__pyx_n_s_cline_in_traceback); + Py_VISIT(traverse_module_state->__pyx_n_s_close); + Py_VISIT(traverse_module_state->__pyx_n_s_code); + Py_VISIT(traverse_module_state->__pyx_n_s_copy); + Py_VISIT(traverse_module_state->__pyx_n_s_copyright); + Py_VISIT(traverse_module_state->__pyx_n_s_cur); + Py_VISIT(traverse_module_state->__pyx_n_s_d); + Py_VISIT(traverse_module_state->__pyx_n_u_d); + Py_VISIT(traverse_module_state->__pyx_n_s_delete); + Py_VISIT(traverse_module_state->__pyx_n_s_device); + Py_VISIT(traverse_module_state->__pyx_n_u_device); + Py_VISIT(traverse_module_state->__pyx_n_s_dh); + Py_VISIT(traverse_module_state->__pyx_n_s_dha); + Py_VISIT(traverse_module_state->__pyx_n_s_dict); + Py_VISIT(traverse_module_state->__pyx_n_s_dict_2); + Py_VISIT(traverse_module_state->__pyx_n_u_dir); + Py_VISIT(traverse_module_state->__pyx_kp_u_disable); + Py_VISIT(traverse_module_state->__pyx_n_s_dnet); + Py_VISIT(traverse_module_state->__pyx_kp_s_dnet_pyx); + Py_VISIT(traverse_module_state->__pyx_n_s_dp); + Py_VISIT(traverse_module_state->__pyx_n_s_dpa); + Py_VISIT(traverse_module_state->__pyx_n_s_dport); + Py_VISIT(traverse_module_state->__pyx_n_u_dport); + Py_VISIT(traverse_module_state->__pyx_n_s_dst); + Py_VISIT(traverse_module_state->__pyx_n_u_dst); + Py_VISIT(traverse_module_state->__pyx_n_u_dst_addr); + Py_VISIT(traverse_module_state->__pyx_n_s_ea); + Py_VISIT(traverse_module_state->__pyx_kp_u_enable); + Py_VISIT(traverse_module_state->__pyx_n_s_entry); + Py_VISIT(traverse_module_state->__pyx_n_s_eth); + Py_VISIT(traverse_module_state->__pyx_n_s_eth___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_eth___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_eth_aton); + Py_VISIT(traverse_module_state->__pyx_n_s_eth_get); + Py_VISIT(traverse_module_state->__pyx_n_s_eth_ntoa); + Py_VISIT(traverse_module_state->__pyx_n_s_eth_pack_hdr); + Py_VISIT(traverse_module_state->__pyx_n_s_eth_send); + Py_VISIT(traverse_module_state->__pyx_n_s_eth_set); + Py_VISIT(traverse_module_state->__pyx_n_s_etype); + Py_VISIT(traverse_module_state->__pyx_n_s_fc); + Py_VISIT(traverse_module_state->__pyx_n_s_fileno); + Py_VISIT(traverse_module_state->__pyx_n_s_fl); + Py_VISIT(traverse_module_state->__pyx_n_s_flags); + Py_VISIT(traverse_module_state->__pyx_n_u_flags); + Py_VISIT(traverse_module_state->__pyx_n_s_frame); + Py_VISIT(traverse_module_state->__pyx_n_s_fw); + Py_VISIT(traverse_module_state->__pyx_n_s_fw___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_fw___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_fw_add); + Py_VISIT(traverse_module_state->__pyx_n_s_fw_delete); + Py_VISIT(traverse_module_state->__pyx_n_s_fw_loop); + Py_VISIT(traverse_module_state->__pyx_kp_u_gc); + Py_VISIT(traverse_module_state->__pyx_n_s_get); + Py_VISIT(traverse_module_state->__pyx_n_s_get_dst); + Py_VISIT(traverse_module_state->__pyx_n_s_get_src); + Py_VISIT(traverse_module_state->__pyx_n_s_getstate); + Py_VISIT(traverse_module_state->__pyx_n_s_gw); + Py_VISIT(traverse_module_state->__pyx_n_s_ha); + Py_VISIT(traverse_module_state->__pyx_n_s_hdr); + Py_VISIT(traverse_module_state->__pyx_n_s_hlim); + Py_VISIT(traverse_module_state->__pyx_kp_u_https_github_com_ofalk_libdnet); + Py_VISIT(traverse_module_state->__pyx_n_s_i); + Py_VISIT(traverse_module_state->__pyx_n_s_ia); + Py_VISIT(traverse_module_state->__pyx_n_s_icmp_pack_hdr); + Py_VISIT(traverse_module_state->__pyx_n_s_id); + Py_VISIT(traverse_module_state->__pyx_n_s_ifent); + Py_VISIT(traverse_module_state->__pyx_n_s_import); + Py_VISIT(traverse_module_state->__pyx_n_s_int); + Py_VISIT(traverse_module_state->__pyx_n_s_intf); + Py_VISIT(traverse_module_state->__pyx_n_s_intf___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_intf___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_intf_get); + Py_VISIT(traverse_module_state->__pyx_n_s_intf_get_dst); + Py_VISIT(traverse_module_state->__pyx_n_s_intf_get_src); + Py_VISIT(traverse_module_state->__pyx_n_s_intf_loop); + Py_VISIT(traverse_module_state->__pyx_n_s_intf_set); + Py_VISIT(traverse_module_state->__pyx_kp_u_invalid_Ethernet_address); + Py_VISIT(traverse_module_state->__pyx_kp_u_invalid_IP_address); + Py_VISIT(traverse_module_state->__pyx_kp_u_invalid_IPv6_address); + Py_VISIT(traverse_module_state->__pyx_kp_u_invalid_network_address); + Py_VISIT(traverse_module_state->__pyx_kp_u_invalid_network_address_2); + Py_VISIT(traverse_module_state->__pyx_n_s_ip); + Py_VISIT(traverse_module_state->__pyx_n_s_ip6); + Py_VISIT(traverse_module_state->__pyx_n_s_ip6_aton); + Py_VISIT(traverse_module_state->__pyx_n_s_ip6_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_ip6_ntoa); + Py_VISIT(traverse_module_state->__pyx_n_s_ip6_pack_hdr); + Py_VISIT(traverse_module_state->__pyx_n_s_ip___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ip___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_ip_aton); + Py_VISIT(traverse_module_state->__pyx_n_s_ip_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_ip_cksum_add); + Py_VISIT(traverse_module_state->__pyx_n_s_ip_cksum_carry); + Py_VISIT(traverse_module_state->__pyx_n_s_ip_ntoa); + Py_VISIT(traverse_module_state->__pyx_n_s_ip_pack_hdr); + Py_VISIT(traverse_module_state->__pyx_n_s_ip_send); + Py_VISIT(traverse_module_state->__pyx_n_s_is_coroutine); + Py_VISIT(traverse_module_state->__pyx_kp_u_isenabled); + Py_VISIT(traverse_module_state->__pyx_n_s_iter_append); + Py_VISIT(traverse_module_state->__pyx_n_s_itype); + Py_VISIT(traverse_module_state->__pyx_n_s_l); + Py_VISIT(traverse_module_state->__pyx_n_s_len); + Py_VISIT(traverse_module_state->__pyx_n_s_license); + Py_VISIT(traverse_module_state->__pyx_n_u_link_addr); + Py_VISIT(traverse_module_state->__pyx_n_s_loop); + Py_VISIT(traverse_module_state->__pyx_n_s_main); + Py_VISIT(traverse_module_state->__pyx_n_s_max); + Py_VISIT(traverse_module_state->__pyx_n_s_mtu); + Py_VISIT(traverse_module_state->__pyx_n_u_mtu); + Py_VISIT(traverse_module_state->__pyx_n_s_n); + Py_VISIT(traverse_module_state->__pyx_n_s_name); + Py_VISIT(traverse_module_state->__pyx_n_u_name); + Py_VISIT(traverse_module_state->__pyx_n_s_name_2); + Py_VISIT(traverse_module_state->__pyx_n_s_net); + Py_VISIT(traverse_module_state->__pyx_n_s_new); + Py_VISIT(traverse_module_state->__pyx_kp_u_non_Ethernet_address); + Py_VISIT(traverse_module_state->__pyx_kp_u_non_IP_address); + Py_VISIT(traverse_module_state->__pyx_kp_u_non_IPv6_address); + Py_VISIT(traverse_module_state->__pyx_kp_u_not_a); + Py_VISIT(traverse_module_state->__pyx_kp_u_not_a_16_byte_string); + Py_VISIT(traverse_module_state->__pyx_kp_u_not_a_4_byte_string); + Py_VISIT(traverse_module_state->__pyx_kp_u_not_a_6_byte_string); + Py_VISIT(traverse_module_state->__pyx_n_s_nxt); + Py_VISIT(traverse_module_state->__pyx_n_s_off); + Py_VISIT(traverse_module_state->__pyx_n_s_op); + Py_VISIT(traverse_module_state->__pyx_n_u_op); + Py_VISIT(traverse_module_state->__pyx_n_s_p); + Py_VISIT(traverse_module_state->__pyx_n_s_pa); + Py_VISIT(traverse_module_state->__pyx_n_s_pickle); + Py_VISIT(traverse_module_state->__pyx_n_s_pkt); + Py_VISIT(traverse_module_state->__pyx_n_s_plen); + Py_VISIT(traverse_module_state->__pyx_n_u_proto); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_PickleError); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_checksum); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_result); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_state); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_type); + Py_VISIT(traverse_module_state->__pyx_n_s_pyx_unpickle___addr_ip4_iter); + Py_VISIT(traverse_module_state->__pyx_n_s_r); + Py_VISIT(traverse_module_state->__pyx_n_s_rand); + Py_VISIT(traverse_module_state->__pyx_n_s_rand___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_rand___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_add); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_get); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_set); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_uint16); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_uint32); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_uint8); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_xrange); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_xrange_2); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_xrange___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_rand_xrange___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_recv); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_reduce_ex); + Py_VISIT(traverse_module_state->__pyx_n_s_route); + Py_VISIT(traverse_module_state->__pyx_n_s_route___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_route___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_route_add); + Py_VISIT(traverse_module_state->__pyx_n_s_route_delete); + Py_VISIT(traverse_module_state->__pyx_n_s_route_get); + Py_VISIT(traverse_module_state->__pyx_n_s_route_loop); + Py_VISIT(traverse_module_state->__pyx_n_s_rule); + Py_VISIT(traverse_module_state->__pyx_n_s_s); + Py_VISIT(traverse_module_state->__pyx_n_s_self); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_arp_cannot_be_converted_to); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_eth_cannot_be_converted_to); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_fw_cannot_be_converted_to_a); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_intf_cannot_be_converted_to); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_ip_cannot_be_converted_to_a); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_rand_cannot_be_converted_to); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_route_cannot_be_converted_t); + Py_VISIT(traverse_module_state->__pyx_kp_s_self_tun_cannot_be_converted_to); + Py_VISIT(traverse_module_state->__pyx_n_s_send); + Py_VISIT(traverse_module_state->__pyx_n_s_seq); + Py_VISIT(traverse_module_state->__pyx_n_s_set); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_sh); + Py_VISIT(traverse_module_state->__pyx_n_s_sha); + Py_VISIT(traverse_module_state->__pyx_n_s_sp); + Py_VISIT(traverse_module_state->__pyx_n_s_spa); + Py_VISIT(traverse_module_state->__pyx_n_s_sport); + Py_VISIT(traverse_module_state->__pyx_n_u_sport); + Py_VISIT(traverse_module_state->__pyx_n_s_src); + Py_VISIT(traverse_module_state->__pyx_n_u_src); + Py_VISIT(traverse_module_state->__pyx_n_s_start); + Py_VISIT(traverse_module_state->__pyx_kp_u_start_must_be_an_integer); + Py_VISIT(traverse_module_state->__pyx_n_s_state); + Py_VISIT(traverse_module_state->__pyx_n_s_stop); + Py_VISIT(traverse_module_state->__pyx_kp_u_stop_must_be_an_integer); + Py_VISIT(traverse_module_state->__pyx_kp_s_stringsource); + Py_VISIT(traverse_module_state->__pyx_n_s_sum); + Py_VISIT(traverse_module_state->__pyx_n_s_tcp_pack_hdr); + Py_VISIT(traverse_module_state->__pyx_n_s_test); + Py_VISIT(traverse_module_state->__pyx_n_s_tos); + Py_VISIT(traverse_module_state->__pyx_n_s_ttl); + Py_VISIT(traverse_module_state->__pyx_n_s_tun); + Py_VISIT(traverse_module_state->__pyx_n_s_tun___reduce_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_tun___setstate_cython); + Py_VISIT(traverse_module_state->__pyx_n_s_tun_close); + Py_VISIT(traverse_module_state->__pyx_n_s_tun_fileno); + Py_VISIT(traverse_module_state->__pyx_n_s_tun_recv); + Py_VISIT(traverse_module_state->__pyx_n_s_tun_send); + Py_VISIT(traverse_module_state->__pyx_n_u_type); + Py_VISIT(traverse_module_state->__pyx_n_s_udp_pack_hdr); + Py_VISIT(traverse_module_state->__pyx_n_s_uint16); + Py_VISIT(traverse_module_state->__pyx_n_s_uint32); + Py_VISIT(traverse_module_state->__pyx_n_s_uint8); + Py_VISIT(traverse_module_state->__pyx_n_s_ulen); + Py_VISIT(traverse_module_state->__pyx_n_s_update); + Py_VISIT(traverse_module_state->__pyx_n_s_url); + Py_VISIT(traverse_module_state->__pyx_n_s_urp); + Py_VISIT(traverse_module_state->__pyx_n_s_use_setstate); + Py_VISIT(traverse_module_state->__pyx_n_s_value); + Py_VISIT(traverse_module_state->__pyx_n_s_version); + Py_VISIT(traverse_module_state->__pyx_n_s_win); + Py_VISIT(traverse_module_state->__pyx_n_s_xrange); + Py_VISIT(traverse_module_state->__pyx_int_0); + Py_VISIT(traverse_module_state->__pyx_int_1); + Py_VISIT(traverse_module_state->__pyx_int_2); + Py_VISIT(traverse_module_state->__pyx_int_3); + Py_VISIT(traverse_module_state->__pyx_int_4); + Py_VISIT(traverse_module_state->__pyx_int_5); + Py_VISIT(traverse_module_state->__pyx_int_6); + Py_VISIT(traverse_module_state->__pyx_int_7); + Py_VISIT(traverse_module_state->__pyx_int_8); + Py_VISIT(traverse_module_state->__pyx_int_9); + Py_VISIT(traverse_module_state->__pyx_int_10); + Py_VISIT(traverse_module_state->__pyx_int_11); + Py_VISIT(traverse_module_state->__pyx_int_12); + Py_VISIT(traverse_module_state->__pyx_int_13); + Py_VISIT(traverse_module_state->__pyx_int_14); + Py_VISIT(traverse_module_state->__pyx_int_15); + Py_VISIT(traverse_module_state->__pyx_int_16); + Py_VISIT(traverse_module_state->__pyx_int_17); + Py_VISIT(traverse_module_state->__pyx_int_18); + Py_VISIT(traverse_module_state->__pyx_int_19); + Py_VISIT(traverse_module_state->__pyx_int_20); + Py_VISIT(traverse_module_state->__pyx_int_21); + Py_VISIT(traverse_module_state->__pyx_int_22); + Py_VISIT(traverse_module_state->__pyx_int_23); + Py_VISIT(traverse_module_state->__pyx_int_24); + Py_VISIT(traverse_module_state->__pyx_int_26); + Py_VISIT(traverse_module_state->__pyx_int_27); + Py_VISIT(traverse_module_state->__pyx_int_32); + Py_VISIT(traverse_module_state->__pyx_int_40); + Py_VISIT(traverse_module_state->__pyx_int_41); + Py_VISIT(traverse_module_state->__pyx_int_47); + Py_VISIT(traverse_module_state->__pyx_int_48); + Py_VISIT(traverse_module_state->__pyx_int_50); + Py_VISIT(traverse_module_state->__pyx_int_51); + Py_VISIT(traverse_module_state->__pyx_int_53); + Py_VISIT(traverse_module_state->__pyx_int_58); + Py_VISIT(traverse_module_state->__pyx_int_64); + Py_VISIT(traverse_module_state->__pyx_int_128); + Py_VISIT(traverse_module_state->__pyx_int_255); + Py_VISIT(traverse_module_state->__pyx_int_512); + Py_VISIT(traverse_module_state->__pyx_int_1024); + Py_VISIT(traverse_module_state->__pyx_int_1280); + Py_VISIT(traverse_module_state->__pyx_int_1500); + Py_VISIT(traverse_module_state->__pyx_int_1518); + Py_VISIT(traverse_module_state->__pyx_int_2048); + Py_VISIT(traverse_module_state->__pyx_int_2054); + Py_VISIT(traverse_module_state->__pyx_int_8191); + Py_VISIT(traverse_module_state->__pyx_int_8192); + Py_VISIT(traverse_module_state->__pyx_int_16384); + Py_VISIT(traverse_module_state->__pyx_int_32768); + Py_VISIT(traverse_module_state->__pyx_int_32821); + Py_VISIT(traverse_module_state->__pyx_int_33024); + Py_VISIT(traverse_module_state->__pyx_int_34525); + Py_VISIT(traverse_module_state->__pyx_int_34887); + Py_VISIT(traverse_module_state->__pyx_int_34888); + Py_VISIT(traverse_module_state->__pyx_int_34915); + Py_VISIT(traverse_module_state->__pyx_int_34916); + Py_VISIT(traverse_module_state->__pyx_int_36864); + Py_VISIT(traverse_module_state->__pyx_int_65535); + Py_VISIT(traverse_module_state->__pyx_int_112194662); + Py_VISIT(traverse_module_state->__pyx_int_113314003); + Py_VISIT(traverse_module_state->__pyx_int_218787872); + Py_VISIT(traverse_module_state->__pyx_k_); + Py_VISIT(traverse_module_state->__pyx_tuple__2); + Py_VISIT(traverse_module_state->__pyx_tuple__4); + Py_VISIT(traverse_module_state->__pyx_tuple__6); + Py_VISIT(traverse_module_state->__pyx_tuple__8); + Py_VISIT(traverse_module_state->__pyx_tuple__10); + Py_VISIT(traverse_module_state->__pyx_tuple__12); + Py_VISIT(traverse_module_state->__pyx_tuple__14); + Py_VISIT(traverse_module_state->__pyx_tuple__16); + Py_VISIT(traverse_module_state->__pyx_tuple__19); + Py_VISIT(traverse_module_state->__pyx_tuple__21); + Py_VISIT(traverse_module_state->__pyx_tuple__25); + Py_VISIT(traverse_module_state->__pyx_tuple__27); + Py_VISIT(traverse_module_state->__pyx_tuple__29); + Py_VISIT(traverse_module_state->__pyx_tuple__31); + Py_VISIT(traverse_module_state->__pyx_tuple__33); + Py_VISIT(traverse_module_state->__pyx_tuple__35); + Py_VISIT(traverse_module_state->__pyx_tuple__39); + Py_VISIT(traverse_module_state->__pyx_tuple__41); + Py_VISIT(traverse_module_state->__pyx_tuple__43); + Py_VISIT(traverse_module_state->__pyx_tuple__45); + Py_VISIT(traverse_module_state->__pyx_tuple__47); + Py_VISIT(traverse_module_state->__pyx_tuple__51); + Py_VISIT(traverse_module_state->__pyx_tuple__54); + Py_VISIT(traverse_module_state->__pyx_tuple__56); + Py_VISIT(traverse_module_state->__pyx_tuple__59); + Py_VISIT(traverse_module_state->__pyx_tuple__61); + Py_VISIT(traverse_module_state->__pyx_tuple__64); + Py_VISIT(traverse_module_state->__pyx_tuple__66); + Py_VISIT(traverse_module_state->__pyx_tuple__68); + Py_VISIT(traverse_module_state->__pyx_tuple__70); + Py_VISIT(traverse_module_state->__pyx_tuple__72); + Py_VISIT(traverse_module_state->__pyx_tuple__74); + Py_VISIT(traverse_module_state->__pyx_tuple__76); + Py_VISIT(traverse_module_state->__pyx_tuple__78); + Py_VISIT(traverse_module_state->__pyx_tuple__83); + Py_VISIT(traverse_module_state->__pyx_tuple__85); + Py_VISIT(traverse_module_state->__pyx_tuple__91); + Py_VISIT(traverse_module_state->__pyx_tuple__97); + Py_VISIT(traverse_module_state->__pyx_tuple__99); + Py_VISIT(traverse_module_state->__pyx_codeobj__5); + Py_VISIT(traverse_module_state->__pyx_codeobj__7); + Py_VISIT(traverse_module_state->__pyx_codeobj__9); + Py_VISIT(traverse_module_state->__pyx_tuple__105); + Py_VISIT(traverse_module_state->__pyx_tuple__113); + Py_VISIT(traverse_module_state->__pyx_tuple__118); + Py_VISIT(traverse_module_state->__pyx_codeobj__11); + Py_VISIT(traverse_module_state->__pyx_codeobj__13); + Py_VISIT(traverse_module_state->__pyx_codeobj__15); + Py_VISIT(traverse_module_state->__pyx_codeobj__17); + Py_VISIT(traverse_module_state->__pyx_codeobj__18); + Py_VISIT(traverse_module_state->__pyx_codeobj__20); + Py_VISIT(traverse_module_state->__pyx_codeobj__22); + Py_VISIT(traverse_module_state->__pyx_codeobj__23); + Py_VISIT(traverse_module_state->__pyx_codeobj__24); + Py_VISIT(traverse_module_state->__pyx_codeobj__26); + Py_VISIT(traverse_module_state->__pyx_codeobj__28); + Py_VISIT(traverse_module_state->__pyx_codeobj__30); + Py_VISIT(traverse_module_state->__pyx_codeobj__32); + Py_VISIT(traverse_module_state->__pyx_codeobj__34); + Py_VISIT(traverse_module_state->__pyx_codeobj__36); + Py_VISIT(traverse_module_state->__pyx_codeobj__37); + Py_VISIT(traverse_module_state->__pyx_codeobj__38); + Py_VISIT(traverse_module_state->__pyx_codeobj__40); + Py_VISIT(traverse_module_state->__pyx_codeobj__42); + Py_VISIT(traverse_module_state->__pyx_codeobj__44); + Py_VISIT(traverse_module_state->__pyx_codeobj__46); + Py_VISIT(traverse_module_state->__pyx_codeobj__48); + Py_VISIT(traverse_module_state->__pyx_codeobj__49); + Py_VISIT(traverse_module_state->__pyx_codeobj__50); + Py_VISIT(traverse_module_state->__pyx_codeobj__52); + Py_VISIT(traverse_module_state->__pyx_codeobj__53); + Py_VISIT(traverse_module_state->__pyx_codeobj__55); + Py_VISIT(traverse_module_state->__pyx_codeobj__57); + Py_VISIT(traverse_module_state->__pyx_codeobj__58); + Py_VISIT(traverse_module_state->__pyx_codeobj__60); + Py_VISIT(traverse_module_state->__pyx_codeobj__62); + Py_VISIT(traverse_module_state->__pyx_codeobj__63); + Py_VISIT(traverse_module_state->__pyx_codeobj__65); + Py_VISIT(traverse_module_state->__pyx_codeobj__67); + Py_VISIT(traverse_module_state->__pyx_codeobj__69); + Py_VISIT(traverse_module_state->__pyx_codeobj__71); + Py_VISIT(traverse_module_state->__pyx_codeobj__73); + Py_VISIT(traverse_module_state->__pyx_codeobj__75); + Py_VISIT(traverse_module_state->__pyx_codeobj__77); + Py_VISIT(traverse_module_state->__pyx_codeobj__79); + Py_VISIT(traverse_module_state->__pyx_codeobj__80); + Py_VISIT(traverse_module_state->__pyx_codeobj__81); + Py_VISIT(traverse_module_state->__pyx_codeobj__82); + Py_VISIT(traverse_module_state->__pyx_codeobj__84); + Py_VISIT(traverse_module_state->__pyx_codeobj__86); + Py_VISIT(traverse_module_state->__pyx_codeobj__87); + Py_VISIT(traverse_module_state->__pyx_codeobj__88); + Py_VISIT(traverse_module_state->__pyx_codeobj__89); + Py_VISIT(traverse_module_state->__pyx_codeobj__90); + Py_VISIT(traverse_module_state->__pyx_codeobj__92); + Py_VISIT(traverse_module_state->__pyx_codeobj__93); + Py_VISIT(traverse_module_state->__pyx_codeobj__94); + Py_VISIT(traverse_module_state->__pyx_codeobj__95); + Py_VISIT(traverse_module_state->__pyx_codeobj__96); + Py_VISIT(traverse_module_state->__pyx_codeobj__98); + Py_VISIT(traverse_module_state->__pyx_codeobj__100); + Py_VISIT(traverse_module_state->__pyx_codeobj__101); + Py_VISIT(traverse_module_state->__pyx_codeobj__102); + Py_VISIT(traverse_module_state->__pyx_codeobj__103); + Py_VISIT(traverse_module_state->__pyx_codeobj__104); + Py_VISIT(traverse_module_state->__pyx_codeobj__106); + Py_VISIT(traverse_module_state->__pyx_codeobj__107); + Py_VISIT(traverse_module_state->__pyx_codeobj__108); + Py_VISIT(traverse_module_state->__pyx_codeobj__109); + Py_VISIT(traverse_module_state->__pyx_codeobj__110); + Py_VISIT(traverse_module_state->__pyx_codeobj__111); + Py_VISIT(traverse_module_state->__pyx_codeobj__112); + Py_VISIT(traverse_module_state->__pyx_codeobj__114); + Py_VISIT(traverse_module_state->__pyx_codeobj__115); + Py_VISIT(traverse_module_state->__pyx_codeobj__116); + Py_VISIT(traverse_module_state->__pyx_codeobj__117); + Py_VISIT(traverse_module_state->__pyx_codeobj__119); + return 0; +} +#endif +/* #### Code section: module_state_defines ### */ +#define __pyx_d __pyx_mstate_global->__pyx_d +#define __pyx_b __pyx_mstate_global->__pyx_b +#define __pyx_cython_runtime __pyx_mstate_global->__pyx_cython_runtime +#define __pyx_empty_tuple __pyx_mstate_global->__pyx_empty_tuple +#define __pyx_empty_bytes __pyx_mstate_global->__pyx_empty_bytes +#define __pyx_empty_unicode __pyx_mstate_global->__pyx_empty_unicode +#ifdef __Pyx_CyFunction_USED +#define __pyx_CyFunctionType __pyx_mstate_global->__pyx_CyFunctionType +#endif +#ifdef __Pyx_FusedFunction_USED +#define __pyx_FusedFunctionType __pyx_mstate_global->__pyx_FusedFunctionType +#endif +#ifdef __Pyx_Generator_USED +#define __pyx_GeneratorType __pyx_mstate_global->__pyx_GeneratorType +#endif +#ifdef __Pyx_IterableCoroutine_USED +#define __pyx_IterableCoroutineType __pyx_mstate_global->__pyx_IterableCoroutineType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineAwaitType __pyx_mstate_global->__pyx_CoroutineAwaitType +#endif +#ifdef __Pyx_Coroutine_USED +#define __pyx_CoroutineType __pyx_mstate_global->__pyx_CoroutineType +#endif +#if CYTHON_USE_MODULE_STATE +#define __pyx_type_4dnet_eth __pyx_mstate_global->__pyx_type_4dnet_eth +#define __pyx_type_4dnet_ip __pyx_mstate_global->__pyx_type_4dnet_ip +#define __pyx_type_4dnet_addr __pyx_mstate_global->__pyx_type_4dnet_addr +#define __pyx_type_4dnet___addr_ip4_iter __pyx_mstate_global->__pyx_type_4dnet___addr_ip4_iter +#define __pyx_type_4dnet_arp __pyx_mstate_global->__pyx_type_4dnet_arp +#define __pyx_type_4dnet_intf __pyx_mstate_global->__pyx_type_4dnet_intf +#define __pyx_type_4dnet_route __pyx_mstate_global->__pyx_type_4dnet_route +#define __pyx_type_4dnet_fw __pyx_mstate_global->__pyx_type_4dnet_fw +#define __pyx_type_4dnet_rand __pyx_mstate_global->__pyx_type_4dnet_rand +#define __pyx_type_4dnet___rand_xrange __pyx_mstate_global->__pyx_type_4dnet___rand_xrange +#define __pyx_type_4dnet_tun __pyx_mstate_global->__pyx_type_4dnet_tun +#endif +#define __pyx_ptype_4dnet_eth __pyx_mstate_global->__pyx_ptype_4dnet_eth +#define __pyx_ptype_4dnet_ip __pyx_mstate_global->__pyx_ptype_4dnet_ip +#define __pyx_ptype_4dnet_addr __pyx_mstate_global->__pyx_ptype_4dnet_addr +#define __pyx_ptype_4dnet___addr_ip4_iter __pyx_mstate_global->__pyx_ptype_4dnet___addr_ip4_iter +#define __pyx_ptype_4dnet_arp __pyx_mstate_global->__pyx_ptype_4dnet_arp +#define __pyx_ptype_4dnet_intf __pyx_mstate_global->__pyx_ptype_4dnet_intf +#define __pyx_ptype_4dnet_route __pyx_mstate_global->__pyx_ptype_4dnet_route +#define __pyx_ptype_4dnet_fw __pyx_mstate_global->__pyx_ptype_4dnet_fw +#define __pyx_ptype_4dnet_rand __pyx_mstate_global->__pyx_ptype_4dnet_rand +#define __pyx_ptype_4dnet___rand_xrange __pyx_mstate_global->__pyx_ptype_4dnet___rand_xrange +#define __pyx_ptype_4dnet_tun __pyx_mstate_global->__pyx_ptype_4dnet_tun +#define __pyx_kp_u_1_18_0 __pyx_mstate_global->__pyx_kp_u_1_18_0 +#define __pyx_n_s_ADDR_TYPE_ETH __pyx_mstate_global->__pyx_n_s_ADDR_TYPE_ETH +#define __pyx_n_s_ADDR_TYPE_IP __pyx_mstate_global->__pyx_n_s_ADDR_TYPE_IP +#define __pyx_n_s_ADDR_TYPE_IP6 __pyx_mstate_global->__pyx_n_s_ADDR_TYPE_IP6 +#define __pyx_n_s_ADDR_TYPE_NONE __pyx_mstate_global->__pyx_n_s_ADDR_TYPE_NONE +#define __pyx_n_s_ARP_ETHIP_LEN __pyx_mstate_global->__pyx_n_s_ARP_ETHIP_LEN +#define __pyx_n_s_ARP_HDR_LEN __pyx_mstate_global->__pyx_n_s_ARP_HDR_LEN +#define __pyx_n_s_ARP_HRD_ETH __pyx_mstate_global->__pyx_n_s_ARP_HRD_ETH +#define __pyx_n_s_ARP_HRD_IEEE802 __pyx_mstate_global->__pyx_n_s_ARP_HRD_IEEE802 +#define __pyx_n_s_ARP_OP_REPLY __pyx_mstate_global->__pyx_n_s_ARP_OP_REPLY +#define __pyx_n_s_ARP_OP_REQUEST __pyx_mstate_global->__pyx_n_s_ARP_OP_REQUEST +#define __pyx_n_s_ARP_OP_REVREPLY __pyx_mstate_global->__pyx_n_s_ARP_OP_REVREPLY +#define __pyx_n_s_ARP_OP_REVREQUEST __pyx_mstate_global->__pyx_n_s_ARP_OP_REVREQUEST +#define __pyx_n_s_ARP_PRO_IP __pyx_mstate_global->__pyx_n_s_ARP_PRO_IP +#define __pyx_n_u_BSD __pyx_mstate_global->__pyx_n_u_BSD +#define __pyx_kp_u_Copyright_c_2023_2024_Oliver_Fal __pyx_mstate_global->__pyx_kp_u_Copyright_c_2023_2024_Oliver_Fal +#define __pyx_n_s_ETH_ADDR_BITS __pyx_mstate_global->__pyx_n_s_ETH_ADDR_BITS +#define __pyx_n_s_ETH_ADDR_BROADCAST __pyx_mstate_global->__pyx_n_s_ETH_ADDR_BROADCAST +#define __pyx_n_s_ETH_ADDR_LEN __pyx_mstate_global->__pyx_n_s_ETH_ADDR_LEN +#define __pyx_n_s_ETH_ADDR_UNSPEC __pyx_mstate_global->__pyx_n_s_ETH_ADDR_UNSPEC +#define __pyx_n_s_ETH_CRC_LEN __pyx_mstate_global->__pyx_n_s_ETH_CRC_LEN +#define __pyx_n_s_ETH_HDR_LEN __pyx_mstate_global->__pyx_n_s_ETH_HDR_LEN +#define __pyx_n_s_ETH_LEN_MAX __pyx_mstate_global->__pyx_n_s_ETH_LEN_MAX +#define __pyx_n_s_ETH_LEN_MIN __pyx_mstate_global->__pyx_n_s_ETH_LEN_MIN +#define __pyx_n_s_ETH_MIN __pyx_mstate_global->__pyx_n_s_ETH_MIN +#define __pyx_n_s_ETH_MTU __pyx_mstate_global->__pyx_n_s_ETH_MTU +#define __pyx_n_s_ETH_TYPE_8021Q __pyx_mstate_global->__pyx_n_s_ETH_TYPE_8021Q +#define __pyx_n_s_ETH_TYPE_ARP __pyx_mstate_global->__pyx_n_s_ETH_TYPE_ARP +#define __pyx_n_s_ETH_TYPE_IP __pyx_mstate_global->__pyx_n_s_ETH_TYPE_IP +#define __pyx_n_s_ETH_TYPE_IPV6 __pyx_mstate_global->__pyx_n_s_ETH_TYPE_IPV6 +#define __pyx_n_s_ETH_TYPE_LEN __pyx_mstate_global->__pyx_n_s_ETH_TYPE_LEN +#define __pyx_n_s_ETH_TYPE_LOOPBACK __pyx_mstate_global->__pyx_n_s_ETH_TYPE_LOOPBACK +#define __pyx_n_s_ETH_TYPE_MPLS __pyx_mstate_global->__pyx_n_s_ETH_TYPE_MPLS +#define __pyx_n_s_ETH_TYPE_MPLS_MCAST __pyx_mstate_global->__pyx_n_s_ETH_TYPE_MPLS_MCAST +#define __pyx_n_s_ETH_TYPE_PPPOE __pyx_mstate_global->__pyx_n_s_ETH_TYPE_PPPOE +#define __pyx_n_s_ETH_TYPE_PPPOEDISC __pyx_mstate_global->__pyx_n_s_ETH_TYPE_PPPOEDISC +#define __pyx_n_s_ETH_TYPE_PUP __pyx_mstate_global->__pyx_n_s_ETH_TYPE_PUP +#define __pyx_n_s_ETH_TYPE_REVARP __pyx_mstate_global->__pyx_n_s_ETH_TYPE_REVARP +#define __pyx_n_s_FW_DIR_IN __pyx_mstate_global->__pyx_n_s_FW_DIR_IN +#define __pyx_n_s_FW_DIR_OUT __pyx_mstate_global->__pyx_n_s_FW_DIR_OUT +#define __pyx_n_s_FW_OP_ALLOW __pyx_mstate_global->__pyx_n_s_FW_OP_ALLOW +#define __pyx_n_s_FW_OP_BLOCK __pyx_mstate_global->__pyx_n_s_FW_OP_BLOCK +#define __pyx_n_s_INTF_FLAG_BROADCAST __pyx_mstate_global->__pyx_n_s_INTF_FLAG_BROADCAST +#define __pyx_n_s_INTF_FLAG_LOOPBACK __pyx_mstate_global->__pyx_n_s_INTF_FLAG_LOOPBACK +#define __pyx_n_s_INTF_FLAG_MULTICAST __pyx_mstate_global->__pyx_n_s_INTF_FLAG_MULTICAST +#define __pyx_n_s_INTF_FLAG_NOARP __pyx_mstate_global->__pyx_n_s_INTF_FLAG_NOARP +#define __pyx_n_s_INTF_FLAG_POINTOPOINT __pyx_mstate_global->__pyx_n_s_INTF_FLAG_POINTOPOINT +#define __pyx_n_s_INTF_FLAG_UP __pyx_mstate_global->__pyx_n_s_INTF_FLAG_UP +#define __pyx_n_s_INTF_TYPE_ETH __pyx_mstate_global->__pyx_n_s_INTF_TYPE_ETH +#define __pyx_n_s_INTF_TYPE_LOOPBACK __pyx_mstate_global->__pyx_n_s_INTF_TYPE_LOOPBACK +#define __pyx_n_s_INTF_TYPE_OTHER __pyx_mstate_global->__pyx_n_s_INTF_TYPE_OTHER +#define __pyx_n_s_INTF_TYPE_TUN __pyx_mstate_global->__pyx_n_s_INTF_TYPE_TUN +#define __pyx_n_s_IP6_ADDR_BITS __pyx_mstate_global->__pyx_n_s_IP6_ADDR_BITS +#define __pyx_n_s_IP6_ADDR_LEN __pyx_mstate_global->__pyx_n_s_IP6_ADDR_LEN +#define __pyx_n_s_IP6_ADDR_LOOPBACK __pyx_mstate_global->__pyx_n_s_IP6_ADDR_LOOPBACK +#define __pyx_n_s_IP6_ADDR_UNSPEC __pyx_mstate_global->__pyx_n_s_IP6_ADDR_UNSPEC +#define __pyx_n_s_IP6_HDR_LEN __pyx_mstate_global->__pyx_n_s_IP6_HDR_LEN +#define __pyx_n_s_IP6_HLIM_DEFAULT __pyx_mstate_global->__pyx_n_s_IP6_HLIM_DEFAULT +#define __pyx_n_s_IP6_HLIM_MAX __pyx_mstate_global->__pyx_n_s_IP6_HLIM_MAX +#define __pyx_n_s_IP6_LEN_MAX __pyx_mstate_global->__pyx_n_s_IP6_LEN_MAX +#define __pyx_n_s_IP6_LEN_MIN __pyx_mstate_global->__pyx_n_s_IP6_LEN_MIN +#define __pyx_n_s_IP6_MTU_MIN __pyx_mstate_global->__pyx_n_s_IP6_MTU_MIN +#define __pyx_n_s_IP_ADDR_ANY __pyx_mstate_global->__pyx_n_s_IP_ADDR_ANY +#define __pyx_n_s_IP_ADDR_BITS __pyx_mstate_global->__pyx_n_s_IP_ADDR_BITS +#define __pyx_n_s_IP_ADDR_BROADCAST __pyx_mstate_global->__pyx_n_s_IP_ADDR_BROADCAST +#define __pyx_n_s_IP_ADDR_LEN __pyx_mstate_global->__pyx_n_s_IP_ADDR_LEN +#define __pyx_n_s_IP_ADDR_LOOPBACK __pyx_mstate_global->__pyx_n_s_IP_ADDR_LOOPBACK +#define __pyx_n_s_IP_ADDR_MCAST_ALL __pyx_mstate_global->__pyx_n_s_IP_ADDR_MCAST_ALL +#define __pyx_n_s_IP_ADDR_MCAST_LOCAL __pyx_mstate_global->__pyx_n_s_IP_ADDR_MCAST_LOCAL +#define __pyx_n_s_IP_DF __pyx_mstate_global->__pyx_n_s_IP_DF +#define __pyx_n_s_IP_HDR_LEN __pyx_mstate_global->__pyx_n_s_IP_HDR_LEN +#define __pyx_n_s_IP_HDR_LEN_MAX __pyx_mstate_global->__pyx_n_s_IP_HDR_LEN_MAX +#define __pyx_n_s_IP_LEN_MAX __pyx_mstate_global->__pyx_n_s_IP_LEN_MAX +#define __pyx_n_s_IP_LEN_MIN __pyx_mstate_global->__pyx_n_s_IP_LEN_MIN +#define __pyx_n_s_IP_MF __pyx_mstate_global->__pyx_n_s_IP_MF +#define __pyx_n_s_IP_OFFMASK __pyx_mstate_global->__pyx_n_s_IP_OFFMASK +#define __pyx_n_s_IP_OPT_LEN __pyx_mstate_global->__pyx_n_s_IP_OPT_LEN +#define __pyx_n_s_IP_OPT_LEN_MAX __pyx_mstate_global->__pyx_n_s_IP_OPT_LEN_MAX +#define __pyx_n_s_IP_PROTO_AH __pyx_mstate_global->__pyx_n_s_IP_PROTO_AH +#define __pyx_n_s_IP_PROTO_ESP __pyx_mstate_global->__pyx_n_s_IP_PROTO_ESP +#define __pyx_n_s_IP_PROTO_GRE __pyx_mstate_global->__pyx_n_s_IP_PROTO_GRE +#define __pyx_n_s_IP_PROTO_ICMP __pyx_mstate_global->__pyx_n_s_IP_PROTO_ICMP +#define __pyx_n_s_IP_PROTO_ICMPV6 __pyx_mstate_global->__pyx_n_s_IP_PROTO_ICMPV6 +#define __pyx_n_s_IP_PROTO_IGMP __pyx_mstate_global->__pyx_n_s_IP_PROTO_IGMP +#define __pyx_n_s_IP_PROTO_IP __pyx_mstate_global->__pyx_n_s_IP_PROTO_IP +#define __pyx_n_s_IP_PROTO_IPV6 __pyx_mstate_global->__pyx_n_s_IP_PROTO_IPV6 +#define __pyx_n_s_IP_PROTO_MAX __pyx_mstate_global->__pyx_n_s_IP_PROTO_MAX +#define __pyx_n_s_IP_PROTO_RAW __pyx_mstate_global->__pyx_n_s_IP_PROTO_RAW +#define __pyx_n_s_IP_PROTO_RESERVED __pyx_mstate_global->__pyx_n_s_IP_PROTO_RESERVED +#define __pyx_n_s_IP_PROTO_TCP __pyx_mstate_global->__pyx_n_s_IP_PROTO_TCP +#define __pyx_n_s_IP_PROTO_UDP __pyx_mstate_global->__pyx_n_s_IP_PROTO_UDP +#define __pyx_n_s_IP_RF __pyx_mstate_global->__pyx_n_s_IP_RF +#define __pyx_n_s_IP_TOS_DEFAULT __pyx_mstate_global->__pyx_n_s_IP_TOS_DEFAULT +#define __pyx_n_s_IP_TTL_DEFAULT __pyx_mstate_global->__pyx_n_s_IP_TTL_DEFAULT +#define __pyx_n_s_IP_TTL_MAX __pyx_mstate_global->__pyx_n_s_IP_TTL_MAX +#define __pyx_kp_s_Incompatible_checksums_0x_x_vs_0 __pyx_mstate_global->__pyx_kp_s_Incompatible_checksums_0x_x_vs_0 +#define __pyx_n_s_NotImplementedError __pyx_mstate_global->__pyx_n_s_NotImplementedError +#define __pyx_n_s_OSError __pyx_mstate_global->__pyx_n_s_OSError +#define __pyx_kp_u_Oliver_Falk_oliver_linux_kernel __pyx_mstate_global->__pyx_kp_u_Oliver_Falk_oliver_linux_kernel +#define __pyx_n_s_OverflowError __pyx_mstate_global->__pyx_n_s_OverflowError +#define __pyx_n_s_PickleError __pyx_mstate_global->__pyx_n_s_PickleError +#define __pyx_kp_s_Pickling_of_struct_members_such __pyx_mstate_global->__pyx_kp_s_Pickling_of_struct_members_such +#define __pyx_n_s_StopIteration __pyx_mstate_global->__pyx_n_s_StopIteration +#define __pyx_n_s_TCP_HDR_LEN __pyx_mstate_global->__pyx_n_s_TCP_HDR_LEN +#define __pyx_n_s_TCP_OPT_ALTSUM __pyx_mstate_global->__pyx_n_s_TCP_OPT_ALTSUM +#define __pyx_n_s_TCP_OPT_ALTSUMDATA __pyx_mstate_global->__pyx_n_s_TCP_OPT_ALTSUMDATA +#define __pyx_n_s_TCP_OPT_BUBBA __pyx_mstate_global->__pyx_n_s_TCP_OPT_BUBBA +#define __pyx_n_s_TCP_OPT_CC __pyx_mstate_global->__pyx_n_s_TCP_OPT_CC +#define __pyx_n_s_TCP_OPT_CCECHO __pyx_mstate_global->__pyx_n_s_TCP_OPT_CCECHO +#define __pyx_n_s_TCP_OPT_CCNEW __pyx_mstate_global->__pyx_n_s_TCP_OPT_CCNEW +#define __pyx_n_s_TCP_OPT_CORRUPT __pyx_mstate_global->__pyx_n_s_TCP_OPT_CORRUPT +#define __pyx_n_s_TCP_OPT_ECHO __pyx_mstate_global->__pyx_n_s_TCP_OPT_ECHO +#define __pyx_n_s_TCP_OPT_ECHOREPLY __pyx_mstate_global->__pyx_n_s_TCP_OPT_ECHOREPLY +#define __pyx_n_s_TCP_OPT_EOL __pyx_mstate_global->__pyx_n_s_TCP_OPT_EOL +#define __pyx_n_s_TCP_OPT_MAX __pyx_mstate_global->__pyx_n_s_TCP_OPT_MAX +#define __pyx_n_s_TCP_OPT_MD5 __pyx_mstate_global->__pyx_n_s_TCP_OPT_MD5 +#define __pyx_n_s_TCP_OPT_MSS __pyx_mstate_global->__pyx_n_s_TCP_OPT_MSS +#define __pyx_n_s_TCP_OPT_NOP __pyx_mstate_global->__pyx_n_s_TCP_OPT_NOP +#define __pyx_n_s_TCP_OPT_POCONN __pyx_mstate_global->__pyx_n_s_TCP_OPT_POCONN +#define __pyx_n_s_TCP_OPT_POSVC __pyx_mstate_global->__pyx_n_s_TCP_OPT_POSVC +#define __pyx_n_s_TCP_OPT_REC __pyx_mstate_global->__pyx_n_s_TCP_OPT_REC +#define __pyx_n_s_TCP_OPT_SACK __pyx_mstate_global->__pyx_n_s_TCP_OPT_SACK +#define __pyx_n_s_TCP_OPT_SACKOK __pyx_mstate_global->__pyx_n_s_TCP_OPT_SACKOK +#define __pyx_n_s_TCP_OPT_SCPS __pyx_mstate_global->__pyx_n_s_TCP_OPT_SCPS +#define __pyx_n_s_TCP_OPT_SKEETER __pyx_mstate_global->__pyx_n_s_TCP_OPT_SKEETER +#define __pyx_n_s_TCP_OPT_SNACK __pyx_mstate_global->__pyx_n_s_TCP_OPT_SNACK +#define __pyx_n_s_TCP_OPT_SNAP __pyx_mstate_global->__pyx_n_s_TCP_OPT_SNAP +#define __pyx_n_s_TCP_OPT_TCPCOMP __pyx_mstate_global->__pyx_n_s_TCP_OPT_TCPCOMP +#define __pyx_n_s_TCP_OPT_TIMESTAMP __pyx_mstate_global->__pyx_n_s_TCP_OPT_TIMESTAMP +#define __pyx_n_s_TCP_OPT_TRAILSUM __pyx_mstate_global->__pyx_n_s_TCP_OPT_TRAILSUM +#define __pyx_n_s_TCP_OPT_WSCALE __pyx_mstate_global->__pyx_n_s_TCP_OPT_WSCALE +#define __pyx_n_s_TCP_PORT_MAX __pyx_mstate_global->__pyx_n_s_TCP_PORT_MAX +#define __pyx_n_s_TCP_WIN_MAX __pyx_mstate_global->__pyx_n_s_TCP_WIN_MAX +#define __pyx_n_s_TH_ACK __pyx_mstate_global->__pyx_n_s_TH_ACK +#define __pyx_n_s_TH_CWR __pyx_mstate_global->__pyx_n_s_TH_CWR +#define __pyx_n_s_TH_ECE __pyx_mstate_global->__pyx_n_s_TH_ECE +#define __pyx_n_s_TH_FIN __pyx_mstate_global->__pyx_n_s_TH_FIN +#define __pyx_n_s_TH_PUSH __pyx_mstate_global->__pyx_n_s_TH_PUSH +#define __pyx_n_s_TH_RST __pyx_mstate_global->__pyx_n_s_TH_RST +#define __pyx_n_s_TH_SYN __pyx_mstate_global->__pyx_n_s_TH_SYN +#define __pyx_n_s_TH_URG __pyx_mstate_global->__pyx_n_s_TH_URG +#define __pyx_n_s_TypeError __pyx_mstate_global->__pyx_n_s_TypeError +#define __pyx_n_s_UDP_HDR_LEN __pyx_mstate_global->__pyx_n_s_UDP_HDR_LEN +#define __pyx_n_s_UDP_PORT_MAX __pyx_mstate_global->__pyx_n_s_UDP_PORT_MAX +#define __pyx_n_s_ValueError __pyx_mstate_global->__pyx_n_s_ValueError +#define __pyx_n_s__120 __pyx_mstate_global->__pyx_n_s__120 +#define __pyx_kp_u__3 __pyx_mstate_global->__pyx_kp_u__3 +#define __pyx_n_s_a __pyx_mstate_global->__pyx_n_s_a +#define __pyx_n_s_ack __pyx_mstate_global->__pyx_n_s_ack +#define __pyx_n_s_add __pyx_mstate_global->__pyx_n_s_add +#define __pyx_n_s_addr __pyx_mstate_global->__pyx_n_s_addr +#define __pyx_n_u_addr __pyx_mstate_global->__pyx_n_u_addr +#define __pyx_n_s_addr___copy __pyx_mstate_global->__pyx_n_s_addr___copy +#define __pyx_n_s_addr___reduce_cython __pyx_mstate_global->__pyx_n_s_addr___reduce_cython +#define __pyx_n_s_addr___setstate_cython __pyx_mstate_global->__pyx_n_s_addr___setstate_cython +#define __pyx_n_s_addr_bcast __pyx_mstate_global->__pyx_n_s_addr_bcast +#define __pyx_n_s_addr_ip4_iter __pyx_mstate_global->__pyx_n_s_addr_ip4_iter +#define __pyx_n_s_addr_ip4_iter___reduce_cython __pyx_mstate_global->__pyx_n_s_addr_ip4_iter___reduce_cython +#define __pyx_n_s_addr_ip4_iter___setstate_cytho __pyx_mstate_global->__pyx_n_s_addr_ip4_iter___setstate_cytho +#define __pyx_n_s_addr_net __pyx_mstate_global->__pyx_n_s_addr_net +#define __pyx_n_s_addrtxt __pyx_mstate_global->__pyx_n_s_addrtxt +#define __pyx_n_s_addrtype __pyx_mstate_global->__pyx_n_s_addrtype +#define __pyx_n_u_alias_addrs __pyx_mstate_global->__pyx_n_u_alias_addrs +#define __pyx_n_s_append __pyx_mstate_global->__pyx_n_s_append +#define __pyx_n_s_arg __pyx_mstate_global->__pyx_n_s_arg +#define __pyx_n_s_arg_2 __pyx_mstate_global->__pyx_n_s_arg_2 +#define __pyx_n_s_arp __pyx_mstate_global->__pyx_n_s_arp +#define __pyx_n_s_arp___reduce_cython __pyx_mstate_global->__pyx_n_s_arp___reduce_cython +#define __pyx_n_s_arp___setstate_cython __pyx_mstate_global->__pyx_n_s_arp___setstate_cython +#define __pyx_n_s_arp_add __pyx_mstate_global->__pyx_n_s_arp_add +#define __pyx_n_s_arp_delete __pyx_mstate_global->__pyx_n_s_arp_delete +#define __pyx_n_s_arp_get __pyx_mstate_global->__pyx_n_s_arp_get +#define __pyx_n_s_arp_loop __pyx_mstate_global->__pyx_n_s_arp_loop +#define __pyx_n_s_arp_pack_hdr_ethip __pyx_mstate_global->__pyx_n_s_arp_pack_hdr_ethip +#define __pyx_n_s_asyncio_coroutines __pyx_mstate_global->__pyx_n_s_asyncio_coroutines +#define __pyx_n_s_author __pyx_mstate_global->__pyx_n_s_author +#define __pyx_n_s_bcast __pyx_mstate_global->__pyx_n_s_bcast +#define __pyx_n_s_buf __pyx_mstate_global->__pyx_n_s_buf +#define __pyx_kp_u_byte_binary_string __pyx_mstate_global->__pyx_kp_u_byte_binary_string +#define __pyx_n_s_callback __pyx_mstate_global->__pyx_n_s_callback +#define __pyx_n_s_cline_in_traceback __pyx_mstate_global->__pyx_n_s_cline_in_traceback +#define __pyx_n_s_close __pyx_mstate_global->__pyx_n_s_close +#define __pyx_n_s_code __pyx_mstate_global->__pyx_n_s_code +#define __pyx_n_s_copy __pyx_mstate_global->__pyx_n_s_copy +#define __pyx_n_s_copyright __pyx_mstate_global->__pyx_n_s_copyright +#define __pyx_n_s_cur __pyx_mstate_global->__pyx_n_s_cur +#define __pyx_n_s_d __pyx_mstate_global->__pyx_n_s_d +#define __pyx_n_u_d __pyx_mstate_global->__pyx_n_u_d +#define __pyx_n_s_delete __pyx_mstate_global->__pyx_n_s_delete +#define __pyx_n_s_device __pyx_mstate_global->__pyx_n_s_device +#define __pyx_n_u_device __pyx_mstate_global->__pyx_n_u_device +#define __pyx_n_s_dh __pyx_mstate_global->__pyx_n_s_dh +#define __pyx_n_s_dha __pyx_mstate_global->__pyx_n_s_dha +#define __pyx_n_s_dict __pyx_mstate_global->__pyx_n_s_dict +#define __pyx_n_s_dict_2 __pyx_mstate_global->__pyx_n_s_dict_2 +#define __pyx_n_u_dir __pyx_mstate_global->__pyx_n_u_dir +#define __pyx_kp_u_disable __pyx_mstate_global->__pyx_kp_u_disable +#define __pyx_n_s_dnet __pyx_mstate_global->__pyx_n_s_dnet +#define __pyx_kp_s_dnet_pyx __pyx_mstate_global->__pyx_kp_s_dnet_pyx +#define __pyx_n_s_dp __pyx_mstate_global->__pyx_n_s_dp +#define __pyx_n_s_dpa __pyx_mstate_global->__pyx_n_s_dpa +#define __pyx_n_s_dport __pyx_mstate_global->__pyx_n_s_dport +#define __pyx_n_u_dport __pyx_mstate_global->__pyx_n_u_dport +#define __pyx_n_s_dst __pyx_mstate_global->__pyx_n_s_dst +#define __pyx_n_u_dst __pyx_mstate_global->__pyx_n_u_dst +#define __pyx_n_u_dst_addr __pyx_mstate_global->__pyx_n_u_dst_addr +#define __pyx_n_s_ea __pyx_mstate_global->__pyx_n_s_ea +#define __pyx_kp_u_enable __pyx_mstate_global->__pyx_kp_u_enable +#define __pyx_n_s_entry __pyx_mstate_global->__pyx_n_s_entry +#define __pyx_n_s_eth __pyx_mstate_global->__pyx_n_s_eth +#define __pyx_n_s_eth___reduce_cython __pyx_mstate_global->__pyx_n_s_eth___reduce_cython +#define __pyx_n_s_eth___setstate_cython __pyx_mstate_global->__pyx_n_s_eth___setstate_cython +#define __pyx_n_s_eth_aton __pyx_mstate_global->__pyx_n_s_eth_aton +#define __pyx_n_s_eth_get __pyx_mstate_global->__pyx_n_s_eth_get +#define __pyx_n_s_eth_ntoa __pyx_mstate_global->__pyx_n_s_eth_ntoa +#define __pyx_n_s_eth_pack_hdr __pyx_mstate_global->__pyx_n_s_eth_pack_hdr +#define __pyx_n_s_eth_send __pyx_mstate_global->__pyx_n_s_eth_send +#define __pyx_n_s_eth_set __pyx_mstate_global->__pyx_n_s_eth_set +#define __pyx_n_s_etype __pyx_mstate_global->__pyx_n_s_etype +#define __pyx_n_s_fc __pyx_mstate_global->__pyx_n_s_fc +#define __pyx_n_s_fileno __pyx_mstate_global->__pyx_n_s_fileno +#define __pyx_n_s_fl __pyx_mstate_global->__pyx_n_s_fl +#define __pyx_n_s_flags __pyx_mstate_global->__pyx_n_s_flags +#define __pyx_n_u_flags __pyx_mstate_global->__pyx_n_u_flags +#define __pyx_n_s_frame __pyx_mstate_global->__pyx_n_s_frame +#define __pyx_n_s_fw __pyx_mstate_global->__pyx_n_s_fw +#define __pyx_n_s_fw___reduce_cython __pyx_mstate_global->__pyx_n_s_fw___reduce_cython +#define __pyx_n_s_fw___setstate_cython __pyx_mstate_global->__pyx_n_s_fw___setstate_cython +#define __pyx_n_s_fw_add __pyx_mstate_global->__pyx_n_s_fw_add +#define __pyx_n_s_fw_delete __pyx_mstate_global->__pyx_n_s_fw_delete +#define __pyx_n_s_fw_loop __pyx_mstate_global->__pyx_n_s_fw_loop +#define __pyx_kp_u_gc __pyx_mstate_global->__pyx_kp_u_gc +#define __pyx_n_s_get __pyx_mstate_global->__pyx_n_s_get +#define __pyx_n_s_get_dst __pyx_mstate_global->__pyx_n_s_get_dst +#define __pyx_n_s_get_src __pyx_mstate_global->__pyx_n_s_get_src +#define __pyx_n_s_getstate __pyx_mstate_global->__pyx_n_s_getstate +#define __pyx_n_s_gw __pyx_mstate_global->__pyx_n_s_gw +#define __pyx_n_s_ha __pyx_mstate_global->__pyx_n_s_ha +#define __pyx_n_s_hdr __pyx_mstate_global->__pyx_n_s_hdr +#define __pyx_n_s_hlim __pyx_mstate_global->__pyx_n_s_hlim +#define __pyx_kp_u_https_github_com_ofalk_libdnet __pyx_mstate_global->__pyx_kp_u_https_github_com_ofalk_libdnet +#define __pyx_n_s_i __pyx_mstate_global->__pyx_n_s_i +#define __pyx_n_s_ia __pyx_mstate_global->__pyx_n_s_ia +#define __pyx_n_s_icmp_pack_hdr __pyx_mstate_global->__pyx_n_s_icmp_pack_hdr +#define __pyx_n_s_id __pyx_mstate_global->__pyx_n_s_id +#define __pyx_n_s_ifent __pyx_mstate_global->__pyx_n_s_ifent +#define __pyx_n_s_import __pyx_mstate_global->__pyx_n_s_import +#define __pyx_n_s_int __pyx_mstate_global->__pyx_n_s_int +#define __pyx_n_s_intf __pyx_mstate_global->__pyx_n_s_intf +#define __pyx_n_s_intf___reduce_cython __pyx_mstate_global->__pyx_n_s_intf___reduce_cython +#define __pyx_n_s_intf___setstate_cython __pyx_mstate_global->__pyx_n_s_intf___setstate_cython +#define __pyx_n_s_intf_get __pyx_mstate_global->__pyx_n_s_intf_get +#define __pyx_n_s_intf_get_dst __pyx_mstate_global->__pyx_n_s_intf_get_dst +#define __pyx_n_s_intf_get_src __pyx_mstate_global->__pyx_n_s_intf_get_src +#define __pyx_n_s_intf_loop __pyx_mstate_global->__pyx_n_s_intf_loop +#define __pyx_n_s_intf_set __pyx_mstate_global->__pyx_n_s_intf_set +#define __pyx_kp_u_invalid_Ethernet_address __pyx_mstate_global->__pyx_kp_u_invalid_Ethernet_address +#define __pyx_kp_u_invalid_IP_address __pyx_mstate_global->__pyx_kp_u_invalid_IP_address +#define __pyx_kp_u_invalid_IPv6_address __pyx_mstate_global->__pyx_kp_u_invalid_IPv6_address +#define __pyx_kp_u_invalid_network_address __pyx_mstate_global->__pyx_kp_u_invalid_network_address +#define __pyx_kp_u_invalid_network_address_2 __pyx_mstate_global->__pyx_kp_u_invalid_network_address_2 +#define __pyx_n_s_ip __pyx_mstate_global->__pyx_n_s_ip +#define __pyx_n_s_ip6 __pyx_mstate_global->__pyx_n_s_ip6 +#define __pyx_n_s_ip6_aton __pyx_mstate_global->__pyx_n_s_ip6_aton +#define __pyx_n_s_ip6_checksum __pyx_mstate_global->__pyx_n_s_ip6_checksum +#define __pyx_n_s_ip6_ntoa __pyx_mstate_global->__pyx_n_s_ip6_ntoa +#define __pyx_n_s_ip6_pack_hdr __pyx_mstate_global->__pyx_n_s_ip6_pack_hdr +#define __pyx_n_s_ip___reduce_cython __pyx_mstate_global->__pyx_n_s_ip___reduce_cython +#define __pyx_n_s_ip___setstate_cython __pyx_mstate_global->__pyx_n_s_ip___setstate_cython +#define __pyx_n_s_ip_aton __pyx_mstate_global->__pyx_n_s_ip_aton +#define __pyx_n_s_ip_checksum __pyx_mstate_global->__pyx_n_s_ip_checksum +#define __pyx_n_s_ip_cksum_add __pyx_mstate_global->__pyx_n_s_ip_cksum_add +#define __pyx_n_s_ip_cksum_carry __pyx_mstate_global->__pyx_n_s_ip_cksum_carry +#define __pyx_n_s_ip_ntoa __pyx_mstate_global->__pyx_n_s_ip_ntoa +#define __pyx_n_s_ip_pack_hdr __pyx_mstate_global->__pyx_n_s_ip_pack_hdr +#define __pyx_n_s_ip_send __pyx_mstate_global->__pyx_n_s_ip_send +#define __pyx_n_s_is_coroutine __pyx_mstate_global->__pyx_n_s_is_coroutine +#define __pyx_kp_u_isenabled __pyx_mstate_global->__pyx_kp_u_isenabled +#define __pyx_n_s_iter_append __pyx_mstate_global->__pyx_n_s_iter_append +#define __pyx_n_s_itype __pyx_mstate_global->__pyx_n_s_itype +#define __pyx_n_s_l __pyx_mstate_global->__pyx_n_s_l +#define __pyx_n_s_len __pyx_mstate_global->__pyx_n_s_len +#define __pyx_n_s_license __pyx_mstate_global->__pyx_n_s_license +#define __pyx_n_u_link_addr __pyx_mstate_global->__pyx_n_u_link_addr +#define __pyx_n_s_loop __pyx_mstate_global->__pyx_n_s_loop +#define __pyx_n_s_main __pyx_mstate_global->__pyx_n_s_main +#define __pyx_n_s_max __pyx_mstate_global->__pyx_n_s_max +#define __pyx_n_s_mtu __pyx_mstate_global->__pyx_n_s_mtu +#define __pyx_n_u_mtu __pyx_mstate_global->__pyx_n_u_mtu +#define __pyx_n_s_n __pyx_mstate_global->__pyx_n_s_n +#define __pyx_n_s_name __pyx_mstate_global->__pyx_n_s_name +#define __pyx_n_u_name __pyx_mstate_global->__pyx_n_u_name +#define __pyx_n_s_name_2 __pyx_mstate_global->__pyx_n_s_name_2 +#define __pyx_n_s_net __pyx_mstate_global->__pyx_n_s_net +#define __pyx_n_s_new __pyx_mstate_global->__pyx_n_s_new +#define __pyx_kp_u_non_Ethernet_address __pyx_mstate_global->__pyx_kp_u_non_Ethernet_address +#define __pyx_kp_u_non_IP_address __pyx_mstate_global->__pyx_kp_u_non_IP_address +#define __pyx_kp_u_non_IPv6_address __pyx_mstate_global->__pyx_kp_u_non_IPv6_address +#define __pyx_kp_u_not_a __pyx_mstate_global->__pyx_kp_u_not_a +#define __pyx_kp_u_not_a_16_byte_string __pyx_mstate_global->__pyx_kp_u_not_a_16_byte_string +#define __pyx_kp_u_not_a_4_byte_string __pyx_mstate_global->__pyx_kp_u_not_a_4_byte_string +#define __pyx_kp_u_not_a_6_byte_string __pyx_mstate_global->__pyx_kp_u_not_a_6_byte_string +#define __pyx_n_s_nxt __pyx_mstate_global->__pyx_n_s_nxt +#define __pyx_n_s_off __pyx_mstate_global->__pyx_n_s_off +#define __pyx_n_s_op __pyx_mstate_global->__pyx_n_s_op +#define __pyx_n_u_op __pyx_mstate_global->__pyx_n_u_op +#define __pyx_n_s_p __pyx_mstate_global->__pyx_n_s_p +#define __pyx_n_s_pa __pyx_mstate_global->__pyx_n_s_pa +#define __pyx_n_s_pickle __pyx_mstate_global->__pyx_n_s_pickle +#define __pyx_n_s_pkt __pyx_mstate_global->__pyx_n_s_pkt +#define __pyx_n_s_plen __pyx_mstate_global->__pyx_n_s_plen +#define __pyx_n_u_proto __pyx_mstate_global->__pyx_n_u_proto +#define __pyx_n_s_pyx_PickleError __pyx_mstate_global->__pyx_n_s_pyx_PickleError +#define __pyx_n_s_pyx_checksum __pyx_mstate_global->__pyx_n_s_pyx_checksum +#define __pyx_n_s_pyx_result __pyx_mstate_global->__pyx_n_s_pyx_result +#define __pyx_n_s_pyx_state __pyx_mstate_global->__pyx_n_s_pyx_state +#define __pyx_n_s_pyx_type __pyx_mstate_global->__pyx_n_s_pyx_type +#define __pyx_n_s_pyx_unpickle___addr_ip4_iter __pyx_mstate_global->__pyx_n_s_pyx_unpickle___addr_ip4_iter +#define __pyx_n_s_r __pyx_mstate_global->__pyx_n_s_r +#define __pyx_n_s_rand __pyx_mstate_global->__pyx_n_s_rand +#define __pyx_n_s_rand___reduce_cython __pyx_mstate_global->__pyx_n_s_rand___reduce_cython +#define __pyx_n_s_rand___setstate_cython __pyx_mstate_global->__pyx_n_s_rand___setstate_cython +#define __pyx_n_s_rand_add __pyx_mstate_global->__pyx_n_s_rand_add +#define __pyx_n_s_rand_get __pyx_mstate_global->__pyx_n_s_rand_get +#define __pyx_n_s_rand_set __pyx_mstate_global->__pyx_n_s_rand_set +#define __pyx_n_s_rand_uint16 __pyx_mstate_global->__pyx_n_s_rand_uint16 +#define __pyx_n_s_rand_uint32 __pyx_mstate_global->__pyx_n_s_rand_uint32 +#define __pyx_n_s_rand_uint8 __pyx_mstate_global->__pyx_n_s_rand_uint8 +#define __pyx_n_s_rand_xrange __pyx_mstate_global->__pyx_n_s_rand_xrange +#define __pyx_n_s_rand_xrange_2 __pyx_mstate_global->__pyx_n_s_rand_xrange_2 +#define __pyx_n_s_rand_xrange___reduce_cython __pyx_mstate_global->__pyx_n_s_rand_xrange___reduce_cython +#define __pyx_n_s_rand_xrange___setstate_cython __pyx_mstate_global->__pyx_n_s_rand_xrange___setstate_cython +#define __pyx_n_s_recv __pyx_mstate_global->__pyx_n_s_recv +#define __pyx_n_s_reduce __pyx_mstate_global->__pyx_n_s_reduce +#define __pyx_n_s_reduce_cython __pyx_mstate_global->__pyx_n_s_reduce_cython +#define __pyx_n_s_reduce_ex __pyx_mstate_global->__pyx_n_s_reduce_ex +#define __pyx_n_s_route __pyx_mstate_global->__pyx_n_s_route +#define __pyx_n_s_route___reduce_cython __pyx_mstate_global->__pyx_n_s_route___reduce_cython +#define __pyx_n_s_route___setstate_cython __pyx_mstate_global->__pyx_n_s_route___setstate_cython +#define __pyx_n_s_route_add __pyx_mstate_global->__pyx_n_s_route_add +#define __pyx_n_s_route_delete __pyx_mstate_global->__pyx_n_s_route_delete +#define __pyx_n_s_route_get __pyx_mstate_global->__pyx_n_s_route_get +#define __pyx_n_s_route_loop __pyx_mstate_global->__pyx_n_s_route_loop +#define __pyx_n_s_rule __pyx_mstate_global->__pyx_n_s_rule +#define __pyx_n_s_s __pyx_mstate_global->__pyx_n_s_s +#define __pyx_n_s_self __pyx_mstate_global->__pyx_n_s_self +#define __pyx_kp_s_self_arp_cannot_be_converted_to __pyx_mstate_global->__pyx_kp_s_self_arp_cannot_be_converted_to +#define __pyx_kp_s_self_eth_cannot_be_converted_to __pyx_mstate_global->__pyx_kp_s_self_eth_cannot_be_converted_to +#define __pyx_kp_s_self_fw_cannot_be_converted_to_a __pyx_mstate_global->__pyx_kp_s_self_fw_cannot_be_converted_to_a +#define __pyx_kp_s_self_intf_cannot_be_converted_to __pyx_mstate_global->__pyx_kp_s_self_intf_cannot_be_converted_to +#define __pyx_kp_s_self_ip_cannot_be_converted_to_a __pyx_mstate_global->__pyx_kp_s_self_ip_cannot_be_converted_to_a +#define __pyx_kp_s_self_rand_cannot_be_converted_to __pyx_mstate_global->__pyx_kp_s_self_rand_cannot_be_converted_to +#define __pyx_kp_s_self_route_cannot_be_converted_t __pyx_mstate_global->__pyx_kp_s_self_route_cannot_be_converted_t +#define __pyx_kp_s_self_tun_cannot_be_converted_to __pyx_mstate_global->__pyx_kp_s_self_tun_cannot_be_converted_to +#define __pyx_n_s_send __pyx_mstate_global->__pyx_n_s_send +#define __pyx_n_s_seq __pyx_mstate_global->__pyx_n_s_seq +#define __pyx_n_s_set __pyx_mstate_global->__pyx_n_s_set +#define __pyx_n_s_setstate __pyx_mstate_global->__pyx_n_s_setstate +#define __pyx_n_s_setstate_cython __pyx_mstate_global->__pyx_n_s_setstate_cython +#define __pyx_n_s_sh __pyx_mstate_global->__pyx_n_s_sh +#define __pyx_n_s_sha __pyx_mstate_global->__pyx_n_s_sha +#define __pyx_n_s_sp __pyx_mstate_global->__pyx_n_s_sp +#define __pyx_n_s_spa __pyx_mstate_global->__pyx_n_s_spa +#define __pyx_n_s_sport __pyx_mstate_global->__pyx_n_s_sport +#define __pyx_n_u_sport __pyx_mstate_global->__pyx_n_u_sport +#define __pyx_n_s_src __pyx_mstate_global->__pyx_n_s_src +#define __pyx_n_u_src __pyx_mstate_global->__pyx_n_u_src +#define __pyx_n_s_start __pyx_mstate_global->__pyx_n_s_start +#define __pyx_kp_u_start_must_be_an_integer __pyx_mstate_global->__pyx_kp_u_start_must_be_an_integer +#define __pyx_n_s_state __pyx_mstate_global->__pyx_n_s_state +#define __pyx_n_s_stop __pyx_mstate_global->__pyx_n_s_stop +#define __pyx_kp_u_stop_must_be_an_integer __pyx_mstate_global->__pyx_kp_u_stop_must_be_an_integer +#define __pyx_kp_s_stringsource __pyx_mstate_global->__pyx_kp_s_stringsource +#define __pyx_n_s_sum __pyx_mstate_global->__pyx_n_s_sum +#define __pyx_n_s_tcp_pack_hdr __pyx_mstate_global->__pyx_n_s_tcp_pack_hdr +#define __pyx_n_s_test __pyx_mstate_global->__pyx_n_s_test +#define __pyx_n_s_tos __pyx_mstate_global->__pyx_n_s_tos +#define __pyx_n_s_ttl __pyx_mstate_global->__pyx_n_s_ttl +#define __pyx_n_s_tun __pyx_mstate_global->__pyx_n_s_tun +#define __pyx_n_s_tun___reduce_cython __pyx_mstate_global->__pyx_n_s_tun___reduce_cython +#define __pyx_n_s_tun___setstate_cython __pyx_mstate_global->__pyx_n_s_tun___setstate_cython +#define __pyx_n_s_tun_close __pyx_mstate_global->__pyx_n_s_tun_close +#define __pyx_n_s_tun_fileno __pyx_mstate_global->__pyx_n_s_tun_fileno +#define __pyx_n_s_tun_recv __pyx_mstate_global->__pyx_n_s_tun_recv +#define __pyx_n_s_tun_send __pyx_mstate_global->__pyx_n_s_tun_send +#define __pyx_n_u_type __pyx_mstate_global->__pyx_n_u_type +#define __pyx_n_s_udp_pack_hdr __pyx_mstate_global->__pyx_n_s_udp_pack_hdr +#define __pyx_n_s_uint16 __pyx_mstate_global->__pyx_n_s_uint16 +#define __pyx_n_s_uint32 __pyx_mstate_global->__pyx_n_s_uint32 +#define __pyx_n_s_uint8 __pyx_mstate_global->__pyx_n_s_uint8 +#define __pyx_n_s_ulen __pyx_mstate_global->__pyx_n_s_ulen +#define __pyx_n_s_update __pyx_mstate_global->__pyx_n_s_update +#define __pyx_n_s_url __pyx_mstate_global->__pyx_n_s_url +#define __pyx_n_s_urp __pyx_mstate_global->__pyx_n_s_urp +#define __pyx_n_s_use_setstate __pyx_mstate_global->__pyx_n_s_use_setstate +#define __pyx_n_s_value __pyx_mstate_global->__pyx_n_s_value +#define __pyx_n_s_version __pyx_mstate_global->__pyx_n_s_version +#define __pyx_n_s_win __pyx_mstate_global->__pyx_n_s_win +#define __pyx_n_s_xrange __pyx_mstate_global->__pyx_n_s_xrange +#define __pyx_int_0 __pyx_mstate_global->__pyx_int_0 +#define __pyx_int_1 __pyx_mstate_global->__pyx_int_1 +#define __pyx_int_2 __pyx_mstate_global->__pyx_int_2 +#define __pyx_int_3 __pyx_mstate_global->__pyx_int_3 +#define __pyx_int_4 __pyx_mstate_global->__pyx_int_4 +#define __pyx_int_5 __pyx_mstate_global->__pyx_int_5 +#define __pyx_int_6 __pyx_mstate_global->__pyx_int_6 +#define __pyx_int_7 __pyx_mstate_global->__pyx_int_7 +#define __pyx_int_8 __pyx_mstate_global->__pyx_int_8 +#define __pyx_int_9 __pyx_mstate_global->__pyx_int_9 +#define __pyx_int_10 __pyx_mstate_global->__pyx_int_10 +#define __pyx_int_11 __pyx_mstate_global->__pyx_int_11 +#define __pyx_int_12 __pyx_mstate_global->__pyx_int_12 +#define __pyx_int_13 __pyx_mstate_global->__pyx_int_13 +#define __pyx_int_14 __pyx_mstate_global->__pyx_int_14 +#define __pyx_int_15 __pyx_mstate_global->__pyx_int_15 +#define __pyx_int_16 __pyx_mstate_global->__pyx_int_16 +#define __pyx_int_17 __pyx_mstate_global->__pyx_int_17 +#define __pyx_int_18 __pyx_mstate_global->__pyx_int_18 +#define __pyx_int_19 __pyx_mstate_global->__pyx_int_19 +#define __pyx_int_20 __pyx_mstate_global->__pyx_int_20 +#define __pyx_int_21 __pyx_mstate_global->__pyx_int_21 +#define __pyx_int_22 __pyx_mstate_global->__pyx_int_22 +#define __pyx_int_23 __pyx_mstate_global->__pyx_int_23 +#define __pyx_int_24 __pyx_mstate_global->__pyx_int_24 +#define __pyx_int_26 __pyx_mstate_global->__pyx_int_26 +#define __pyx_int_27 __pyx_mstate_global->__pyx_int_27 +#define __pyx_int_32 __pyx_mstate_global->__pyx_int_32 +#define __pyx_int_40 __pyx_mstate_global->__pyx_int_40 +#define __pyx_int_41 __pyx_mstate_global->__pyx_int_41 +#define __pyx_int_47 __pyx_mstate_global->__pyx_int_47 +#define __pyx_int_48 __pyx_mstate_global->__pyx_int_48 +#define __pyx_int_50 __pyx_mstate_global->__pyx_int_50 +#define __pyx_int_51 __pyx_mstate_global->__pyx_int_51 +#define __pyx_int_53 __pyx_mstate_global->__pyx_int_53 +#define __pyx_int_58 __pyx_mstate_global->__pyx_int_58 +#define __pyx_int_64 __pyx_mstate_global->__pyx_int_64 +#define __pyx_int_128 __pyx_mstate_global->__pyx_int_128 +#define __pyx_int_255 __pyx_mstate_global->__pyx_int_255 +#define __pyx_int_512 __pyx_mstate_global->__pyx_int_512 +#define __pyx_int_1024 __pyx_mstate_global->__pyx_int_1024 +#define __pyx_int_1280 __pyx_mstate_global->__pyx_int_1280 +#define __pyx_int_1500 __pyx_mstate_global->__pyx_int_1500 +#define __pyx_int_1518 __pyx_mstate_global->__pyx_int_1518 +#define __pyx_int_2048 __pyx_mstate_global->__pyx_int_2048 +#define __pyx_int_2054 __pyx_mstate_global->__pyx_int_2054 +#define __pyx_int_8191 __pyx_mstate_global->__pyx_int_8191 +#define __pyx_int_8192 __pyx_mstate_global->__pyx_int_8192 +#define __pyx_int_16384 __pyx_mstate_global->__pyx_int_16384 +#define __pyx_int_32768 __pyx_mstate_global->__pyx_int_32768 +#define __pyx_int_32821 __pyx_mstate_global->__pyx_int_32821 +#define __pyx_int_33024 __pyx_mstate_global->__pyx_int_33024 +#define __pyx_int_34525 __pyx_mstate_global->__pyx_int_34525 +#define __pyx_int_34887 __pyx_mstate_global->__pyx_int_34887 +#define __pyx_int_34888 __pyx_mstate_global->__pyx_int_34888 +#define __pyx_int_34915 __pyx_mstate_global->__pyx_int_34915 +#define __pyx_int_34916 __pyx_mstate_global->__pyx_int_34916 +#define __pyx_int_36864 __pyx_mstate_global->__pyx_int_36864 +#define __pyx_int_65535 __pyx_mstate_global->__pyx_int_65535 +#define __pyx_int_112194662 __pyx_mstate_global->__pyx_int_112194662 +#define __pyx_int_113314003 __pyx_mstate_global->__pyx_int_113314003 +#define __pyx_int_218787872 __pyx_mstate_global->__pyx_int_218787872 +#define __pyx_k_ __pyx_mstate_global->__pyx_k_ +#define __pyx_tuple__2 __pyx_mstate_global->__pyx_tuple__2 +#define __pyx_tuple__4 __pyx_mstate_global->__pyx_tuple__4 +#define __pyx_tuple__6 __pyx_mstate_global->__pyx_tuple__6 +#define __pyx_tuple__8 __pyx_mstate_global->__pyx_tuple__8 +#define __pyx_tuple__10 __pyx_mstate_global->__pyx_tuple__10 +#define __pyx_tuple__12 __pyx_mstate_global->__pyx_tuple__12 +#define __pyx_tuple__14 __pyx_mstate_global->__pyx_tuple__14 +#define __pyx_tuple__16 __pyx_mstate_global->__pyx_tuple__16 +#define __pyx_tuple__19 __pyx_mstate_global->__pyx_tuple__19 +#define __pyx_tuple__21 __pyx_mstate_global->__pyx_tuple__21 +#define __pyx_tuple__25 __pyx_mstate_global->__pyx_tuple__25 +#define __pyx_tuple__27 __pyx_mstate_global->__pyx_tuple__27 +#define __pyx_tuple__29 __pyx_mstate_global->__pyx_tuple__29 +#define __pyx_tuple__31 __pyx_mstate_global->__pyx_tuple__31 +#define __pyx_tuple__33 __pyx_mstate_global->__pyx_tuple__33 +#define __pyx_tuple__35 __pyx_mstate_global->__pyx_tuple__35 +#define __pyx_tuple__39 __pyx_mstate_global->__pyx_tuple__39 +#define __pyx_tuple__41 __pyx_mstate_global->__pyx_tuple__41 +#define __pyx_tuple__43 __pyx_mstate_global->__pyx_tuple__43 +#define __pyx_tuple__45 __pyx_mstate_global->__pyx_tuple__45 +#define __pyx_tuple__47 __pyx_mstate_global->__pyx_tuple__47 +#define __pyx_tuple__51 __pyx_mstate_global->__pyx_tuple__51 +#define __pyx_tuple__54 __pyx_mstate_global->__pyx_tuple__54 +#define __pyx_tuple__56 __pyx_mstate_global->__pyx_tuple__56 +#define __pyx_tuple__59 __pyx_mstate_global->__pyx_tuple__59 +#define __pyx_tuple__61 __pyx_mstate_global->__pyx_tuple__61 +#define __pyx_tuple__64 __pyx_mstate_global->__pyx_tuple__64 +#define __pyx_tuple__66 __pyx_mstate_global->__pyx_tuple__66 +#define __pyx_tuple__68 __pyx_mstate_global->__pyx_tuple__68 +#define __pyx_tuple__70 __pyx_mstate_global->__pyx_tuple__70 +#define __pyx_tuple__72 __pyx_mstate_global->__pyx_tuple__72 +#define __pyx_tuple__74 __pyx_mstate_global->__pyx_tuple__74 +#define __pyx_tuple__76 __pyx_mstate_global->__pyx_tuple__76 +#define __pyx_tuple__78 __pyx_mstate_global->__pyx_tuple__78 +#define __pyx_tuple__83 __pyx_mstate_global->__pyx_tuple__83 +#define __pyx_tuple__85 __pyx_mstate_global->__pyx_tuple__85 +#define __pyx_tuple__91 __pyx_mstate_global->__pyx_tuple__91 +#define __pyx_tuple__97 __pyx_mstate_global->__pyx_tuple__97 +#define __pyx_tuple__99 __pyx_mstate_global->__pyx_tuple__99 +#define __pyx_codeobj__5 __pyx_mstate_global->__pyx_codeobj__5 +#define __pyx_codeobj__7 __pyx_mstate_global->__pyx_codeobj__7 +#define __pyx_codeobj__9 __pyx_mstate_global->__pyx_codeobj__9 +#define __pyx_tuple__105 __pyx_mstate_global->__pyx_tuple__105 +#define __pyx_tuple__113 __pyx_mstate_global->__pyx_tuple__113 +#define __pyx_tuple__118 __pyx_mstate_global->__pyx_tuple__118 +#define __pyx_codeobj__11 __pyx_mstate_global->__pyx_codeobj__11 +#define __pyx_codeobj__13 __pyx_mstate_global->__pyx_codeobj__13 +#define __pyx_codeobj__15 __pyx_mstate_global->__pyx_codeobj__15 +#define __pyx_codeobj__17 __pyx_mstate_global->__pyx_codeobj__17 +#define __pyx_codeobj__18 __pyx_mstate_global->__pyx_codeobj__18 +#define __pyx_codeobj__20 __pyx_mstate_global->__pyx_codeobj__20 +#define __pyx_codeobj__22 __pyx_mstate_global->__pyx_codeobj__22 +#define __pyx_codeobj__23 __pyx_mstate_global->__pyx_codeobj__23 +#define __pyx_codeobj__24 __pyx_mstate_global->__pyx_codeobj__24 +#define __pyx_codeobj__26 __pyx_mstate_global->__pyx_codeobj__26 +#define __pyx_codeobj__28 __pyx_mstate_global->__pyx_codeobj__28 +#define __pyx_codeobj__30 __pyx_mstate_global->__pyx_codeobj__30 +#define __pyx_codeobj__32 __pyx_mstate_global->__pyx_codeobj__32 +#define __pyx_codeobj__34 __pyx_mstate_global->__pyx_codeobj__34 +#define __pyx_codeobj__36 __pyx_mstate_global->__pyx_codeobj__36 +#define __pyx_codeobj__37 __pyx_mstate_global->__pyx_codeobj__37 +#define __pyx_codeobj__38 __pyx_mstate_global->__pyx_codeobj__38 +#define __pyx_codeobj__40 __pyx_mstate_global->__pyx_codeobj__40 +#define __pyx_codeobj__42 __pyx_mstate_global->__pyx_codeobj__42 +#define __pyx_codeobj__44 __pyx_mstate_global->__pyx_codeobj__44 +#define __pyx_codeobj__46 __pyx_mstate_global->__pyx_codeobj__46 +#define __pyx_codeobj__48 __pyx_mstate_global->__pyx_codeobj__48 +#define __pyx_codeobj__49 __pyx_mstate_global->__pyx_codeobj__49 +#define __pyx_codeobj__50 __pyx_mstate_global->__pyx_codeobj__50 +#define __pyx_codeobj__52 __pyx_mstate_global->__pyx_codeobj__52 +#define __pyx_codeobj__53 __pyx_mstate_global->__pyx_codeobj__53 +#define __pyx_codeobj__55 __pyx_mstate_global->__pyx_codeobj__55 +#define __pyx_codeobj__57 __pyx_mstate_global->__pyx_codeobj__57 +#define __pyx_codeobj__58 __pyx_mstate_global->__pyx_codeobj__58 +#define __pyx_codeobj__60 __pyx_mstate_global->__pyx_codeobj__60 +#define __pyx_codeobj__62 __pyx_mstate_global->__pyx_codeobj__62 +#define __pyx_codeobj__63 __pyx_mstate_global->__pyx_codeobj__63 +#define __pyx_codeobj__65 __pyx_mstate_global->__pyx_codeobj__65 +#define __pyx_codeobj__67 __pyx_mstate_global->__pyx_codeobj__67 +#define __pyx_codeobj__69 __pyx_mstate_global->__pyx_codeobj__69 +#define __pyx_codeobj__71 __pyx_mstate_global->__pyx_codeobj__71 +#define __pyx_codeobj__73 __pyx_mstate_global->__pyx_codeobj__73 +#define __pyx_codeobj__75 __pyx_mstate_global->__pyx_codeobj__75 +#define __pyx_codeobj__77 __pyx_mstate_global->__pyx_codeobj__77 +#define __pyx_codeobj__79 __pyx_mstate_global->__pyx_codeobj__79 +#define __pyx_codeobj__80 __pyx_mstate_global->__pyx_codeobj__80 +#define __pyx_codeobj__81 __pyx_mstate_global->__pyx_codeobj__81 +#define __pyx_codeobj__82 __pyx_mstate_global->__pyx_codeobj__82 +#define __pyx_codeobj__84 __pyx_mstate_global->__pyx_codeobj__84 +#define __pyx_codeobj__86 __pyx_mstate_global->__pyx_codeobj__86 +#define __pyx_codeobj__87 __pyx_mstate_global->__pyx_codeobj__87 +#define __pyx_codeobj__88 __pyx_mstate_global->__pyx_codeobj__88 +#define __pyx_codeobj__89 __pyx_mstate_global->__pyx_codeobj__89 +#define __pyx_codeobj__90 __pyx_mstate_global->__pyx_codeobj__90 +#define __pyx_codeobj__92 __pyx_mstate_global->__pyx_codeobj__92 +#define __pyx_codeobj__93 __pyx_mstate_global->__pyx_codeobj__93 +#define __pyx_codeobj__94 __pyx_mstate_global->__pyx_codeobj__94 +#define __pyx_codeobj__95 __pyx_mstate_global->__pyx_codeobj__95 +#define __pyx_codeobj__96 __pyx_mstate_global->__pyx_codeobj__96 +#define __pyx_codeobj__98 __pyx_mstate_global->__pyx_codeobj__98 +#define __pyx_codeobj__100 __pyx_mstate_global->__pyx_codeobj__100 +#define __pyx_codeobj__101 __pyx_mstate_global->__pyx_codeobj__101 +#define __pyx_codeobj__102 __pyx_mstate_global->__pyx_codeobj__102 +#define __pyx_codeobj__103 __pyx_mstate_global->__pyx_codeobj__103 +#define __pyx_codeobj__104 __pyx_mstate_global->__pyx_codeobj__104 +#define __pyx_codeobj__106 __pyx_mstate_global->__pyx_codeobj__106 +#define __pyx_codeobj__107 __pyx_mstate_global->__pyx_codeobj__107 +#define __pyx_codeobj__108 __pyx_mstate_global->__pyx_codeobj__108 +#define __pyx_codeobj__109 __pyx_mstate_global->__pyx_codeobj__109 +#define __pyx_codeobj__110 __pyx_mstate_global->__pyx_codeobj__110 +#define __pyx_codeobj__111 __pyx_mstate_global->__pyx_codeobj__111 +#define __pyx_codeobj__112 __pyx_mstate_global->__pyx_codeobj__112 +#define __pyx_codeobj__114 __pyx_mstate_global->__pyx_codeobj__114 +#define __pyx_codeobj__115 __pyx_mstate_global->__pyx_codeobj__115 +#define __pyx_codeobj__116 __pyx_mstate_global->__pyx_codeobj__116 +#define __pyx_codeobj__117 __pyx_mstate_global->__pyx_codeobj__117 +#define __pyx_codeobj__119 __pyx_mstate_global->__pyx_codeobj__119 +/* #### Code section: module_code ### */ /* "dnet.pyx":45 * from dnet cimport * @@ -2594,7 +5585,7 @@ static PyObject *__pyx_f_4dnet___memcpy(char *__pyx_v_dst, PyObject *__pyx_v_src int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__memcpy", 0); + __Pyx_RefNannySetupContext("__memcpy", 1); /* "dnet.pyx":46 * @@ -2603,7 +5594,7 @@ static PyObject *__pyx_f_4dnet___memcpy(char *__pyx_v_dst, PyObject *__pyx_v_src * raise ValueError, "not a %d-byte binary string: %r" % (n, src) * memcpy(dst, src, n) */ - __pyx_t_1 = ((PyBytes_Size(__pyx_v_src) != __pyx_v_n) != 0); + __pyx_t_1 = (PyBytes_Size(__pyx_v_src) != __pyx_v_n); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":47 @@ -2702,7 +5693,7 @@ static PyObject *__pyx_f_4dnet___oserror(void) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__oserror", 0); + __Pyx_RefNannySetupContext("__oserror", 1); /* "dnet.pyx":51 * @@ -2755,59 +5746,99 @@ static PyObject *__pyx_f_4dnet___oserror(void) { */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_1__iter_append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_4dnet_1__iter_append = {"__iter_append", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_1__iter_append, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_4dnet_1__iter_append(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_1__iter_append(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_1__iter_append = {"__iter_append", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_1__iter_append, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_1__iter_append(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_entry = 0; PyObject *__pyx_v_l = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter_append (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entry,&__pyx_n_s_l,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_entry,&__pyx_n_s_l,0}; + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_entry)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_entry)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_l)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_l)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 54, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__iter_append", 1, 2, 2, 1); __PYX_ERR(0, 54, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__iter_append") < 0)) __PYX_ERR(0, 54, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__iter_append") < 0)) __PYX_ERR(0, 54, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_entry = values[0]; __pyx_v_l = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__iter_append", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 54, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__iter_append", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 54, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.__iter_append", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -2815,6 +5846,12 @@ static PyObject *__pyx_pw_4dnet_1__iter_append(PyObject *__pyx_self, PyObject *_ __pyx_r = __pyx_pf_4dnet___iter_append(__pyx_self, __pyx_v_entry, __pyx_v_l); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2826,7 +5863,7 @@ static PyObject *__pyx_pf_4dnet___iter_append(CYTHON_UNUSED PyObject *__pyx_self int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__iter_append", 0); + __Pyx_RefNannySetupContext("__iter_append", 1); /* "dnet.pyx":55 * @@ -2869,44 +5906,64 @@ static PyObject *__pyx_pf_4dnet___iter_append(CYTHON_UNUSED PyObject *__pyx_self static int __pyx_pw_4dnet_3eth_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_4dnet_3eth_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_device = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_device,0}; - PyObject* values[1] = {0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_device,0}; + if (__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); + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_device)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_device)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 111, __pyx_L3_error) else goto __pyx_L5_argtuple_error; } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 111, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 111, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + } else if (unlikely(__pyx_nargs != 1)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); } __pyx_v_device = values[0]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 111, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 111, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.eth.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; @@ -2914,6 +5971,12 @@ static int __pyx_pw_4dnet_3eth_1__init__(PyObject *__pyx_v_self, PyObject *__pyx __pyx_r = __pyx_pf_4dnet_3eth___init__(((struct __pyx_obj_4dnet_eth *)__pyx_v_self), __pyx_v_device); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -2927,7 +5990,7 @@ static int __pyx_pf_4dnet_3eth___init__(struct __pyx_obj_4dnet_eth *__pyx_v_self int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":112 * @@ -2946,7 +6009,7 @@ static int __pyx_pf_4dnet_3eth___init__(struct __pyx_obj_4dnet_eth *__pyx_v_self * raise OSError, __oserror() * */ - __pyx_t_2 = ((!(__pyx_v_self->eth != 0)) != 0); + __pyx_t_2 = (!(__pyx_v_self->eth != 0)); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":114 @@ -3000,13 +6063,41 @@ static int __pyx_pf_4dnet_3eth___init__(struct __pyx_obj_4dnet_eth *__pyx_v_self */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3eth_3get(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_4dnet_3eth_2get[] = "Return the MAC address associated with the device as a\n binary string."; -static PyObject *__pyx_pw_4dnet_3eth_3get(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("get (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_3eth_2get(((struct __pyx_obj_4dnet_eth *)__pyx_v_self)); +static PyObject *__pyx_pw_4dnet_3eth_3get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3eth_2get, "Return the MAC address associated with the device as a\n binary string."); +static PyMethodDef __pyx_mdef_4dnet_3eth_3get = {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_3get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3eth_2get}; +static PyObject *__pyx_pw_4dnet_3eth_3get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("get", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "get", 0))) return NULL; + __pyx_r = __pyx_pf_4dnet_3eth_2get(((struct __pyx_obj_4dnet_eth *)__pyx_v_self)); /* function exit code */ __Pyx_RefNannyFinishContext(); @@ -3022,7 +6113,7 @@ static PyObject *__pyx_pf_4dnet_3eth_2get(struct __pyx_obj_4dnet_eth *__pyx_v_se int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get", 0); + __Pyx_RefNannySetupContext("get", 1); /* "dnet.pyx":120 * binary string.""" @@ -3031,7 +6122,7 @@ static PyObject *__pyx_pf_4dnet_3eth_2get(struct __pyx_obj_4dnet_eth *__pyx_v_se * raise OSError, __oserror() * return PyBytes_FromStringAndSize(ea.data, 6) */ - __pyx_t_1 = ((eth_get(__pyx_v_self->eth, (&__pyx_v_ea)) < 0) != 0); + __pyx_t_1 = (eth_get(__pyx_v_self->eth, (&__pyx_v_ea)) < 0); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":121 @@ -3098,15 +6189,98 @@ static PyObject *__pyx_pf_4dnet_3eth_2get(struct __pyx_obj_4dnet_eth *__pyx_v_se */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3eth_5set(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ -static char __pyx_doc_4dnet_3eth_4set[] = "Set the MAC address for the device, returning 0 on success,\n -1 on failure.\n \n Arguments:\n eth_addr -- 6-byte binary string (e.g. '\\x00\\xde\\xad\\xbe\\xef\\x00')\n "; -static PyObject *__pyx_pw_4dnet_3eth_5set(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { +static PyObject *__pyx_pw_4dnet_3eth_5set(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3eth_4set, "Set the MAC address for the device, returning 0 on success,\n -1 on failure.\n \n Arguments:\n eth_addr -- 6-byte binary string (e.g. '\\x00\\xde\\xad\\xbe\\xef\\x00')\n "); +static PyMethodDef __pyx_mdef_4dnet_3eth_5set = {"set", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_5set, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3eth_4set}; +static PyObject *__pyx_pw_4dnet_3eth_5set(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_value = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_3eth_4set(((struct __pyx_obj_4dnet_eth *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_value,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_value)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 124, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set") < 0)) __PYX_ERR(0, 124, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_value = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 124, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.eth.set", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_3eth_4set(((struct __pyx_obj_4dnet_eth *)__pyx_v_self), __pyx_v_value); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3120,7 +6294,7 @@ static PyObject *__pyx_pf_4dnet_3eth_4set(struct __pyx_obj_4dnet_eth *__pyx_v_se int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set", 0); + __Pyx_RefNannySetupContext("set", 1); /* "dnet.pyx":132 * """ @@ -3140,7 +6314,7 @@ static PyObject *__pyx_pf_4dnet_3eth_4set(struct __pyx_obj_4dnet_eth *__pyx_v_se * raise OSError, __oserror() * */ - __pyx_t_2 = ((eth_set(__pyx_v_self->eth, (&__pyx_v_ea)) < 0) != 0); + __pyx_t_2 = (eth_set(__pyx_v_self->eth, (&__pyx_v_ea)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":134 @@ -3195,15 +6369,98 @@ static PyObject *__pyx_pf_4dnet_3eth_4set(struct __pyx_obj_4dnet_eth *__pyx_v_se */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3eth_7send(PyObject *__pyx_v_self, PyObject *__pyx_v_frame); /*proto*/ -static char __pyx_doc_4dnet_3eth_6send[] = "Send an Ethernet frame, returning the number of bytes sent\n or -1 on failure.\n \n Arguments:\n frame -- binary string representing an Ethernet frame\n "; -static PyObject *__pyx_pw_4dnet_3eth_7send(PyObject *__pyx_v_self, PyObject *__pyx_v_frame) { +static PyObject *__pyx_pw_4dnet_3eth_7send(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3eth_6send, "Send an Ethernet frame, returning the number of bytes sent\n or -1 on failure.\n \n Arguments:\n frame -- binary string representing an Ethernet frame\n "); +static PyMethodDef __pyx_mdef_4dnet_3eth_7send = {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_7send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3eth_6send}; +static PyObject *__pyx_pw_4dnet_3eth_7send(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_frame = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("send (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_3eth_6send(((struct __pyx_obj_4dnet_eth *)__pyx_v_self), ((PyObject *)__pyx_v_frame)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_frame,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_frame)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 136, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "send") < 0)) __PYX_ERR(0, 136, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_frame = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("send", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 136, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.eth.send", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_3eth_6send(((struct __pyx_obj_4dnet_eth *)__pyx_v_self), __pyx_v_frame); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3216,7 +6473,7 @@ static PyObject *__pyx_pf_4dnet_3eth_6send(struct __pyx_obj_4dnet_eth *__pyx_v_s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("send", 0); + __Pyx_RefNannySetupContext("send", 1); /* "dnet.pyx":143 * frame -- binary string representing an Ethernet frame @@ -3263,8 +6520,10 @@ static PyObject *__pyx_pf_4dnet_3eth_6send(struct __pyx_obj_4dnet_eth *__pyx_v_s /* Python wrapper */ static void __pyx_pw_4dnet_3eth_9__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_4dnet_3eth_9__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_4dnet_3eth_8__dealloc__(((struct __pyx_obj_4dnet_eth *)__pyx_v_self)); /* function exit code */ @@ -3272,9 +6531,7 @@ static void __pyx_pw_4dnet_3eth_9__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_4dnet_3eth_8__dealloc__(struct __pyx_obj_4dnet_eth *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "dnet.pyx":146 * @@ -3313,21 +6570,48 @@ static void __pyx_pf_4dnet_3eth_8__dealloc__(struct __pyx_obj_4dnet_eth *__pyx_v */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.eth cannot be converted to a Python object for pickling") + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3eth_11__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_3eth_11__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_3eth_11__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_3eth_11__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_3eth_11__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_3eth_10__reduce_cython__(((struct __pyx_obj_4dnet_eth *)__pyx_v_self)); /* function exit code */ @@ -3338,33 +6622,28 @@ static PyObject *__pyx_pw_4dnet_3eth_11__reduce_cython__(PyObject *__pyx_v_self, static PyObject *__pyx_pf_4dnet_3eth_10__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_eth *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.eth cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.eth cannot be converted to a Python object for pickling") + * raise TypeError, "self.eth 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(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_eth_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.eth cannot be converted to a Python object for pickling") + * raise TypeError, "self.eth 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("dnet.eth.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3374,20 +6653,103 @@ static PyObject *__pyx_pf_4dnet_3eth_10__reduce_cython__(CYTHON_UNUSED struct __ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.eth cannot be converted to a Python object for pickling") + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.eth cannot be converted to a Python object for pickling") + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3eth_13__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_3eth_13__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_3eth_13__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_3eth_13__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_3eth_13__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_3eth_12__setstate_cython__(((struct __pyx_obj_4dnet_eth *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.eth.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_3eth_12__setstate_cython__(((struct __pyx_obj_4dnet_eth *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3395,33 +6757,28 @@ static PyObject *__pyx_pw_4dnet_3eth_13__setstate_cython__(PyObject *__pyx_v_sel static PyObject *__pyx_pf_4dnet_3eth_12__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_eth *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.eth cannot be converted to a Python object for pickling") + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.eth cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.eth 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(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_eth_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.eth cannot be converted to a Python object for pickling") + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.eth cannot be converted to a Python object for pickling") + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.eth.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -3438,16 +6795,98 @@ static PyObject *__pyx_pf_4dnet_3eth_12__setstate_cython__(CYTHON_UNUSED struct */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3eth_ntoa(PyObject *__pyx_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_2eth_ntoa[] = "Convert an Ethernet MAC address from 6-byte packed binary string to\n a printable string ('00:de:ad:be:ef:00')."; -static PyMethodDef __pyx_mdef_4dnet_3eth_ntoa = {"eth_ntoa", (PyCFunction)__pyx_pw_4dnet_3eth_ntoa, METH_O, __pyx_doc_4dnet_2eth_ntoa}; -static PyObject *__pyx_pw_4dnet_3eth_ntoa(PyObject *__pyx_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_3eth_ntoa(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_2eth_ntoa, "Convert an Ethernet MAC address from 6-byte packed binary string to\n a printable string ('00:de:ad:be:ef:00')."); +static PyMethodDef __pyx_mdef_4dnet_3eth_ntoa = {"eth_ntoa", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_ntoa, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2eth_ntoa}; +static PyObject *__pyx_pw_4dnet_3eth_ntoa(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("eth_ntoa (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_2eth_ntoa(__pyx_self, ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 149, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "eth_ntoa") < 0)) __PYX_ERR(0, 149, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("eth_ntoa", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 149, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.eth_ntoa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_2eth_ntoa(__pyx_self, __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3460,7 +6899,7 @@ static PyObject *__pyx_pf_4dnet_2eth_ntoa(CYTHON_UNUSED PyObject *__pyx_self, Py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("eth_ntoa", 0); + __Pyx_RefNannySetupContext("eth_ntoa", 1); /* "dnet.pyx":153 * a printable string ('00:de:ad:be:ef:00').""" @@ -3515,16 +6954,98 @@ static PyObject *__pyx_pf_4dnet_2eth_ntoa(CYTHON_UNUSED PyObject *__pyx_self, Py */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_5eth_aton(PyObject *__pyx_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_4eth_aton[] = "Convert an Ethernet MAC address from a printable string to a\n packed binary string ('\\x00\\xde\\xad\\xbe\\xef\\x00')."; -static PyMethodDef __pyx_mdef_4dnet_5eth_aton = {"eth_aton", (PyCFunction)__pyx_pw_4dnet_5eth_aton, METH_O, __pyx_doc_4dnet_4eth_aton}; -static PyObject *__pyx_pw_4dnet_5eth_aton(PyObject *__pyx_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_5eth_aton(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4eth_aton, "Convert an Ethernet MAC address from a printable string to a\n packed binary string ('\\x00\\xde\\xad\\xbe\\xef\\x00')."); +static PyMethodDef __pyx_mdef_4dnet_5eth_aton = {"eth_aton", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5eth_aton, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4eth_aton}; +static PyObject *__pyx_pw_4dnet_5eth_aton(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("eth_aton (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4eth_aton(__pyx_self, ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 156, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "eth_aton") < 0)) __PYX_ERR(0, 156, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("eth_aton", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 156, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.eth_aton", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4eth_aton(__pyx_self, __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3539,7 +7060,7 @@ static PyObject *__pyx_pf_4dnet_4eth_aton(CYTHON_UNUSED PyObject *__pyx_self, Py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("eth_aton", 0); + __Pyx_RefNannySetupContext("eth_aton", 1); /* "dnet.pyx":160 * packed binary string ('\\x00\\xde\\xad\\xbe\\xef\\x00').""" @@ -3549,7 +7070,7 @@ static PyObject *__pyx_pf_4dnet_4eth_aton(CYTHON_UNUSED PyObject *__pyx_self, Py * return PyBytes_FromStringAndSize(ea.data, 6) */ __pyx_t_1 = __Pyx_PyObject_AsWritableString(__pyx_v_buf); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 160, __pyx_L1_error) - __pyx_t_2 = ((eth_aton(__pyx_t_1, (&__pyx_v_ea)) < 0) != 0); + __pyx_t_2 = (eth_aton(__pyx_t_1, (&__pyx_v_ea)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":161 @@ -3612,69 +7133,142 @@ static PyObject *__pyx_pf_4dnet_4eth_aton(CYTHON_UNUSED PyObject *__pyx_self, Py * """Return a packed binary string representing an Ethernet header. */ -/* Python wrapper */ -static PyObject *__pyx_pw_4dnet_7eth_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_6eth_pack_hdr[] = "Return a packed binary string representing an Ethernet header.\n\t\n Keyword arguments:\n dst -- destination address\t\t\t(6-byte binary string)\n src -- source address\t\t\t(6-byte binary string)\n etype -- Ethernet payload type (ETH_TYPE_*)\t(16-bit integer)\n "; -static PyMethodDef __pyx_mdef_4dnet_7eth_pack_hdr = {"eth_pack_hdr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_7eth_pack_hdr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_6eth_pack_hdr}; -static PyObject *__pyx_pw_4dnet_7eth_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_dst = 0; - PyObject *__pyx_v_src = 0; - PyObject *__pyx_v_etype = 0; +static PyObject *__pyx_pf_4dnet_38__defaults__(CYTHON_UNUSED PyObject *__pyx_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; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("eth_pack_hdr (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dst,&__pyx_n_s_src,&__pyx_n_s_etype,0}; - PyObject* values[3] = {0,0,0}; - values[0] = __pyx_k__3; - values[1] = __pyx_k__4; - values[2] = __pyx_k__5; - 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 (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dst); - if (value) { values[0] = value; kw_args--; } - } + __Pyx_RefNannySetupContext("__defaults__", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_dst); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_dst); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_dst)) __PYX_ERR(0, 164, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_src); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_src); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_src)) __PYX_ERR(0, 164, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_etype); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_etype); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self)->__pyx_arg_etype)) __PYX_ERR(0, 164, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None)) __PYX_ERR(0, 164, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("dnet.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4dnet_7eth_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_6eth_pack_hdr, "Return a packed binary string representing an Ethernet header.\n\t\n Keyword arguments:\n dst -- destination address\t\t\t(6-byte binary string)\n src -- source address\t\t\t(6-byte binary string)\n etype -- Ethernet payload type (ETH_TYPE_*)\t(16-bit integer)\n "); +static PyMethodDef __pyx_mdef_4dnet_7eth_pack_hdr = {"eth_pack_hdr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_7eth_pack_hdr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_6eth_pack_hdr}; +static PyObject *__pyx_pw_4dnet_7eth_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_dst = 0; + PyObject *__pyx_v_src = 0; + PyObject *__pyx_v_etype = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("eth_pack_hdr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dst,&__pyx_n_s_src,&__pyx_n_s_etype,0}; + __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_self); + values[0] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_dst); + values[1] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_src); + values[2] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_etype); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (kw_args > 0) { + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dst); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 164, __pyx_L3_error) + } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_src); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_src); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 164, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_etype); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_etype); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 164, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "eth_pack_hdr") < 0)) __PYX_ERR(0, 164, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "eth_pack_hdr") < 0)) __PYX_ERR(0, 164, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; @@ -3684,10 +7278,18 @@ static PyObject *__pyx_pw_4dnet_7eth_pack_hdr(PyObject *__pyx_self, PyObject *__ __pyx_v_src = values[1]; __pyx_v_etype = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("eth_pack_hdr", 0, 0, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 164, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("eth_pack_hdr", 0, 0, 3, __pyx_nargs); __PYX_ERR(0, 164, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.eth_pack_hdr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -3695,6 +7297,12 @@ static PyObject *__pyx_pw_4dnet_7eth_pack_hdr(PyObject *__pyx_self, PyObject *__ __pyx_r = __pyx_pf_4dnet_6eth_pack_hdr(__pyx_self, __pyx_v_dst, __pyx_v_src, __pyx_v_etype); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3710,7 +7318,7 @@ static PyObject *__pyx_pf_4dnet_6eth_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("eth_pack_hdr", 0); + __Pyx_RefNannySetupContext("eth_pack_hdr", 1); /* "dnet.pyx":175 * cdef char hdr[14] @@ -3788,12 +7396,20 @@ static PyObject *__pyx_pf_4dnet_6eth_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self /* Python wrapper */ static int __pyx_pw_4dnet_2ip_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_4dnet_2ip_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_4dnet_2ip___init__(((struct __pyx_obj_4dnet_ip *)__pyx_v_self)); /* function exit code */ @@ -3809,7 +7425,7 @@ static int __pyx_pf_4dnet_2ip___init__(struct __pyx_obj_4dnet_ip *__pyx_v_self) int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":250 * @@ -3827,7 +7443,7 @@ static int __pyx_pf_4dnet_2ip___init__(struct __pyx_obj_4dnet_ip *__pyx_v_self) * raise OSError, __oserror() * */ - __pyx_t_1 = ((!(__pyx_v_self->ip != 0)) != 0); + __pyx_t_1 = (!(__pyx_v_self->ip != 0)); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":252 @@ -3881,15 +7497,98 @@ static int __pyx_pf_4dnet_2ip___init__(struct __pyx_obj_4dnet_ip *__pyx_v_self) */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_2ip_3send(PyObject *__pyx_v_self, PyObject *__pyx_v_pkt); /*proto*/ -static char __pyx_doc_4dnet_2ip_2send[] = "Send an IP packet, returning the number of bytes sent\n or -1 on failure.\n\n Arguments:\n pkt -- binary string representing an IP packet\n "; -static PyObject *__pyx_pw_4dnet_2ip_3send(PyObject *__pyx_v_self, PyObject *__pyx_v_pkt) { +static PyObject *__pyx_pw_4dnet_2ip_3send(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_2ip_2send, "Send an IP packet, returning the number of bytes sent\n or -1 on failure.\n\n Arguments:\n pkt -- binary string representing an IP packet\n "); +static PyMethodDef __pyx_mdef_4dnet_2ip_3send = {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2ip_3send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2ip_2send}; +static PyObject *__pyx_pw_4dnet_2ip_3send(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_pkt = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("send (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_2ip_2send(((struct __pyx_obj_4dnet_ip *)__pyx_v_self), ((PyObject *)__pyx_v_pkt)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pkt,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pkt)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 254, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "send") < 0)) __PYX_ERR(0, 254, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_pkt = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("send", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 254, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.ip.send", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_2ip_2send(((struct __pyx_obj_4dnet_ip *)__pyx_v_self), __pyx_v_pkt); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -3902,7 +7601,7 @@ static PyObject *__pyx_pf_4dnet_2ip_2send(struct __pyx_obj_4dnet_ip *__pyx_v_sel int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("send", 0); + __Pyx_RefNannySetupContext("send", 1); /* "dnet.pyx":261 * pkt -- binary string representing an IP packet @@ -3949,8 +7648,10 @@ static PyObject *__pyx_pf_4dnet_2ip_2send(struct __pyx_obj_4dnet_ip *__pyx_v_sel /* Python wrapper */ static void __pyx_pw_4dnet_2ip_5__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_4dnet_2ip_5__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_4dnet_2ip_4__dealloc__(((struct __pyx_obj_4dnet_ip *)__pyx_v_self)); /* function exit code */ @@ -3958,9 +7659,7 @@ static void __pyx_pw_4dnet_2ip_5__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_4dnet_2ip_4__dealloc__(struct __pyx_obj_4dnet_ip *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "dnet.pyx":264 * @@ -3999,21 +7698,48 @@ static void __pyx_pf_4dnet_2ip_4__dealloc__(struct __pyx_obj_4dnet_ip *__pyx_v_s */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.ip cannot be converted to a Python object for pickling") + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_2ip_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_2ip_7__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_2ip_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_2ip_7__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2ip_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_2ip_7__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_2ip_6__reduce_cython__(((struct __pyx_obj_4dnet_ip *)__pyx_v_self)); /* function exit code */ @@ -4024,33 +7750,28 @@ static PyObject *__pyx_pw_4dnet_2ip_7__reduce_cython__(PyObject *__pyx_v_self, C static PyObject *__pyx_pf_4dnet_2ip_6__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_ip *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.ip cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.ip cannot be converted to a Python object for pickling") + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_ip_cannot_be_converted_to_a, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.ip cannot be converted to a Python object for pickling") + * raise TypeError, "self.ip 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("dnet.ip.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4060,20 +7781,103 @@ static PyObject *__pyx_pf_4dnet_2ip_6__reduce_cython__(CYTHON_UNUSED struct __py /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.ip cannot be converted to a Python object for pickling") + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.ip cannot be converted to a Python object for pickling") + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_2ip_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_2ip_9__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_2ip_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_2ip_9__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2ip_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_2ip_9__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_2ip_8__setstate_cython__(((struct __pyx_obj_4dnet_ip *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.ip.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_2ip_8__setstate_cython__(((struct __pyx_obj_4dnet_ip *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4081,33 +7885,28 @@ static PyObject *__pyx_pw_4dnet_2ip_9__setstate_cython__(PyObject *__pyx_v_self, static PyObject *__pyx_pf_4dnet_2ip_8__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_ip *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.ip cannot be converted to a Python object for pickling") + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.ip cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_ip_cannot_be_converted_to_a, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.ip cannot be converted to a Python object for pickling") + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.ip cannot be converted to a Python object for pickling") + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.ip.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -4124,16 +7923,98 @@ static PyObject *__pyx_pf_4dnet_2ip_8__setstate_cython__(CYTHON_UNUSED struct __ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_9ip_ntoa(PyObject *__pyx_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_8ip_ntoa[] = "Convert an IP address from a 4-byte packed binary string or\n integer to a printable string ('10.0.0.1')."; -static PyMethodDef __pyx_mdef_4dnet_9ip_ntoa = {"ip_ntoa", (PyCFunction)__pyx_pw_4dnet_9ip_ntoa, METH_O, __pyx_doc_4dnet_8ip_ntoa}; -static PyObject *__pyx_pw_4dnet_9ip_ntoa(PyObject *__pyx_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_9ip_ntoa(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_8ip_ntoa, "Convert an IP address from a 4-byte packed binary string or\n integer to a printable string ('10.0.0.1')."); +static PyMethodDef __pyx_mdef_4dnet_9ip_ntoa = {"ip_ntoa", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_9ip_ntoa, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_8ip_ntoa}; +static PyObject *__pyx_pw_4dnet_9ip_ntoa(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip_ntoa (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_8ip_ntoa(__pyx_self, ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 267, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip_ntoa") < 0)) __PYX_ERR(0, 267, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ip_ntoa", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 267, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.ip_ntoa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_8ip_ntoa(__pyx_self, __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4150,7 +8031,7 @@ static PyObject *__pyx_pf_4dnet_8ip_ntoa(CYTHON_UNUSED PyObject *__pyx_self, PyO int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip_ntoa", 0); + __Pyx_RefNannySetupContext("ip_ntoa", 1); /* "dnet.pyx":273 * cdef unsigned int i @@ -4255,16 +8136,98 @@ static PyObject *__pyx_pf_4dnet_8ip_ntoa(CYTHON_UNUSED PyObject *__pyx_self, PyO */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_11ip_aton(PyObject *__pyx_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_10ip_aton[] = "Convert an IP address from a printable string to a\n packed binary string ('\\x0a\\x00\\x00\\x01')."; -static PyMethodDef __pyx_mdef_4dnet_11ip_aton = {"ip_aton", (PyCFunction)__pyx_pw_4dnet_11ip_aton, METH_O, __pyx_doc_4dnet_10ip_aton}; -static PyObject *__pyx_pw_4dnet_11ip_aton(PyObject *__pyx_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_11ip_aton(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_10ip_aton, "Convert an IP address from a printable string to a\n packed binary string ('\\x0a\\x00\\x00\\x01')."); +static PyMethodDef __pyx_mdef_4dnet_11ip_aton = {"ip_aton", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_11ip_aton, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_10ip_aton}; +static PyObject *__pyx_pw_4dnet_11ip_aton(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip_aton (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_10ip_aton(__pyx_self, ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 280, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip_aton") < 0)) __PYX_ERR(0, 280, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ip_aton", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 280, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.ip_aton", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_10ip_aton(__pyx_self, __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4279,7 +8242,7 @@ static PyObject *__pyx_pf_4dnet_10ip_aton(CYTHON_UNUSED PyObject *__pyx_self, Py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip_aton", 0); + __Pyx_RefNannySetupContext("ip_aton", 1); /* "dnet.pyx":284 * packed binary string ('\\x0a\\x00\\x00\\x01').""" @@ -4289,7 +8252,7 @@ static PyObject *__pyx_pf_4dnet_10ip_aton(CYTHON_UNUSED PyObject *__pyx_self, Py * return PyBytes_FromStringAndSize(&ia, 4) */ __pyx_t_1 = __Pyx_PyObject_AsWritableString(__pyx_v_buf); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 284, __pyx_L1_error) - __pyx_t_2 = ((ip_aton(__pyx_t_1, (&__pyx_v_ia)) < 0) != 0); + __pyx_t_2 = (ip_aton(__pyx_t_1, (&__pyx_v_ia)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":285 @@ -4353,21 +8316,103 @@ static PyObject *__pyx_pf_4dnet_10ip_aton(CYTHON_UNUSED PyObject *__pyx_self, Py */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_13ip_checksum(PyObject *__pyx_self, PyObject *__pyx_v_pkt); /*proto*/ -static char __pyx_doc_4dnet_12ip_checksum[] = "Return packed binary string representing an IP packet \n with the IP and transport-layer checksums set.\n \n Arguments:\n pkt -- binary string representing an IP packet\n "; -static PyMethodDef __pyx_mdef_4dnet_13ip_checksum = {"ip_checksum", (PyCFunction)__pyx_pw_4dnet_13ip_checksum, METH_O, __pyx_doc_4dnet_12ip_checksum}; -static PyObject *__pyx_pw_4dnet_13ip_checksum(PyObject *__pyx_self, PyObject *__pyx_v_pkt) { +static PyObject *__pyx_pw_4dnet_13ip_checksum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_12ip_checksum, "Return packed binary string representing an IP packet \n with the IP and transport-layer checksums set.\n \n Arguments:\n pkt -- binary string representing an IP packet\n "); +static PyMethodDef __pyx_mdef_4dnet_13ip_checksum = {"ip_checksum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_13ip_checksum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_12ip_checksum}; +static PyObject *__pyx_pw_4dnet_13ip_checksum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_pkt = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip_checksum (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_12ip_checksum(__pyx_self, ((PyObject *)__pyx_v_pkt)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_4dnet_12ip_checksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pkt) { + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pkt,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pkt)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 288, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip_checksum") < 0)) __PYX_ERR(0, 288, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_pkt = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ip_checksum", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 288, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.ip_checksum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_12ip_checksum(__pyx_self, __pyx_v_pkt); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4dnet_12ip_checksum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_pkt) { char __pyx_v_buf[0x800]; char *__pyx_v_p; int __pyx_v_n; @@ -4380,7 +8425,7 @@ static PyObject *__pyx_pf_4dnet_12ip_checksum(CYTHON_UNUSED PyObject *__pyx_self int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip_checksum", 0); + __Pyx_RefNannySetupContext("ip_checksum", 1); /* "dnet.pyx":298 * cdef char *p @@ -4389,7 +8434,7 @@ static PyObject *__pyx_pf_4dnet_12ip_checksum(CYTHON_UNUSED PyObject *__pyx_self * if n < 2048: * memcpy(buf, p, n) */ - __pyx_t_1 = ((PyObject_AsReadBuffer(__pyx_v_pkt, (&__pyx_v_p), (&__pyx_v_n)) == 0) != 0); + __pyx_t_1 = (PyObject_AsReadBuffer(__pyx_v_pkt, (&__pyx_v_p), (&__pyx_v_n)) == 0); if (__pyx_t_1) { /* "dnet.pyx":299 @@ -4399,7 +8444,7 @@ static PyObject *__pyx_pf_4dnet_12ip_checksum(CYTHON_UNUSED PyObject *__pyx_self * memcpy(buf, p, n) * __ip_checksum(buf, n) */ - __pyx_t_1 = ((__pyx_v_n < 0x800) != 0); + __pyx_t_1 = (__pyx_v_n < 0x800); if (__pyx_t_1) { /* "dnet.pyx":300 @@ -4552,59 +8597,99 @@ static PyObject *__pyx_pf_4dnet_12ip_checksum(CYTHON_UNUSED PyObject *__pyx_self */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_15ip_cksum_add(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_4dnet_15ip_cksum_add = {"ip_cksum_add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_15ip_cksum_add, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_4dnet_15ip_cksum_add(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_15ip_cksum_add(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_15ip_cksum_add = {"ip_cksum_add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_15ip_cksum_add, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_15ip_cksum_add(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_buf = 0; int __pyx_v_sum; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip_cksum_add (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,&__pyx_n_s_sum,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,&__pyx_n_s_sum,0}; + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_buf)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 311, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sum)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 311, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("ip_cksum_add", 1, 2, 2, 1); __PYX_ERR(0, 311, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ip_cksum_add") < 0)) __PYX_ERR(0, 311, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip_cksum_add") < 0)) __PYX_ERR(0, 311, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_buf = values[0]; __pyx_v_sum = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_sum == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 311, __pyx_L3_error) } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ip_cksum_add", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 311, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ip_cksum_add", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 311, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.ip_cksum_add", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -4612,6 +8697,12 @@ static PyObject *__pyx_pw_4dnet_15ip_cksum_add(PyObject *__pyx_self, PyObject *_ __pyx_r = __pyx_pf_4dnet_14ip_cksum_add(__pyx_self, __pyx_v_buf, __pyx_v_sum); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4626,7 +8717,7 @@ static PyObject *__pyx_pf_4dnet_14ip_cksum_add(CYTHON_UNUSED PyObject *__pyx_sel int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip_cksum_add", 0); + __Pyx_RefNannySetupContext("ip_cksum_add", 1); /* "dnet.pyx":314 * cdef char *p @@ -4635,7 +8726,7 @@ static PyObject *__pyx_pf_4dnet_14ip_cksum_add(CYTHON_UNUSED PyObject *__pyx_sel * return __ip_cksum_add(p, n, sum) * else: */ - __pyx_t_1 = ((PyObject_AsReadBuffer(__pyx_v_buf, (&__pyx_v_p), (&__pyx_v_n)) == 0) != 0); + __pyx_t_1 = (PyObject_AsReadBuffer(__pyx_v_buf, (&__pyx_v_p), (&__pyx_v_n)) == 0); if (likely(__pyx_t_1)) { /* "dnet.pyx":315 @@ -4701,28 +8792,97 @@ static PyObject *__pyx_pf_4dnet_14ip_cksum_add(CYTHON_UNUSED PyObject *__pyx_sel */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_17ip_cksum_carry(PyObject *__pyx_self, PyObject *__pyx_arg_sum); /*proto*/ -static PyMethodDef __pyx_mdef_4dnet_17ip_cksum_carry = {"ip_cksum_carry", (PyCFunction)__pyx_pw_4dnet_17ip_cksum_carry, METH_O, 0}; -static PyObject *__pyx_pw_4dnet_17ip_cksum_carry(PyObject *__pyx_self, PyObject *__pyx_arg_sum) { +static PyObject *__pyx_pw_4dnet_17ip_cksum_carry(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_17ip_cksum_carry = {"ip_cksum_carry", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_17ip_cksum_carry, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_17ip_cksum_carry(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { int __pyx_v_sum; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip_cksum_carry (wrapper)", 0); - assert(__pyx_arg_sum); { - __pyx_v_sum = __Pyx_PyInt_As_int(__pyx_arg_sum); if (unlikely((__pyx_v_sum == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 319, __pyx_L3_error) + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sum,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 319, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip_cksum_carry") < 0)) __PYX_ERR(0, 319, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_sum = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_sum == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 319, __pyx_L3_error) } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ip_cksum_carry", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 319, __pyx_L3_error) + __pyx_L6_skip:; goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.ip_cksum_carry", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; __pyx_L4_argument_unpacking_done:; - __pyx_r = __pyx_pf_4dnet_16ip_cksum_carry(__pyx_self, ((int)__pyx_v_sum)); + __pyx_r = __pyx_pf_4dnet_16ip_cksum_carry(__pyx_self, __pyx_v_sum); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4734,7 +8894,7 @@ static PyObject *__pyx_pf_4dnet_16ip_cksum_carry(CYTHON_UNUSED PyObject *__pyx_s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip_cksum_carry", 0); + __Pyx_RefNannySetupContext("ip_cksum_carry", 1); /* "dnet.pyx":320 * @@ -4777,11 +8937,83 @@ static PyObject *__pyx_pf_4dnet_16ip_cksum_carry(CYTHON_UNUSED PyObject *__pyx_s * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): */ +static PyObject *__pyx_pf_4dnet_40__defaults__(CYTHON_UNUSED PyObject *__pyx_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("__defaults__", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(8); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_tos); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_tos); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_tos)) __PYX_ERR(0, 322, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_len); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_len); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_len)) __PYX_ERR(0, 322, __pyx_L1_error); + __Pyx_INCREF(((PyObject *)__pyx_int_0)); + __Pyx_GIVEREF(((PyObject *)__pyx_int_0)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_int_0))) __PYX_ERR(0, 322, __pyx_L1_error); + __Pyx_INCREF(((PyObject *)__pyx_int_0)); + __Pyx_GIVEREF(((PyObject *)__pyx_int_0)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, ((PyObject *)__pyx_int_0))) __PYX_ERR(0, 322, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_ttl); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_ttl); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_ttl)) __PYX_ERR(0, 322, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_p); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_p); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 5, __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_p)) __PYX_ERR(0, 322, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_src); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_src); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 6, __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_src)) __PYX_ERR(0, 322, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_dst); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_dst); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 7, __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self)->__pyx_arg_dst)) __PYX_ERR(0, 322, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(0, 322, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None)) __PYX_ERR(0, 322, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("dnet.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_19ip_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_18ip_pack_hdr[] = "Return a packed binary string representing an IP header.\n \n Keyword arguments:\n tos -- type of service\t\t\t(8-bit integer)\n len -- length (IP_HDR_LEN + payload)\t(16-bit integer)\n id -- packet ID\t\t\t\t(16-bit integer)\n off -- fragmentation offset\t\t(16-bit integer)\n ttl -- time-to-live\t\t\t(8-bit integer)\n p -- protocol (IP_PROTO_*)\t\t(8-bit integer)\n src -- source address\t\t\t(4-byte binary string)\n dst -- destination address\t\t\t(4-byte binary string)\n "; -static PyMethodDef __pyx_mdef_4dnet_19ip_pack_hdr = {"ip_pack_hdr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_19ip_pack_hdr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_18ip_pack_hdr}; -static PyObject *__pyx_pw_4dnet_19ip_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_19ip_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_18ip_pack_hdr, "Return a packed binary string representing an IP header.\n \n Keyword arguments:\n tos -- type of service\t\t\t(8-bit integer)\n len -- length (IP_HDR_LEN + payload)\t(16-bit integer)\n id -- packet ID\t\t\t\t(16-bit integer)\n off -- fragmentation offset\t\t(16-bit integer)\n ttl -- time-to-live\t\t\t(8-bit integer)\n p -- protocol (IP_PROTO_*)\t\t(8-bit integer)\n src -- source address\t\t\t(4-byte binary string)\n dst -- destination address\t\t\t(4-byte binary string)\n "); +static PyMethodDef __pyx_mdef_4dnet_19ip_pack_hdr = {"ip_pack_hdr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_19ip_pack_hdr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_18ip_pack_hdr}; +static PyObject *__pyx_pw_4dnet_19ip_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_tos = 0; PyObject *__pyx_v_len = 0; PyObject *__pyx_v_id = 0; @@ -4790,116 +9022,137 @@ static PyObject *__pyx_pw_4dnet_19ip_pack_hdr(PyObject *__pyx_self, PyObject *__ PyObject *__pyx_v_p = 0; PyObject *__pyx_v_src = 0; PyObject *__pyx_v_dst = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[8] = {0,0,0,0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip_pack_hdr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tos,&__pyx_n_s_len,&__pyx_n_s_id,&__pyx_n_s_off,&__pyx_n_s_ttl,&__pyx_n_s_p,&__pyx_n_s_src,&__pyx_n_s_dst,0}; - PyObject* values[8] = {0,0,0,0,0,0,0,0}; - values[0] = __pyx_k__8; - values[1] = __pyx_k__9; - values[2] = ((PyObject *)__pyx_int_0); - values[3] = ((PyObject *)__pyx_int_0); - values[4] = __pyx_k__10; - values[5] = __pyx_k__11; - values[6] = __pyx_k__12; - values[7] = __pyx_k__13; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_tos,&__pyx_n_s_len,&__pyx_n_s_id,&__pyx_n_s_off,&__pyx_n_s_ttl,&__pyx_n_s_p,&__pyx_n_s_src,&__pyx_n_s_dst,0}; + __pyx_defaults1 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_self); + values[0] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_tos); + values[1] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_len); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_0))); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_0))); + values[4] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_ttl); + values[5] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_p); + values[6] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_src); + values[7] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_dst); + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + switch (__pyx_nargs) { + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); CYTHON_FALLTHROUGH; - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); CYTHON_FALLTHROUGH; - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_tos); - if (value) { values[0] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_tos); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_len); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_len); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_id); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_id); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_off); - if (value) { values[3] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_off); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ttl); - if (value) { values[4] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ttl); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_p); - if (value) { values[5] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_p); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_src); - if (value) { values[6] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_src); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 7: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dst); - if (value) { values[7] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dst); + if (value) { values[7] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 322, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ip_pack_hdr") < 0)) __PYX_ERR(0, 322, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip_pack_hdr") < 0)) __PYX_ERR(0, 322, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 8: values[7] = PyTuple_GET_ITEM(__pyx_args, 7); + switch (__pyx_nargs) { + case 8: values[7] = __Pyx_Arg_FASTCALL(__pyx_args, 7); CYTHON_FALLTHROUGH; - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); CYTHON_FALLTHROUGH; - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; @@ -4914,10 +9167,18 @@ static PyObject *__pyx_pw_4dnet_19ip_pack_hdr(PyObject *__pyx_self, PyObject *__ __pyx_v_src = values[6]; __pyx_v_dst = values[7]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ip_pack_hdr", 0, 0, 8, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 322, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ip_pack_hdr", 0, 0, 8, __pyx_nargs); __PYX_ERR(0, 322, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.ip_pack_hdr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -4925,6 +9186,12 @@ static PyObject *__pyx_pw_4dnet_19ip_pack_hdr(PyObject *__pyx_self, PyObject *__ __pyx_r = __pyx_pf_4dnet_18ip_pack_hdr(__pyx_self, __pyx_v_tos, __pyx_v_len, __pyx_v_id, __pyx_v_off, __pyx_v_ttl, __pyx_v_p, __pyx_v_src, __pyx_v_dst); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -4945,7 +9212,7 @@ static PyObject *__pyx_pf_4dnet_18ip_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip_pack_hdr", 0); + __Pyx_RefNannySetupContext("ip_pack_hdr", 1); /* "dnet.pyx":339 * cdef char hdr[20] @@ -5026,16 +9293,98 @@ static PyObject *__pyx_pf_4dnet_18ip_pack_hdr(CYTHON_UNUSED PyObject *__pyx_self */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_21ip6_ntoa(PyObject *__pyx_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_20ip6_ntoa[] = "Convert an IPv6 address from a 16-byte packed binary string to a\n printable string ('10.0.0.1')."; -static PyMethodDef __pyx_mdef_4dnet_21ip6_ntoa = {"ip6_ntoa", (PyCFunction)__pyx_pw_4dnet_21ip6_ntoa, METH_O, __pyx_doc_4dnet_20ip6_ntoa}; -static PyObject *__pyx_pw_4dnet_21ip6_ntoa(PyObject *__pyx_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_21ip6_ntoa(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_20ip6_ntoa, "Convert an IPv6 address from a 16-byte packed binary string to a\n printable string ('10.0.0.1')."); +static PyMethodDef __pyx_mdef_4dnet_21ip6_ntoa = {"ip6_ntoa", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_21ip6_ntoa, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_20ip6_ntoa}; +static PyObject *__pyx_pw_4dnet_21ip6_ntoa(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip6_ntoa (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_20ip6_ntoa(__pyx_self, ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 372, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip6_ntoa") < 0)) __PYX_ERR(0, 372, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ip6_ntoa", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 372, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.ip6_ntoa", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_20ip6_ntoa(__pyx_self, __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5048,7 +9397,7 @@ static PyObject *__pyx_pf_4dnet_20ip6_ntoa(CYTHON_UNUSED PyObject *__pyx_self, P int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip6_ntoa", 0); + __Pyx_RefNannySetupContext("ip6_ntoa", 1); /* "dnet.pyx":376 * printable string ('10.0.0.1').""" @@ -5103,16 +9452,98 @@ static PyObject *__pyx_pf_4dnet_20ip6_ntoa(CYTHON_UNUSED PyObject *__pyx_self, P */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_23ip6_aton(PyObject *__pyx_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_22ip6_aton[] = "Convert an IPv6 address from a printable string to a\n packed binary string ('\\x0a\\x00\\x00\\x01')."; -static PyMethodDef __pyx_mdef_4dnet_23ip6_aton = {"ip6_aton", (PyCFunction)__pyx_pw_4dnet_23ip6_aton, METH_O, __pyx_doc_4dnet_22ip6_aton}; -static PyObject *__pyx_pw_4dnet_23ip6_aton(PyObject *__pyx_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_23ip6_aton(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_22ip6_aton, "Convert an IPv6 address from a printable string to a\n packed binary string ('\\x0a\\x00\\x00\\x01')."); +static PyMethodDef __pyx_mdef_4dnet_23ip6_aton = {"ip6_aton", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_23ip6_aton, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_22ip6_aton}; +static PyObject *__pyx_pw_4dnet_23ip6_aton(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip6_aton (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_22ip6_aton(__pyx_self, ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 379, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip6_aton") < 0)) __PYX_ERR(0, 379, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ip6_aton", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 379, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.ip6_aton", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_22ip6_aton(__pyx_self, __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5127,7 +9558,7 @@ static PyObject *__pyx_pf_4dnet_22ip6_aton(CYTHON_UNUSED PyObject *__pyx_self, P int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip6_aton", 0); + __Pyx_RefNannySetupContext("ip6_aton", 1); /* "dnet.pyx":383 * packed binary string ('\\x0a\\x00\\x00\\x01').""" @@ -5137,7 +9568,7 @@ static PyObject *__pyx_pf_4dnet_22ip6_aton(CYTHON_UNUSED PyObject *__pyx_self, P * return PyBytes_FromStringAndSize(&ia, 16) */ __pyx_t_1 = __Pyx_PyObject_AsWritableString(__pyx_v_buf); if (unlikely((!__pyx_t_1) && PyErr_Occurred())) __PYX_ERR(0, 383, __pyx_L1_error) - __pyx_t_2 = ((ip6_aton(__pyx_t_1, (&__pyx_v_ia)) < 0) != 0); + __pyx_t_2 = (ip6_aton(__pyx_t_1, (&__pyx_v_ia)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":384 @@ -5201,16 +9632,98 @@ static PyObject *__pyx_pf_4dnet_22ip6_aton(CYTHON_UNUSED PyObject *__pyx_self, P */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_25ip6_checksum(PyObject *__pyx_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_24ip6_checksum[] = "Return a packed binary string representing an IPv6 packet \n with the IPv6 and transport-layer checksums set.\n\n Arguments:\n pkt -- binary string representing an IPv6 packet\n "; -static PyMethodDef __pyx_mdef_4dnet_25ip6_checksum = {"ip6_checksum", (PyCFunction)__pyx_pw_4dnet_25ip6_checksum, METH_O, __pyx_doc_4dnet_24ip6_checksum}; -static PyObject *__pyx_pw_4dnet_25ip6_checksum(PyObject *__pyx_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_25ip6_checksum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_24ip6_checksum, "Return a packed binary string representing an IPv6 packet \n with the IPv6 and transport-layer checksums set.\n\n Arguments:\n pkt -- binary string representing an IPv6 packet\n "); +static PyMethodDef __pyx_mdef_4dnet_25ip6_checksum = {"ip6_checksum", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_25ip6_checksum, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_24ip6_checksum}; +static PyObject *__pyx_pw_4dnet_25ip6_checksum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip6_checksum (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_24ip6_checksum(__pyx_self, ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 387, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip6_checksum") < 0)) __PYX_ERR(0, 387, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ip6_checksum", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 387, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.ip6_checksum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_24ip6_checksum(__pyx_self, __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5222,7 +9735,7 @@ static PyObject *__pyx_pf_4dnet_24ip6_checksum(CYTHON_UNUSED PyObject *__pyx_sel int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip6_checksum", 0); + __Pyx_RefNannySetupContext("ip6_checksum", 1); /* "dnet.pyx":394 * pkt -- binary string representing an IPv6 packet @@ -5272,11 +9785,80 @@ static PyObject *__pyx_pf_4dnet_24ip6_checksum(CYTHON_UNUSED PyObject *__pyx_sel * """Return a packed binary string representing an IPv6 header. */ +static PyObject *__pyx_pf_4dnet_42__defaults__(CYTHON_UNUSED PyObject *__pyx_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("__defaults__", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(7); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_int_0)); + __Pyx_GIVEREF(((PyObject *)__pyx_int_0)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_int_0))) __PYX_ERR(0, 397, __pyx_L1_error); + __Pyx_INCREF(((PyObject *)__pyx_int_0)); + __Pyx_GIVEREF(((PyObject *)__pyx_int_0)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_int_0))) __PYX_ERR(0, 397, __pyx_L1_error); + __Pyx_INCREF(((PyObject *)__pyx_int_0)); + __Pyx_GIVEREF(((PyObject *)__pyx_int_0)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, ((PyObject *)__pyx_int_0))) __PYX_ERR(0, 397, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_nxt); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_nxt); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_nxt)) __PYX_ERR(0, 397, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_hlim); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_hlim); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_hlim)) __PYX_ERR(0, 397, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_src); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_src); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 5, __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_src)) __PYX_ERR(0, 397, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_dst); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_dst); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 6, __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self)->__pyx_arg_dst)) __PYX_ERR(0, 397, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(0, 397, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None)) __PYX_ERR(0, 397, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("dnet.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_27ip6_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_26ip6_pack_hdr[] = "Return a packed binary string representing an IPv6 header.\n \n Keyword arguments:\n fc -- flow class\t\t\t(8-bit integer)\n fl -- flow label\t\t\t(20-bit integer)\n plen -- payload length\t\t(16-bit integer)\n nxt -- next header (IP_PROTO_*)\t(8-bit integer)\n hlim -- hop limit\t\t\t(8-bit integer)\n src -- source address\t\t(16-byte binary string)\n dst -- destination address\t\t(16-byte binary string)\n "; -static PyMethodDef __pyx_mdef_4dnet_27ip6_pack_hdr = {"ip6_pack_hdr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_27ip6_pack_hdr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_26ip6_pack_hdr}; -static PyObject *__pyx_pw_4dnet_27ip6_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_27ip6_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_26ip6_pack_hdr, "Return a packed binary string representing an IPv6 header.\n \n Keyword arguments:\n fc -- flow class\t\t\t(8-bit integer)\n fl -- flow label\t\t\t(20-bit integer)\n plen -- payload length\t\t(16-bit integer)\n nxt -- next header (IP_PROTO_*)\t(8-bit integer)\n hlim -- hop limit\t\t\t(8-bit integer)\n src -- source address\t\t(16-byte binary string)\n dst -- destination address\t\t(16-byte binary string)\n "); +static PyMethodDef __pyx_mdef_4dnet_27ip6_pack_hdr = {"ip6_pack_hdr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_27ip6_pack_hdr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_26ip6_pack_hdr}; +static PyObject *__pyx_pw_4dnet_27ip6_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_fc = 0; PyObject *__pyx_v_fl = 0; PyObject *__pyx_v_plen = 0; @@ -5284,105 +9866,125 @@ static PyObject *__pyx_pw_4dnet_27ip6_pack_hdr(PyObject *__pyx_self, PyObject *_ PyObject *__pyx_v_hlim = 0; PyObject *__pyx_v_src = 0; PyObject *__pyx_v_dst = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[7] = {0,0,0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("ip6_pack_hdr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fc,&__pyx_n_s_fl,&__pyx_n_s_plen,&__pyx_n_s_nxt,&__pyx_n_s_hlim,&__pyx_n_s_src,&__pyx_n_s_dst,0}; - PyObject* values[7] = {0,0,0,0,0,0,0}; - values[0] = ((PyObject *)__pyx_int_0); - values[1] = ((PyObject *)__pyx_int_0); - values[2] = ((PyObject *)__pyx_int_0); - values[3] = __pyx_k__14; - values[4] = __pyx_k__15; - values[5] = __pyx_k__16; - values[6] = __pyx_k__17; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_fc,&__pyx_n_s_fl,&__pyx_n_s_plen,&__pyx_n_s_nxt,&__pyx_n_s_hlim,&__pyx_n_s_src,&__pyx_n_s_dst,0}; + __pyx_defaults2 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_self); + values[0] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_0))); + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_0))); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_0))); + values[3] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_nxt); + values[4] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_hlim); + values[5] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_src); + values[6] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_dst); + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); CYTHON_FALLTHROUGH; - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fc); - if (value) { values[0] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fc); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_fl); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_fl); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_plen); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_plen); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_nxt); - if (value) { values[3] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_nxt); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_hlim); - if (value) { values[4] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_hlim); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_src); - if (value) { values[5] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_src); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dst); - if (value) { values[6] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dst); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 397, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "ip6_pack_hdr") < 0)) __PYX_ERR(0, 397, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "ip6_pack_hdr") < 0)) __PYX_ERR(0, 397, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); CYTHON_FALLTHROUGH; - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; @@ -5396,10 +9998,18 @@ static PyObject *__pyx_pw_4dnet_27ip6_pack_hdr(PyObject *__pyx_self, PyObject *_ __pyx_v_src = values[5]; __pyx_v_dst = values[6]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("ip6_pack_hdr", 0, 0, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 397, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("ip6_pack_hdr", 0, 0, 7, __pyx_nargs); __PYX_ERR(0, 397, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.ip6_pack_hdr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -5407,6 +10017,12 @@ static PyObject *__pyx_pw_4dnet_27ip6_pack_hdr(PyObject *__pyx_self, PyObject *_ __pyx_r = __pyx_pf_4dnet_26ip6_pack_hdr(__pyx_self, __pyx_v_fc, __pyx_v_fl, __pyx_v_plen, __pyx_v_nxt, __pyx_v_hlim, __pyx_v_src, __pyx_v_dst); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5426,7 +10042,7 @@ static PyObject *__pyx_pf_4dnet_26ip6_pack_hdr(CYTHON_UNUSED PyObject *__pyx_sel int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ip6_pack_hdr", 0); + __Pyx_RefNannySetupContext("ip6_pack_hdr", 1); /* "dnet.pyx":412 * cdef char hdr[40] @@ -5510,50 +10126,60 @@ static int __pyx_pw_4dnet_4addr_1__init__(PyObject *__pyx_v_self, PyObject *__py static int __pyx_pw_4dnet_4addr_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_addrtxt = 0; CYTHON_UNUSED PyObject *__pyx_v_addrtype = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_addrtxt,&__pyx_n_s_addrtype,0}; - PyObject* values[2] = {0,0}; - values[0] = ((PyObject *)Py_None); - values[1] = __pyx_k__18; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_addrtxt,&__pyx_n_s_addrtype,0}; + values[0] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)Py_None)); + values[1] = __Pyx_Arg_NewRef_VARARGS(__pyx_k_); + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_addrtxt); - if (value) { values[0] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_addrtxt); + if (value) { values[0] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 446, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_addrtype); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_addrtype); + if (value) { values[1] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 446, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 446, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 446, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; @@ -5562,10 +10188,18 @@ static int __pyx_pw_4dnet_4addr_1__init__(PyObject *__pyx_v_self, PyObject *__py __pyx_v_addrtxt = values[0]; __pyx_v_addrtype = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 446, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 2, __pyx_nargs); __PYX_ERR(0, 446, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.addr.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; @@ -5573,6 +10207,12 @@ static int __pyx_pw_4dnet_4addr_1__init__(PyObject *__pyx_v_self, PyObject *__py __pyx_r = __pyx_pf_4dnet_4addr___init__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self), __pyx_v_addrtxt, __pyx_v_addrtype); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5588,7 +10228,7 @@ static int __pyx_pf_4dnet_4addr___init__(struct __pyx_obj_4dnet_addr *__pyx_v_se int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":447 * @@ -5598,7 +10238,7 @@ static int __pyx_pf_4dnet_4addr___init__(struct __pyx_obj_4dnet_addr *__pyx_v_se * self._addr.addr_type = ADDR_TYPE_IP */ __pyx_t_2 = PyObject_RichCompare(__pyx_v_addrtxt, Py_None, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 447, __pyx_L1_error) - __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 447, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 447, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_3) { } else { @@ -5606,7 +10246,7 @@ static int __pyx_pf_4dnet_4addr___init__(struct __pyx_obj_4dnet_addr *__pyx_v_se goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_PyObject_AsWritableString(__pyx_v_addrtxt); if (unlikely((!__pyx_t_4) && PyErr_Occurred())) __PYX_ERR(0, 447, __pyx_L1_error) - __pyx_t_3 = ((addr_aton(__pyx_t_4, (&__pyx_v_self->_addr)) < 0) != 0); + __pyx_t_3 = (addr_aton(__pyx_t_4, (&__pyx_v_self->_addr)) < 0); __pyx_t_1 = __pyx_t_3; __pyx_L4_bool_binop_done:; if (__pyx_t_1) { @@ -5618,7 +10258,7 @@ static int __pyx_pf_4dnet_4addr___init__(struct __pyx_obj_4dnet_addr *__pyx_v_se * self._addr.addr_type = ADDR_TYPE_IP * self._addr.addr_bits = IP_ADDR_BITS */ - __pyx_t_1 = ((PyBytes_Size(__pyx_v_addrtxt) == 4) != 0); + __pyx_t_1 = (PyBytes_Size(__pyx_v_addrtxt) == 4); if (likely(__pyx_t_1)) { /* "dnet.pyx":449 @@ -5719,9 +10359,11 @@ static int __pyx_pf_4dnet_4addr___init__(struct __pyx_obj_4dnet_addr *__pyx_v_se /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_8addrtype_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_8addrtype_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_8addrtype___get__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -5736,7 +10378,7 @@ static PyObject *__pyx_pf_4dnet_4addr_8addrtype___get__(struct __pyx_obj_4dnet_a int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "dnet.pyx":458 * """Address type (ADDR_TYPE_*) integer.""" @@ -5783,12 +10425,14 @@ static PyObject *__pyx_pf_4dnet_4addr_8addrtype___get__(struct __pyx_obj_4dnet_a static int __pyx_pw_4dnet_4addr_8addrtype_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ static int __pyx_pw_4dnet_4addr_8addrtype_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { unsigned int __pyx_v_value; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); assert(__pyx_arg_value); { __pyx_v_value = __Pyx_PyInt_As_unsigned_int(__pyx_arg_value); if (unlikely((__pyx_v_value == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 459, __pyx_L3_error) } @@ -5807,12 +10451,10 @@ static int __pyx_pw_4dnet_4addr_8addrtype_3__set__(PyObject *__pyx_v_self, PyObj static int __pyx_pf_4dnet_4addr_8addrtype_2__set__(struct __pyx_obj_4dnet_addr *__pyx_v_self, unsigned int __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); /* "dnet.pyx":460 * return self._addr.addr_type @@ -5821,7 +10463,7 @@ static int __pyx_pf_4dnet_4addr_8addrtype_2__set__(struct __pyx_obj_4dnet_addr * * self._addr.addr_type = value * */ - __pyx_t_1 = ((__pyx_v_value > 0xffff) != 0); + __pyx_t_1 = (__pyx_v_value > 0xffff); if (unlikely(__pyx_t_1)) { __Pyx_Raise(__pyx_builtin_OverflowError, 0, 0, 0); __PYX_ERR(0, 460, __pyx_L1_error) @@ -5851,7 +10493,6 @@ static int __pyx_pf_4dnet_4addr_8addrtype_2__set__(struct __pyx_obj_4dnet_addr * __Pyx_AddTraceback("dnet.addr.addrtype.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -5866,9 +10507,11 @@ static int __pyx_pf_4dnet_4addr_8addrtype_2__set__(struct __pyx_obj_4dnet_addr * /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_4bits_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_4bits_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_4bits___get__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -5883,7 +10526,7 @@ static PyObject *__pyx_pf_4dnet_4addr_4bits___get__(struct __pyx_obj_4dnet_addr int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "dnet.pyx":466 * """Address bitlength integer.""" @@ -5930,12 +10573,14 @@ static PyObject *__pyx_pf_4dnet_4addr_4bits___get__(struct __pyx_obj_4dnet_addr static int __pyx_pw_4dnet_4addr_4bits_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value); /*proto*/ static int __pyx_pw_4dnet_4addr_4bits_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_arg_value) { unsigned int __pyx_v_value; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); assert(__pyx_arg_value); { __pyx_v_value = __Pyx_PyInt_As_unsigned_int(__pyx_arg_value); if (unlikely((__pyx_v_value == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 467, __pyx_L3_error) } @@ -5954,12 +10599,10 @@ static int __pyx_pw_4dnet_4addr_4bits_3__set__(PyObject *__pyx_v_self, PyObject static int __pyx_pf_4dnet_4addr_4bits_2__set__(struct __pyx_obj_4dnet_addr *__pyx_v_self, unsigned int __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); /* "dnet.pyx":468 * return self._addr.addr_bits @@ -5968,7 +10611,7 @@ static int __pyx_pf_4dnet_4addr_4bits_2__set__(struct __pyx_obj_4dnet_addr *__py * self._addr.addr_bits = value * */ - __pyx_t_1 = ((__pyx_v_value > 0xffff) != 0); + __pyx_t_1 = (__pyx_v_value > 0xffff); if (unlikely(__pyx_t_1)) { __Pyx_Raise(__pyx_builtin_OverflowError, 0, 0, 0); __PYX_ERR(0, 468, __pyx_L1_error) @@ -5998,7 +10641,6 @@ static int __pyx_pf_4dnet_4addr_4bits_2__set__(struct __pyx_obj_4dnet_addr *__py __Pyx_AddTraceback("dnet.addr.bits.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -6013,9 +10655,11 @@ static int __pyx_pf_4dnet_4addr_4bits_2__set__(struct __pyx_obj_4dnet_addr *__py /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_4data_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_4data_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_4data___get__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -6033,7 +10677,7 @@ static PyObject *__pyx_pf_4dnet_4addr_4data___get__(struct __pyx_obj_4dnet_addr int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "dnet.pyx":474 * """Raw address string.""" @@ -6049,7 +10693,7 @@ static PyObject *__pyx_pf_4dnet_4addr_4data___get__(struct __pyx_obj_4dnet_addr __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 474, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 474, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_4) { @@ -6090,7 +10734,7 @@ static PyObject *__pyx_pf_4dnet_4addr_4data___get__(struct __pyx_obj_4dnet_addr __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 476, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 476, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 476, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_4) { @@ -6131,7 +10775,7 @@ static PyObject *__pyx_pf_4dnet_4addr_4data___get__(struct __pyx_obj_4dnet_addr __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 478, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 478, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (likely(__pyx_t_4)) { @@ -6202,9 +10846,11 @@ static PyObject *__pyx_pf_4dnet_4addr_4data___get__(struct __pyx_obj_4dnet_addr /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_3eth_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_3eth_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_3eth___get__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -6222,7 +10868,7 @@ static PyObject *__pyx_pf_4dnet_4addr_3eth___get__(struct __pyx_obj_4dnet_addr * int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "dnet.pyx":486 * """Ethernet MAC address as binary string.""" @@ -6238,7 +10884,7 @@ static PyObject *__pyx_pf_4dnet_4addr_3eth___get__(struct __pyx_obj_4dnet_addr * __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 486, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 486, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 486, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_4)) { @@ -6307,9 +10953,11 @@ static PyObject *__pyx_pf_4dnet_4addr_3eth___get__(struct __pyx_obj_4dnet_addr * /* Python wrapper */ static int __pyx_pw_4dnet_4addr_3eth_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_4dnet_4addr_3eth_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_3eth_2__set__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ @@ -6328,7 +10976,7 @@ static int __pyx_pf_4dnet_4addr_3eth_2__set__(struct __pyx_obj_4dnet_addr *__pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_RefNannySetupContext("__set__", 1); /* "dnet.pyx":491 * @@ -6344,7 +10992,7 @@ static int __pyx_pf_4dnet_4addr_3eth_2__set__(struct __pyx_obj_4dnet_addr *__pyx __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 491, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 491, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 491, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_4)) { @@ -6437,9 +11085,11 @@ static int __pyx_pf_4dnet_4addr_3eth_2__set__(struct __pyx_obj_4dnet_addr *__pyx /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_2ip_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_2ip_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_2ip___get__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -6457,7 +11107,7 @@ static PyObject *__pyx_pf_4dnet_4addr_2ip___get__(struct __pyx_obj_4dnet_addr *_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "dnet.pyx":500 * """IPv4 address as binary string.""" @@ -6473,7 +11123,7 @@ static PyObject *__pyx_pf_4dnet_4addr_2ip___get__(struct __pyx_obj_4dnet_addr *_ __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 500, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 500, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 500, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_4)) { @@ -6542,9 +11192,11 @@ static PyObject *__pyx_pf_4dnet_4addr_2ip___get__(struct __pyx_obj_4dnet_addr *_ /* Python wrapper */ static int __pyx_pw_4dnet_4addr_2ip_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_4dnet_4addr_2ip_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_2ip_2__set__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ @@ -6563,7 +11215,7 @@ static int __pyx_pf_4dnet_4addr_2ip_2__set__(struct __pyx_obj_4dnet_addr *__pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_RefNannySetupContext("__set__", 1); /* "dnet.pyx":506 * def __set__(self, value): @@ -6637,7 +11289,7 @@ static int __pyx_pf_4dnet_4addr_2ip_2__set__(struct __pyx_obj_4dnet_addr *__pyx_ __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 510, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(0, 510, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(0, 510, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (unlikely(__pyx_t_1)) { @@ -6733,9 +11385,11 @@ static int __pyx_pf_4dnet_4addr_2ip_2__set__(struct __pyx_obj_4dnet_addr *__pyx_ /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_3ip6_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_3ip6_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_3ip6___get__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -6753,7 +11407,7 @@ static PyObject *__pyx_pf_4dnet_4addr_3ip6___get__(struct __pyx_obj_4dnet_addr * int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "dnet.pyx":520 * """IPv6 address as binary string.""" @@ -6769,7 +11423,7 @@ static PyObject *__pyx_pf_4dnet_4addr_3ip6___get__(struct __pyx_obj_4dnet_addr * __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 520, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 520, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 520, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_4)) { @@ -6838,9 +11492,11 @@ static PyObject *__pyx_pf_4dnet_4addr_3ip6___get__(struct __pyx_obj_4dnet_addr * /* Python wrapper */ static int __pyx_pw_4dnet_4addr_3ip6_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ static int __pyx_pw_4dnet_4addr_3ip6_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_3ip6_2__set__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self), ((PyObject *)__pyx_v_value)); /* function exit code */ @@ -6859,7 +11515,7 @@ static int __pyx_pf_4dnet_4addr_3ip6_2__set__(struct __pyx_obj_4dnet_addr *__pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_RefNannySetupContext("__set__", 1); /* "dnet.pyx":525 * @@ -6875,7 +11531,7 @@ static int __pyx_pf_4dnet_4addr_3ip6_2__set__(struct __pyx_obj_4dnet_addr *__pyx __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 525, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 525, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 525, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_4)) { @@ -6966,12 +11622,40 @@ static int __pyx_pf_4dnet_4addr_3ip6_2__set__(struct __pyx_obj_4dnet_addr *__pyx */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4addr_3bcast(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_4dnet_4addr_2bcast[] = "Return an addr object for our broadcast address."; -static PyObject *__pyx_pw_4dnet_4addr_3bcast(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4addr_3bcast(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4addr_2bcast, "Return an addr object for our broadcast address."); +static PyMethodDef __pyx_mdef_4dnet_4addr_3bcast = {"bcast", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_3bcast, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4addr_2bcast}; +static PyObject *__pyx_pw_4dnet_4addr_3bcast(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("bcast (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("bcast", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "bcast", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4addr_2bcast(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -6987,7 +11671,7 @@ static PyObject *__pyx_pf_4dnet_4addr_2bcast(struct __pyx_obj_4dnet_addr *__pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("bcast", 0); + __Pyx_RefNannySetupContext("bcast", 1); /* "dnet.pyx":533 * def bcast(self): @@ -7018,7 +11702,7 @@ static PyObject *__pyx_pf_4dnet_4addr_2bcast(struct __pyx_obj_4dnet_addr *__pyx_ * def net(self): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_bcast)); + __Pyx_INCREF((PyObject *)__pyx_v_bcast); __pyx_r = ((PyObject *)__pyx_v_bcast); goto __pyx_L0; @@ -7051,12 +11735,40 @@ static PyObject *__pyx_pf_4dnet_4addr_2bcast(struct __pyx_obj_4dnet_addr *__pyx_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4addr_5net(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_4dnet_4addr_4net[] = "Return an addr object for our network address."; -static PyObject *__pyx_pw_4dnet_4addr_5net(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4addr_5net(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4addr_4net, "Return an addr object for our network address."); +static PyMethodDef __pyx_mdef_4dnet_4addr_5net = {"net", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_5net, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4addr_4net}; +static PyObject *__pyx_pw_4dnet_4addr_5net(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("net (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("net", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "net", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4addr_4net(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -7072,7 +11784,7 @@ static PyObject *__pyx_pf_4dnet_4addr_4net(struct __pyx_obj_4dnet_addr *__pyx_v_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("net", 0); + __Pyx_RefNannySetupContext("net", 1); /* "dnet.pyx":539 * def net(self): @@ -7103,7 +11815,7 @@ static PyObject *__pyx_pf_4dnet_4addr_4net(struct __pyx_obj_4dnet_addr *__pyx_v_ * def __add__(self, other): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_net)); + __Pyx_INCREF((PyObject *)__pyx_v_net); __pyx_r = ((PyObject *)__pyx_v_net); goto __pyx_L0; @@ -7138,17 +11850,19 @@ static PyObject *__pyx_pf_4dnet_4addr_4net(struct __pyx_obj_4dnet_addr *__pyx_v_ /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_7__add__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_7__add__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__add__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4addr_6__add__(((PyObject *)__pyx_v_self), ((PyObject *)__pyx_v_other)); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_4dnet_4addr_6__add__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self), ((PyObject *)__pyx_v_other)); /* function exit code */ __Pyx_RefNannyFinishContext(); return __pyx_r; } -static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { +static PyObject *__pyx_pf_4dnet_4addr_6__add__(struct __pyx_obj_4dnet_addr *__pyx_v_self, PyObject *__pyx_v_other) { PyObject *__pyx_v_x = NULL; PyObject *__pyx_v_y = NULL; PyObject *__pyx_v_z = NULL; @@ -7158,11 +11872,12 @@ static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - unsigned long __pyx_t_5; + int __pyx_t_5; + unsigned long __pyx_t_6; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__add__", 0); + __Pyx_RefNannySetupContext("__add__", 1); /* "dnet.pyx":545 * def __add__(self, other): @@ -7171,7 +11886,7 @@ static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject * x, y = other, self * elif PyLong_Check(other): */ - __pyx_t_1 = (PyLong_Check(__pyx_v_self) != 0); + __pyx_t_1 = (PyLong_Check(((PyObject *)__pyx_v_self)) != 0); if (__pyx_t_1) { /* "dnet.pyx":546 @@ -7183,7 +11898,7 @@ static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject */ __pyx_t_2 = __pyx_v_other; __Pyx_INCREF(__pyx_t_2); - __pyx_t_3 = __pyx_v_self; + __pyx_t_3 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_3); __pyx_v_x = __pyx_t_2; __pyx_t_2 = 0; @@ -7217,7 +11932,7 @@ static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject * else: * raise NotImplementedError */ - __pyx_t_3 = __pyx_v_self; + __pyx_t_3 = ((PyObject *)__pyx_v_self); __Pyx_INCREF(__pyx_t_3); __pyx_t_2 = __pyx_v_other; __Pyx_INCREF(__pyx_t_2); @@ -7259,20 +11974,27 @@ static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_x, __pyx_n_s_copy); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 551, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_5 = 1; } } - __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(0, 551, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_2 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 0+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } __pyx_v_z = __pyx_t_2; __pyx_t_2 = 0; @@ -7288,9 +12010,9 @@ static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject __pyx_t_3 = PyNumber_Add(__pyx_t_2, __pyx_v_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 552, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_5 = __Pyx_PyInt_As_unsigned_long(__pyx_t_3); if (unlikely((__pyx_t_5 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 552, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_As_unsigned_long(__pyx_t_3); if (unlikely((__pyx_t_6 == (unsigned long)-1) && PyErr_Occurred())) __PYX_ERR(0, 552, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - ((struct __pyx_obj_4dnet_addr *)__pyx_v_z)->_addr.addr_ip = htonl(__pyx_t_5); + ((struct __pyx_obj_4dnet_addr *)__pyx_v_z)->_addr.addr_ip = htonl(__pyx_t_6); /* "dnet.pyx":553 * z = x.__copy__() @@ -7337,11 +12059,39 @@ static PyObject *__pyx_pf_4dnet_4addr_6__add__(PyObject *__pyx_v_self, PyObject */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4addr_9__copy__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_4addr_9__copy__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4addr_9__copy__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_4addr_9__copy__ = {"__copy__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_9__copy__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_4addr_9__copy__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__copy__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__copy__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__copy__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4addr_8__copy__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -7358,7 +12108,7 @@ static PyObject *__pyx_pf_4dnet_4addr_8__copy__(struct __pyx_obj_4dnet_addr *__p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__copy__", 0); + __Pyx_RefNannySetupContext("__copy__", 1); /* "dnet.pyx":556 * @@ -7390,7 +12140,7 @@ static PyObject *__pyx_pf_4dnet_4addr_8__copy__(struct __pyx_obj_4dnet_addr *__p * def __eq__(addr x, addr y): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_a)); + __Pyx_INCREF((PyObject *)__pyx_v_a); __pyx_r = ((PyObject *)__pyx_v_a); goto __pyx_L0; @@ -7425,12 +12175,14 @@ static PyObject *__pyx_pf_4dnet_4addr_8__copy__(struct __pyx_obj_4dnet_addr *__p /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_11__eq__(PyObject *__pyx_v_x, PyObject *__pyx_v_y); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_11__eq__(PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__eq__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_4dnet_addr, 1, "y", 0))) __PYX_ERR(0, 560, __pyx_L1_error) __pyx_r = __pyx_pf_4dnet_4addr_10__eq__(((struct __pyx_obj_4dnet_addr *)__pyx_v_x), ((struct __pyx_obj_4dnet_addr *)__pyx_v_y)); @@ -7450,7 +12202,7 @@ static PyObject *__pyx_pf_4dnet_4addr_10__eq__(struct __pyx_obj_4dnet_addr *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__eq__", 0); + __Pyx_RefNannySetupContext("__eq__", 1); /* "dnet.pyx":561 * @@ -7496,12 +12248,14 @@ static PyObject *__pyx_pf_4dnet_4addr_10__eq__(struct __pyx_obj_4dnet_addr *__py /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_13__ne__(PyObject *__pyx_v_x, PyObject *__pyx_v_y); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_13__ne__(PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__ne__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_4dnet_addr, 1, "y", 0))) __PYX_ERR(0, 563, __pyx_L1_error) __pyx_r = __pyx_pf_4dnet_4addr_12__ne__(((struct __pyx_obj_4dnet_addr *)__pyx_v_x), ((struct __pyx_obj_4dnet_addr *)__pyx_v_y)); @@ -7521,7 +12275,7 @@ static PyObject *__pyx_pf_4dnet_4addr_12__ne__(struct __pyx_obj_4dnet_addr *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__ne__", 0); + __Pyx_RefNannySetupContext("__ne__", 1); /* "dnet.pyx":564 * @@ -7567,12 +12321,14 @@ static PyObject *__pyx_pf_4dnet_4addr_12__ne__(struct __pyx_obj_4dnet_addr *__py /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_15__lt__(PyObject *__pyx_v_x, PyObject *__pyx_v_y); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_15__lt__(PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__lt__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_4dnet_addr, 1, "y", 0))) __PYX_ERR(0, 566, __pyx_L1_error) __pyx_r = __pyx_pf_4dnet_4addr_14__lt__(((struct __pyx_obj_4dnet_addr *)__pyx_v_x), ((struct __pyx_obj_4dnet_addr *)__pyx_v_y)); @@ -7592,7 +12348,7 @@ static PyObject *__pyx_pf_4dnet_4addr_14__lt__(struct __pyx_obj_4dnet_addr *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__lt__", 0); + __Pyx_RefNannySetupContext("__lt__", 1); /* "dnet.pyx":567 * @@ -7638,12 +12394,14 @@ static PyObject *__pyx_pf_4dnet_4addr_14__lt__(struct __pyx_obj_4dnet_addr *__py /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_17__gt__(PyObject *__pyx_v_x, PyObject *__pyx_v_y); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_17__gt__(PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__gt__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_4dnet_addr, 1, "y", 0))) __PYX_ERR(0, 569, __pyx_L1_error) __pyx_r = __pyx_pf_4dnet_4addr_16__gt__(((struct __pyx_obj_4dnet_addr *)__pyx_v_x), ((struct __pyx_obj_4dnet_addr *)__pyx_v_y)); @@ -7663,7 +12421,7 @@ static PyObject *__pyx_pf_4dnet_4addr_16__gt__(struct __pyx_obj_4dnet_addr *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__gt__", 0); + __Pyx_RefNannySetupContext("__gt__", 1); /* "dnet.pyx":570 * @@ -7709,12 +12467,14 @@ static PyObject *__pyx_pf_4dnet_4addr_16__gt__(struct __pyx_obj_4dnet_addr *__py /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_19__le__(PyObject *__pyx_v_x, PyObject *__pyx_v_y); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_19__le__(PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__le__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_4dnet_addr, 1, "y", 0))) __PYX_ERR(0, 572, __pyx_L1_error) __pyx_r = __pyx_pf_4dnet_4addr_18__le__(((struct __pyx_obj_4dnet_addr *)__pyx_v_x), ((struct __pyx_obj_4dnet_addr *)__pyx_v_y)); @@ -7734,7 +12494,7 @@ static PyObject *__pyx_pf_4dnet_4addr_18__le__(struct __pyx_obj_4dnet_addr *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__le__", 0); + __Pyx_RefNannySetupContext("__le__", 1); /* "dnet.pyx":573 * @@ -7780,12 +12540,14 @@ static PyObject *__pyx_pf_4dnet_4addr_18__le__(struct __pyx_obj_4dnet_addr *__py /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_21__ge__(PyObject *__pyx_v_x, PyObject *__pyx_v_y); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_21__ge__(PyObject *__pyx_v_x, PyObject *__pyx_v_y) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__ge__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_y), __pyx_ptype_4dnet_addr, 1, "y", 0))) __PYX_ERR(0, 575, __pyx_L1_error) __pyx_r = __pyx_pf_4dnet_4addr_20__ge__(((struct __pyx_obj_4dnet_addr *)__pyx_v_x), ((struct __pyx_obj_4dnet_addr *)__pyx_v_y)); @@ -7805,7 +12567,7 @@ static PyObject *__pyx_pf_4dnet_4addr_20__ge__(struct __pyx_obj_4dnet_addr *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__ge__", 0); + __Pyx_RefNannySetupContext("__ge__", 1); /* "dnet.pyx":576 * @@ -7851,12 +12613,14 @@ static PyObject *__pyx_pf_4dnet_4addr_20__ge__(struct __pyx_obj_4dnet_addr *__py /* Python wrapper */ static int __pyx_pw_4dnet_4addr_23__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_other); /*proto*/ static int __pyx_pw_4dnet_4addr_23__contains__(PyObject *__pyx_v_self, PyObject *__pyx_v_other) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__contains__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_other), __pyx_ptype_4dnet_addr, 1, "other", 0))) __PYX_ERR(0, 578, __pyx_L1_error) __pyx_r = __pyx_pf_4dnet_4addr_22__contains__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self), ((struct __pyx_obj_4dnet_addr *)__pyx_v_other)); @@ -7875,11 +12639,9 @@ static int __pyx_pf_4dnet_4addr_22__contains__(struct __pyx_obj_4dnet_addr *__py struct addr __pyx_v_o1; struct addr __pyx_v_o2; int __pyx_r; - __Pyx_RefNannyDeclarations int __pyx_t_1; int __pyx_t_2; int __pyx_t_3; - __Pyx_RefNannySetupContext("__contains__", 0); /* "dnet.pyx":580 * def __contains__(self, addr other): @@ -7888,7 +12650,7 @@ static int __pyx_pf_4dnet_4addr_22__contains__(struct __pyx_obj_4dnet_addr *__py * addr_bcast(&self._addr, &s2) != 0 or \ * addr_net(&other._addr, &o1) != 0 or \ */ - __pyx_t_2 = ((addr_net((&__pyx_v_self->_addr), (&__pyx_v_s1)) != 0) != 0); + __pyx_t_2 = (addr_net((&__pyx_v_self->_addr), (&__pyx_v_s1)) != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; @@ -7902,7 +12664,7 @@ static int __pyx_pf_4dnet_4addr_22__contains__(struct __pyx_obj_4dnet_addr *__py * addr_net(&other._addr, &o1) != 0 or \ * addr_bcast(&other._addr, &o2) != 0: */ - __pyx_t_2 = ((addr_bcast((&__pyx_v_self->_addr), (&__pyx_v_s2)) != 0) != 0); + __pyx_t_2 = (addr_bcast((&__pyx_v_self->_addr), (&__pyx_v_s2)) != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; @@ -7916,7 +12678,7 @@ static int __pyx_pf_4dnet_4addr_22__contains__(struct __pyx_obj_4dnet_addr *__py * addr_bcast(&other._addr, &o2) != 0: * return 0 */ - __pyx_t_2 = ((addr_net((&__pyx_v_other->_addr), (&__pyx_v_o1)) != 0) != 0); + __pyx_t_2 = (addr_net((&__pyx_v_other->_addr), (&__pyx_v_o1)) != 0); if (!__pyx_t_2) { } else { __pyx_t_1 = __pyx_t_2; @@ -7930,7 +12692,7 @@ static int __pyx_pf_4dnet_4addr_22__contains__(struct __pyx_obj_4dnet_addr *__py * return 0 * return addr_cmp(&o1, &s1) >= 0 and addr_cmp(&o2, &s2) <= 0 */ - __pyx_t_2 = ((addr_bcast((&__pyx_v_other->_addr), (&__pyx_v_o2)) != 0) != 0); + __pyx_t_2 = (addr_bcast((&__pyx_v_other->_addr), (&__pyx_v_o2)) != 0); __pyx_t_1 = __pyx_t_2; __pyx_L4_bool_binop_done:; @@ -7991,7 +12753,6 @@ static int __pyx_pf_4dnet_4addr_22__contains__(struct __pyx_obj_4dnet_addr *__py /* function exit code */ __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -8006,9 +12767,11 @@ static int __pyx_pf_4dnet_4addr_22__contains__(struct __pyx_obj_4dnet_addr *__py /* Python wrapper */ static Py_hash_t __pyx_pw_4dnet_4addr_25__hash__(PyObject *__pyx_v_self); /*proto*/ static Py_hash_t __pyx_pw_4dnet_4addr_25__hash__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; Py_hash_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__hash__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_24__hash__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -8031,7 +12794,7 @@ static Py_hash_t __pyx_pf_4dnet_4addr_24__hash__(struct __pyx_obj_4dnet_addr *__ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__hash__", 0); + __Pyx_RefNannySetupContext("__hash__", 1); /* "dnet.pyx":589 * def __hash__(self): @@ -8047,7 +12810,7 @@ static Py_hash_t __pyx_pf_4dnet_4addr_24__hash__(struct __pyx_obj_4dnet_addr *__ __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 589, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 589, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 589, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_4) { __pyx_v_size = 6; @@ -8068,7 +12831,7 @@ static Py_hash_t __pyx_pf_4dnet_4addr_24__hash__(struct __pyx_obj_4dnet_addr *__ __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 590, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 590, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 590, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_4) { __pyx_v_size = 4; @@ -8089,7 +12852,7 @@ static Py_hash_t __pyx_pf_4dnet_4addr_24__hash__(struct __pyx_obj_4dnet_addr *__ __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_EQ); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 591, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_4) { __pyx_v_size = 16; @@ -8168,7 +12931,7 @@ static Py_hash_t __pyx_pf_4dnet_4addr_24__hash__(struct __pyx_obj_4dnet_addr *__ * x = x ^ y * if x == -1: x = -2 */ - __pyx_t_4 = ((__pyx_v_y == -1L) != 0); + __pyx_t_4 = (__pyx_v_y == -1L); if (__pyx_t_4) { __pyx_v_y = -2L; } @@ -8189,7 +12952,7 @@ static Py_hash_t __pyx_pf_4dnet_4addr_24__hash__(struct __pyx_obj_4dnet_addr *__ * return x * */ - __pyx_t_4 = ((__pyx_v_x == -1L) != 0); + __pyx_t_4 = (__pyx_v_x == -1L); if (__pyx_t_4) { __pyx_v_x = -2L; } @@ -8236,9 +12999,11 @@ static Py_hash_t __pyx_pf_4dnet_4addr_24__hash__(struct __pyx_obj_4dnet_addr *__ /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_27__int__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_27__int__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__int__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_26__int__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -8256,7 +13021,7 @@ static PyObject *__pyx_pf_4dnet_4addr_26__int__(struct __pyx_obj_4dnet_addr *__p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__int__", 0); + __Pyx_RefNannySetupContext("__int__", 1); /* "dnet.pyx":605 * @@ -8272,7 +13037,7 @@ static PyObject *__pyx_pf_4dnet_4addr_26__int__(struct __pyx_obj_4dnet_addr *__p __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 605, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 605, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 605, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (unlikely(__pyx_t_4)) { @@ -8342,9 +13107,11 @@ static PyObject *__pyx_pf_4dnet_4addr_26__int__(struct __pyx_obj_4dnet_addr *__p #if PY_MAJOR_VERSION < 3 static PyObject *__pyx_pw_4dnet_4addr_29__long__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_29__long__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__long__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_28__long__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -8360,10 +13127,11 @@ static PyObject *__pyx_pf_4dnet_4addr_28__long__(struct __pyx_obj_4dnet_addr *__ PyObject *__pyx_t_1 = NULL; PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__long__", 0); + __Pyx_RefNannySetupContext("__long__", 1); /* "dnet.pyx":610 * @@ -8376,20 +13144,27 @@ static PyObject *__pyx_pf_4dnet_4addr_28__long__(struct __pyx_obj_4dnet_addr *__ __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_int); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 610, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __pyx_t_3 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = 0; + #if CYTHON_UNPACK_METHODS + if (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_4 = 1; } } - __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(0, 610, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 0+__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 610, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } __pyx_r = __pyx_t_1; __pyx_t_1 = 0; goto __pyx_L0; @@ -8427,9 +13202,11 @@ static PyObject *__pyx_pf_4dnet_4addr_28__long__(struct __pyx_obj_4dnet_addr *__ /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_31__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_31__iter__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_30__iter__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -8450,7 +13227,7 @@ static PyObject *__pyx_pf_4dnet_4addr_30__iter__(struct __pyx_obj_4dnet_addr *__ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__iter__", 0); + __Pyx_RefNannySetupContext("__iter__", 1); /* "dnet.pyx":614 * def __iter__(self): @@ -8466,7 +13243,7 @@ static PyObject *__pyx_pf_4dnet_4addr_30__iter__(struct __pyx_obj_4dnet_addr *__ __pyx_t_4 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 614, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 614, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 614, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (!__pyx_t_5) { } else { @@ -8481,7 +13258,7 @@ static PyObject *__pyx_pf_4dnet_4addr_30__iter__(struct __pyx_obj_4dnet_addr *__ * addr_bcast(&self._addr, &b) != 0: * raise ValueError */ - __pyx_t_5 = ((addr_net((&__pyx_v_self->_addr), (&__pyx_v_a)) != 0) != 0); + __pyx_t_5 = (addr_net((&__pyx_v_self->_addr), (&__pyx_v_a)) != 0); if (!__pyx_t_5) { } else { __pyx_t_1 = __pyx_t_5; @@ -8495,7 +13272,7 @@ static PyObject *__pyx_pf_4dnet_4addr_30__iter__(struct __pyx_obj_4dnet_addr *__ * raise ValueError * """XXX - i wish! */ - __pyx_t_5 = ((addr_bcast((&__pyx_v_self->_addr), (&__pyx_v_b)) != 0) != 0); + __pyx_t_5 = (addr_bcast((&__pyx_v_self->_addr), (&__pyx_v_b)) != 0); __pyx_t_1 = __pyx_t_5; __pyx_L4_bool_binop_done:; @@ -8542,9 +13319,9 @@ static PyObject *__pyx_pf_4dnet_4addr_30__iter__(struct __pyx_obj_4dnet_addr *__ __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 626, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_4); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4)) __PYX_ERR(0, 626, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3)) __PYX_ERR(0, 626, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_3 = 0; __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_4dnet___addr_ip4_iter), __pyx_t_2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 626, __pyx_L1_error) @@ -8586,9 +13363,11 @@ static PyObject *__pyx_pf_4dnet_4addr_30__iter__(struct __pyx_obj_4dnet_addr *__ /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4addr_33__repr__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4addr_33__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4addr_32__repr__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -8605,7 +13384,7 @@ static PyObject *__pyx_pf_4dnet_4addr_32__repr__(struct __pyx_obj_4dnet_addr *__ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__repr__", 0); + __Pyx_RefNannySetupContext("__repr__", 1); /* "dnet.pyx":630 * def __repr__(self): @@ -8623,7 +13402,7 @@ static PyObject *__pyx_pf_4dnet_4addr_32__repr__(struct __pyx_obj_4dnet_addr *__ * return '' * return p */ - __pyx_t_1 = ((!(__pyx_v_p != 0)) != 0); + __pyx_t_1 = (!(__pyx_v_p != 0)); if (__pyx_t_1) { /* "dnet.pyx":632 @@ -8682,16 +13461,44 @@ static PyObject *__pyx_pf_4dnet_4addr_32__repr__(struct __pyx_obj_4dnet_addr *__ /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4addr_35__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_4addr_35__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4addr_35__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_4addr_35__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_35__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_4addr_35__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4addr_34__reduce_cython__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self)); /* function exit code */ @@ -8702,33 +13509,28 @@ static PyObject *__pyx_pw_4dnet_4addr_35__reduce_cython__(PyObject *__pyx_v_self static PyObject *__pyx_pf_4dnet_4addr_34__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_addr *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__19, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Pickling_of_struct_members_such, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" * def __setstate_cython__(self, __pyx_state): */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.addr.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -8738,20 +13540,103 @@ static PyObject *__pyx_pf_4dnet_4addr_34__reduce_cython__(CYTHON_UNUSED struct _ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4addr_37__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_4addr_37__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_4addr_37__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_4addr_37__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_37__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_4addr_37__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4addr_36__setstate_cython__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.addr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4addr_36__setstate_cython__(((struct __pyx_obj_4dnet_addr *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -8759,33 +13644,28 @@ static PyObject *__pyx_pw_4dnet_4addr_37__setstate_cython__(PyObject *__pyx_v_se static PyObject *__pyx_pf_4dnet_4addr_36__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_addr *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__20, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_Pickling_of_struct_members_such, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.addr.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -8806,54 +13686,78 @@ static int __pyx_pw_4dnet_15__addr_ip4_iter_1__init__(PyObject *__pyx_v_self, Py static int __pyx_pw_4dnet_15__addr_ip4_iter_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { PyObject *__pyx_v_cur = 0; PyObject *__pyx_v_max = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cur,&__pyx_n_s_max,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_cur,&__pyx_n_s_max,0}; + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_cur)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_cur)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_max)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_max)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 639, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, 1); __PYX_ERR(0, 639, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 639, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 639, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); } __pyx_v_cur = values[0]; __pyx_v_max = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 639, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 639, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.__addr_ip4_iter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; @@ -8861,18 +13765,22 @@ static int __pyx_pw_4dnet_15__addr_ip4_iter_1__init__(PyObject *__pyx_v_self, Py __pyx_r = __pyx_pf_4dnet_15__addr_ip4_iter___init__(((struct __pyx_obj_4dnet___addr_ip4_iter *)__pyx_v_self), __pyx_v_cur, __pyx_v_max); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } static int __pyx_pf_4dnet_15__addr_ip4_iter___init__(struct __pyx_obj_4dnet___addr_ip4_iter *__pyx_v_self, PyObject *__pyx_v_cur, PyObject *__pyx_v_max) { 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("__init__", 0); /* "dnet.pyx":640 * @@ -8909,7 +13817,6 @@ static int __pyx_pf_4dnet_15__addr_ip4_iter___init__(struct __pyx_obj_4dnet___ad __Pyx_AddTraceback("dnet.__addr_ip4_iter.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -8924,9 +13831,11 @@ static int __pyx_pf_4dnet_15__addr_ip4_iter___init__(struct __pyx_obj_4dnet___ad /* Python wrapper */ static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_3__next__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_3__next__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_15__addr_ip4_iter_2__next__(((struct __pyx_obj_4dnet___addr_ip4_iter *)__pyx_v_self)); /* function exit code */ @@ -8938,13 +13847,14 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_2__next__(struct __pyx_obj_4dn struct __pyx_obj_4dnet_addr *__pyx_v_next = 0; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations + int __pyx_error_without_exception = 0; /* StopIteration */ int __pyx_t_1; PyObject *__pyx_t_2 = NULL; unsigned short __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__next__", 0); + __Pyx_RefNannySetupContext("__next__", 1); /* "dnet.pyx":645 * def __next__(self): @@ -8953,7 +13863,7 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_2__next__(struct __pyx_obj_4dn * next = addr() * next._addr.addr_type = ADDR_TYPE_IP */ - __pyx_t_1 = ((__pyx_v_self->cur <= __pyx_v_self->max) != 0); + __pyx_t_1 = (__pyx_v_self->cur <= __pyx_v_self->max); if (likely(__pyx_t_1)) { /* "dnet.pyx":646 @@ -9020,7 +13930,7 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_2__next__(struct __pyx_obj_4dn * raise StopIteration */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_next)); + __Pyx_INCREF((PyObject *)__pyx_v_next); __pyx_r = ((PyObject *)__pyx_v_next); goto __pyx_L0; @@ -9041,8 +13951,8 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_2__next__(struct __pyx_obj_4dn * # */ /*else*/ { - __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); - __PYX_ERR(0, 653, __pyx_L1_error) + __pyx_error_without_exception = 1; + goto __pyx_L1_error;; } /* "dnet.pyx":643 @@ -9056,7 +13966,9 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_2__next__(struct __pyx_obj_4dn /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_2); - __Pyx_AddTraceback("dnet.__addr_ip4_iter.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (!__pyx_error_without_exception) { + __Pyx_AddTraceback("dnet.__addr_ip4_iter.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + } __pyx_r = NULL; __pyx_L0:; __Pyx_XDECREF((PyObject *)__pyx_v_next); @@ -9072,11 +13984,39 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_2__next__(struct __pyx_obj_4dn */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_5__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_15__addr_ip4_iter_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_15__addr_ip4_iter_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(((struct __pyx_obj_4dnet___addr_ip4_iter *)__pyx_v_self)); /* function exit code */ @@ -9094,11 +14034,10 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py PyObject *__pyx_t_2 = NULL; PyObject *__pyx_t_3 = NULL; int __pyx_t_4; - int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__reduce_cython__", 0); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":5 * cdef object _dict @@ -9114,9 +14053,9 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_2 = 0; __pyx_v_state = ((PyObject*)__pyx_t_3); @@ -9142,8 +14081,7 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py * use_setstate = True */ __pyx_t_4 = (__pyx_v__dict != Py_None); - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + if (__pyx_t_4) { /* "(tree fragment)":8 * _dict = getattr(self, '__dict__', None) @@ -9156,7 +14094,7 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(__pyx_v__dict); __Pyx_GIVEREF(__pyx_v__dict); - PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__dict)) __PYX_ERR(1, 8, __pyx_L1_error); __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 8, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -9187,7 +14125,7 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py * else: * use_setstate = False # <<<<<<<<<<<<<< * if use_setstate: - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, None), state + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, None), state */ /*else*/ { __pyx_v_use_setstate = 0; @@ -9198,18 +14136,17 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py * else: * use_setstate = False * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, None), state + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, None), state * else: */ - __pyx_t_5 = (__pyx_v_use_setstate != 0); - if (__pyx_t_5) { + if (__pyx_v_use_setstate) { /* "(tree fragment)":13 * use_setstate = False * if use_setstate: - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, None), state # <<<<<<<<<<<<<< + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, None), state # <<<<<<<<<<<<<< * else: - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, state) + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, state) */ __Pyx_XDECREF(__pyx_r); __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_pyx_unpickle___addr_ip4_iter); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error) @@ -9218,22 +14155,22 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_218787872); - __Pyx_GIVEREF(__pyx_int_218787872); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_218787872); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_112194662); + __Pyx_GIVEREF(__pyx_int_112194662); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_112194662)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(Py_None); __Pyx_GIVEREF(Py_None); - PyTuple_SET_ITEM(__pyx_t_3, 2, Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, Py_None)) __PYX_ERR(1, 13, __pyx_L1_error); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_GIVEREF(__pyx_t_2); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state)) __PYX_ERR(1, 13, __pyx_L1_error); __pyx_t_2 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_1; @@ -9244,15 +14181,15 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py * else: * use_setstate = False * if use_setstate: # <<<<<<<<<<<<<< - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, None), state + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, None), state * else: */ } /* "(tree fragment)":15 - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, None), state + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, None), state * else: - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, state) # <<<<<<<<<<<<<< + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, state) # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle___addr_ip4_iter__set_state(self, __pyx_state) */ @@ -9264,19 +14201,19 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py __Pyx_GOTREF(__pyx_t_3); __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); - __Pyx_INCREF(__pyx_int_218787872); - __Pyx_GIVEREF(__pyx_int_218787872); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_218787872); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))))) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_int_112194662); + __Pyx_GIVEREF(__pyx_int_112194662); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_112194662)) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_INCREF(__pyx_v_state); __Pyx_GIVEREF(__pyx_v_state); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state)) __PYX_ERR(1, 15, __pyx_L1_error); __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error); __pyx_t_1 = 0; __pyx_t_3 = 0; __pyx_r = __pyx_t_2; @@ -9307,20 +14244,103 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_4__reduce_cython__(struct __py /* "(tree fragment)":16 * else: - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, state) + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle___addr_ip4_iter__set_state(self, __pyx_state) */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_7__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_15__addr_ip4_iter_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_15__addr_ip4_iter_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_15__addr_ip4_iter_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_15__addr_ip4_iter_6__setstate_cython__(((struct __pyx_obj_4dnet___addr_ip4_iter *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 16, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.__addr_ip4_iter.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_15__addr_ip4_iter_6__setstate_cython__(((struct __pyx_obj_4dnet___addr_ip4_iter *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -9332,21 +14352,21 @@ static PyObject *__pyx_pf_4dnet_15__addr_ip4_iter_6__setstate_cython__(struct __ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__setstate_cython__", 0); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":17 - * return __pyx_unpickle___addr_ip4_iter, (type(self), 0xd0a7020, state) + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, state) * def __setstate_cython__(self, __pyx_state): * __pyx_unpickle___addr_ip4_iter__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(1, 17, __pyx_L1_error) + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 17, __pyx_L1_error) __pyx_t_1 = __pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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___addr_ip4_iter, (type(self), 0xd0a7020, state) + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, state) * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< * __pyx_unpickle___addr_ip4_iter__set_state(self, __pyx_state) */ @@ -9387,13 +14407,12 @@ static int __pyx_f_4dnet___arp_callback(struct arp_entry *__pyx_v_entry, void *_ PyObject *(*__pyx_t_5)(PyObject *); struct addr __pyx_t_6; int __pyx_t_7; - PyObject *__pyx_t_8 = NULL; + int __pyx_t_8; int __pyx_t_9; - int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__arp_callback", 0); + __Pyx_RefNannySetupContext("__arp_callback", 1); /* "dnet.pyx":691 * @@ -9434,7 +14453,7 @@ static int __pyx_f_4dnet___arp_callback(struct arp_entry *__pyx_v_entry, void *_ __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 691, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext; + __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; @@ -9500,16 +14519,17 @@ static int __pyx_f_4dnet___arp_callback(struct arp_entry *__pyx_v_entry, void *_ */ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)__pyx_v_pa)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_pa)); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_pa)); - __Pyx_INCREF(((PyObject *)__pyx_v_ha)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_ha)); - PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_ha)); + __Pyx_INCREF((PyObject *)__pyx_v_pa); + __Pyx_GIVEREF((PyObject *)__pyx_v_pa); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_pa))) __PYX_ERR(0, 695, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_ha); + __Pyx_GIVEREF((PyObject *)__pyx_v_ha); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_ha))) __PYX_ERR(0, 695, __pyx_L1_error); __Pyx_INCREF(__pyx_v_f); __pyx_t_2 = __pyx_v_f; __pyx_t_4 = NULL; __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -9519,41 +14539,16 @@ static int __pyx_f_4dnet___arp_callback(struct arp_entry *__pyx_v_entry, void *_ __pyx_t_7 = 1; } } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_a}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_a}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_a}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - { - __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 695, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (__pyx_t_4) { - __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL; - } - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); - __Pyx_INCREF(__pyx_v_a); - __Pyx_GIVEREF(__pyx_v_a); - PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_a); - __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 695, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_ret = __pyx_t_3; __pyx_t_3 = 0; @@ -9564,9 +14559,9 @@ static int __pyx_f_4dnet___arp_callback(struct arp_entry *__pyx_v_entry, void *_ * ret = 0 * return ret */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_ret); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 696, __pyx_L1_error) - __pyx_t_10 = ((!__pyx_t_9) != 0); - if (__pyx_t_10) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_ret); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 696, __pyx_L1_error) + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { /* "dnet.pyx":697 * ret = f((pa, ha), a) @@ -9612,7 +14607,6 @@ static int __pyx_f_4dnet___arp_callback(struct arp_entry *__pyx_v_entry, void *_ __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("dnet.__arp_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -9636,12 +14630,20 @@ static int __pyx_f_4dnet___arp_callback(struct arp_entry *__pyx_v_entry, void *_ /* Python wrapper */ static int __pyx_pw_4dnet_3arp_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_4dnet_3arp_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_4dnet_3arp___init__(((struct __pyx_obj_4dnet_arp *)__pyx_v_self)); /* function exit code */ @@ -9657,7 +14659,7 @@ static int __pyx_pf_4dnet_3arp___init__(struct __pyx_obj_4dnet_arp *__pyx_v_self int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":708 * @@ -9675,7 +14677,7 @@ static int __pyx_pf_4dnet_3arp___init__(struct __pyx_obj_4dnet_arp *__pyx_v_self * raise OSError, __oserror() * */ - __pyx_t_1 = ((!(__pyx_v_self->arp != 0)) != 0); + __pyx_t_1 = (!(__pyx_v_self->arp != 0)); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":710 @@ -9729,59 +14731,100 @@ static int __pyx_pf_4dnet_3arp___init__(struct __pyx_obj_4dnet_arp *__pyx_v_self */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3arp_3add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_3arp_2add[] = "Add an entry to the system ARP table.\n\n Arguments:\n pa -- ADDR_TYPE_IP network address object\n ha -- ADDR_TYPE_ETH network address object\n "; -static PyObject *__pyx_pw_4dnet_3arp_3add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_3arp_3add(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3arp_2add, "Add an entry to the system ARP table.\n\n Arguments:\n pa -- ADDR_TYPE_IP network address object\n ha -- ADDR_TYPE_ETH network address object\n "); +static PyMethodDef __pyx_mdef_4dnet_3arp_3add = {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_3add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3arp_2add}; +static PyObject *__pyx_pw_4dnet_3arp_3add(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { struct __pyx_obj_4dnet_addr *__pyx_v_pa = 0; struct __pyx_obj_4dnet_addr *__pyx_v_ha = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pa,&__pyx_n_s_ha,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pa,&__pyx_n_s_ha,0}; + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pa)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pa)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 712, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ha)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ha)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 712, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, 1); __PYX_ERR(0, 712, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add") < 0)) __PYX_ERR(0, 712, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add") < 0)) __PYX_ERR(0, 712, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_pa = ((struct __pyx_obj_4dnet_addr *)values[0]); __pyx_v_ha = ((struct __pyx_obj_4dnet_addr *)values[1]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 712, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 712, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.arp.add", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -9795,6 +14838,12 @@ static PyObject *__pyx_pw_4dnet_3arp_3add(PyObject *__pyx_v_self, PyObject *__py __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -9809,7 +14858,7 @@ static PyObject *__pyx_pf_4dnet_3arp_2add(struct __pyx_obj_4dnet_arp *__pyx_v_se int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("add", 0); + __Pyx_RefNannySetupContext("add", 1); /* "dnet.pyx":720 * """ @@ -9838,7 +14887,7 @@ static PyObject *__pyx_pf_4dnet_3arp_2add(struct __pyx_obj_4dnet_arp *__pyx_v_se * raise OSError, __oserror() * */ - __pyx_t_2 = ((arp_add(__pyx_v_self->arp, (&__pyx_v_entry)) < 0) != 0); + __pyx_t_2 = (arp_add(__pyx_v_self->arp, (&__pyx_v_entry)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":723 @@ -9893,23 +14942,103 @@ static PyObject *__pyx_pf_4dnet_3arp_2add(struct __pyx_obj_4dnet_arp *__pyx_v_se */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3arp_5delete(PyObject *__pyx_v_self, PyObject *__pyx_v_pa); /*proto*/ -static char __pyx_doc_4dnet_3arp_4delete[] = "Delete an entry from the system ARP table.\n\n Arguments:\n pa -- ADDR_TYPE_IP network address object\n "; -static PyObject *__pyx_pw_4dnet_3arp_5delete(PyObject *__pyx_v_self, PyObject *__pyx_v_pa) { +static PyObject *__pyx_pw_4dnet_3arp_5delete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3arp_4delete, "Delete an entry from the system ARP table.\n\n Arguments:\n pa -- ADDR_TYPE_IP network address object\n "); +static PyMethodDef __pyx_mdef_4dnet_3arp_5delete = {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_5delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3arp_4delete}; +static PyObject *__pyx_pw_4dnet_3arp_5delete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_4dnet_addr *__pyx_v_pa = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("delete (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pa,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pa)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 725, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delete") < 0)) __PYX_ERR(0, 725, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_pa = ((struct __pyx_obj_4dnet_addr *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delete", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 725, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.arp.delete", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pa), __pyx_ptype_4dnet_addr, 1, "pa", 0))) __PYX_ERR(0, 725, __pyx_L1_error) - __pyx_r = __pyx_pf_4dnet_3arp_4delete(((struct __pyx_obj_4dnet_arp *)__pyx_v_self), ((struct __pyx_obj_4dnet_addr *)__pyx_v_pa)); + __pyx_r = __pyx_pf_4dnet_3arp_4delete(((struct __pyx_obj_4dnet_arp *)__pyx_v_self), __pyx_v_pa); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -9924,7 +15053,7 @@ static PyObject *__pyx_pf_4dnet_3arp_4delete(struct __pyx_obj_4dnet_arp *__pyx_v int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("delete", 0); + __Pyx_RefNannySetupContext("delete", 1); /* "dnet.pyx":732 * """ @@ -9943,7 +15072,7 @@ static PyObject *__pyx_pf_4dnet_3arp_4delete(struct __pyx_obj_4dnet_arp *__pyx_v * raise OSError, __oserror() * */ - __pyx_t_2 = ((arp_delete(__pyx_v_self->arp, (&__pyx_v_entry)) < 0) != 0); + __pyx_t_2 = (arp_delete(__pyx_v_self->arp, (&__pyx_v_entry)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":734 @@ -9998,23 +15127,103 @@ static PyObject *__pyx_pf_4dnet_3arp_4delete(struct __pyx_obj_4dnet_arp *__pyx_v */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3arp_7get(PyObject *__pyx_v_self, PyObject *__pyx_v_pa); /*proto*/ -static char __pyx_doc_4dnet_3arp_6get[] = "Return the hardware address for a given protocol address\n in the system ARP table.\n\n Arguments:\n pa -- ADDR_TYPE_IP network address object\n "; -static PyObject *__pyx_pw_4dnet_3arp_7get(PyObject *__pyx_v_self, PyObject *__pyx_v_pa) { +static PyObject *__pyx_pw_4dnet_3arp_7get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3arp_6get, "Return the hardware address for a given protocol address\n in the system ARP table.\n\n Arguments:\n pa -- ADDR_TYPE_IP network address object\n "); +static PyMethodDef __pyx_mdef_4dnet_3arp_7get = {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_7get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3arp_6get}; +static PyObject *__pyx_pw_4dnet_3arp_7get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_4dnet_addr *__pyx_v_pa = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pa,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pa)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 736, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get") < 0)) __PYX_ERR(0, 736, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_pa = ((struct __pyx_obj_4dnet_addr *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 736, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.arp.get", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pa), __pyx_ptype_4dnet_addr, 1, "pa", 0))) __PYX_ERR(0, 736, __pyx_L1_error) - __pyx_r = __pyx_pf_4dnet_3arp_6get(((struct __pyx_obj_4dnet_arp *)__pyx_v_self), ((struct __pyx_obj_4dnet_addr *)__pyx_v_pa)); + __pyx_r = __pyx_pf_4dnet_3arp_6get(((struct __pyx_obj_4dnet_arp *)__pyx_v_self), __pyx_v_pa); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10030,7 +15239,7 @@ static PyObject *__pyx_pf_4dnet_3arp_6get(struct __pyx_obj_4dnet_arp *__pyx_v_se int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get", 0); + __Pyx_RefNannySetupContext("get", 1); /* "dnet.pyx":744 * """ @@ -10049,7 +15258,7 @@ static PyObject *__pyx_pf_4dnet_3arp_6get(struct __pyx_obj_4dnet_arp *__pyx_v_se * return addr(addr_ntoa(&entry.arp_ha)) * return None */ - __pyx_t_2 = ((arp_get(__pyx_v_self->arp, (&__pyx_v_entry)) == 0) != 0); + __pyx_t_2 = (arp_get(__pyx_v_self->arp, (&__pyx_v_entry)) == 0); if (__pyx_t_2) { /* "dnet.pyx":746 @@ -10118,52 +15327,82 @@ static PyObject *__pyx_pf_4dnet_3arp_6get(struct __pyx_obj_4dnet_arp *__pyx_v_se */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3arp_9loop(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_3arp_8loop[] = "Iterate over the system ARP table, invoking a user callback\n with each entry, returning the status of the callback routine.\n\n Keyword arguments:\n callback -- callback function with ((pa, ha), arg) prototype.\n If this function returns a non-zero value, the loop\n will break early.\n arg -- optional callback argument\n "; -static PyObject *__pyx_pw_4dnet_3arp_9loop(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_3arp_9loop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3arp_8loop, "Iterate over the system ARP table, invoking a user callback\n with each entry, returning the status of the callback routine.\n\n Keyword arguments:\n callback -- callback function with ((pa, ha), arg) prototype.\n If this function returns a non-zero value, the loop\n will break early.\n arg -- optional callback argument\n "); +static PyMethodDef __pyx_mdef_4dnet_3arp_9loop = {"loop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_9loop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3arp_8loop}; +static PyObject *__pyx_pw_4dnet_3arp_9loop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_callback = 0; PyObject *__pyx_v_arg = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("loop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_arg,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_arg,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_callback)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 749, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_arg); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 749, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "loop") < 0)) __PYX_ERR(0, 749, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "loop") < 0)) __PYX_ERR(0, 749, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -10171,10 +15410,18 @@ static PyObject *__pyx_pw_4dnet_3arp_9loop(PyObject *__pyx_v_self, PyObject *__p __pyx_v_callback = values[0]; __pyx_v_arg = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("loop", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 749, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("loop", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 749, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.arp.loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -10182,6 +15429,12 @@ static PyObject *__pyx_pw_4dnet_3arp_9loop(PyObject *__pyx_v_self, PyObject *__p __pyx_r = __pyx_pf_4dnet_3arp_8loop(((struct __pyx_obj_4dnet_arp *)__pyx_v_self), __pyx_v_callback, __pyx_v_arg); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10194,7 +15447,7 @@ static PyObject *__pyx_pf_4dnet_3arp_8loop(struct __pyx_obj_4dnet_arp *__pyx_v_s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("loop", 0); + __Pyx_RefNannySetupContext("loop", 1); /* "dnet.pyx":759 * arg -- optional callback argument @@ -10207,10 +15460,10 @@ static PyObject *__pyx_pf_4dnet_3arp_8loop(struct __pyx_obj_4dnet_arp *__pyx_v_s __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_callback); __Pyx_GIVEREF(__pyx_v_callback); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_callback); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_callback)) __PYX_ERR(0, 759, __pyx_L1_error); __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg)) __PYX_ERR(0, 759, __pyx_L1_error); __pyx_v__arg = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; @@ -10259,9 +15512,11 @@ static PyObject *__pyx_pf_4dnet_3arp_8loop(struct __pyx_obj_4dnet_arp *__pyx_v_s /* Python wrapper */ static PyObject *__pyx_pw_4dnet_3arp_11__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_3arp_11__iter__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_3arp_10__iter__(((struct __pyx_obj_4dnet_arp *)__pyx_v_self)); /* function exit code */ @@ -10278,11 +15533,10 @@ static PyObject *__pyx_pf_4dnet_3arp_10__iter__(struct __pyx_obj_4dnet_arp *__py 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("__iter__", 0); + __Pyx_RefNannySetupContext("__iter__", 1); /* "dnet.pyx":763 * @@ -10309,7 +15563,8 @@ static PyObject *__pyx_pf_4dnet_3arp_10__iter__(struct __pyx_obj_4dnet_arp *__py __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -10319,41 +15574,16 @@ static PyObject *__pyx_pf_4dnet_3arp_10__iter__(struct __pyx_obj_4dnet_arp *__py __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_v_l}; - __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(0, 764, __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_v_l}; - __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(0, 764, __pyx_L1_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_l}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); __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(0, 764, __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_v_l); - __Pyx_GIVEREF(__pyx_v_l); - PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_l); - __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 764, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 764, __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_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":765 @@ -10384,7 +15614,6 @@ static PyObject *__pyx_pf_4dnet_3arp_10__iter__(struct __pyx_obj_4dnet_arp *__py __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("dnet.arp.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -10405,8 +15634,10 @@ static PyObject *__pyx_pf_4dnet_3arp_10__iter__(struct __pyx_obj_4dnet_arp *__py /* Python wrapper */ static void __pyx_pw_4dnet_3arp_13__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_4dnet_3arp_13__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_4dnet_3arp_12__dealloc__(((struct __pyx_obj_4dnet_arp *)__pyx_v_self)); /* function exit code */ @@ -10414,9 +15645,7 @@ static void __pyx_pw_4dnet_3arp_13__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_4dnet_3arp_12__dealloc__(struct __pyx_obj_4dnet_arp *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "dnet.pyx":768 * @@ -10455,21 +15684,48 @@ static void __pyx_pf_4dnet_3arp_12__dealloc__(struct __pyx_obj_4dnet_arp *__pyx_ */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.arp cannot be converted to a Python object for pickling") + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3arp_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_3arp_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_3arp_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_3arp_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_3arp_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_3arp_14__reduce_cython__(((struct __pyx_obj_4dnet_arp *)__pyx_v_self)); /* function exit code */ @@ -10480,33 +15736,28 @@ static PyObject *__pyx_pw_4dnet_3arp_15__reduce_cython__(PyObject *__pyx_v_self, static PyObject *__pyx_pf_4dnet_3arp_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_arp *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.arp cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.arp cannot be converted to a Python object for pickling") + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_arp_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.arp cannot be converted to a Python object for pickling") + * raise TypeError, "self.arp 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("dnet.arp.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -10516,20 +15767,103 @@ static PyObject *__pyx_pf_4dnet_3arp_14__reduce_cython__(CYTHON_UNUSED struct __ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.arp cannot be converted to a Python object for pickling") + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.arp cannot be converted to a Python object for pickling") + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3arp_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_3arp_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_3arp_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_3arp_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_3arp_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_3arp_16__setstate_cython__(((struct __pyx_obj_4dnet_arp *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.arp.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_3arp_16__setstate_cython__(((struct __pyx_obj_4dnet_arp *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10537,33 +15871,28 @@ static PyObject *__pyx_pw_4dnet_3arp_17__setstate_cython__(PyObject *__pyx_v_sel static PyObject *__pyx_pf_4dnet_3arp_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_arp *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.arp cannot be converted to a Python object for pickling") + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.arp cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_arp_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.arp cannot be converted to a Python object for pickling") + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.arp cannot be converted to a Python object for pickling") + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.arp.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -10579,93 +15908,174 @@ static PyObject *__pyx_pf_4dnet_3arp_16__setstate_cython__(CYTHON_UNUSED struct * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): */ +static PyObject *__pyx_pf_4dnet_44__defaults__(CYTHON_UNUSED PyObject *__pyx_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("__defaults__", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_op); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_op); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_op)) __PYX_ERR(0, 771, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_sha); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_sha); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_sha)) __PYX_ERR(0, 771, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_spa); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_spa); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_spa)) __PYX_ERR(0, 771, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_dha); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_dha); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_dha)) __PYX_ERR(0, 771, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_dpa); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_dpa); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self)->__pyx_arg_dpa)) __PYX_ERR(0, 771, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(0, 771, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None)) __PYX_ERR(0, 771, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("dnet.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_29arp_pack_hdr_ethip(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_28arp_pack_hdr_ethip[] = "Return a packed binary string representing an Ethernet/IP ARP message.\n \n Keyword arguments:\n op -- operation (ARP_OP_*)\t\t\t(16-bit integer)\n sha -- sender Ethernet address\t\t(6-byte binary string)\n spa -- sender IP address\t\t\t(4-byte binary string)\n dha -- destination Ethernet address\t\t(6-byte binary string)\n dpa -- destination IP address\t\t(4-byte binary string)\n "; -static PyMethodDef __pyx_mdef_4dnet_29arp_pack_hdr_ethip = {"arp_pack_hdr_ethip", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_29arp_pack_hdr_ethip, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_28arp_pack_hdr_ethip}; -static PyObject *__pyx_pw_4dnet_29arp_pack_hdr_ethip(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_29arp_pack_hdr_ethip(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_28arp_pack_hdr_ethip, "Return a packed binary string representing an Ethernet/IP ARP message.\n \n Keyword arguments:\n op -- operation (ARP_OP_*)\t\t\t(16-bit integer)\n sha -- sender Ethernet address\t\t(6-byte binary string)\n spa -- sender IP address\t\t\t(4-byte binary string)\n dha -- destination Ethernet address\t\t(6-byte binary string)\n dpa -- destination IP address\t\t(4-byte binary string)\n "); +static PyMethodDef __pyx_mdef_4dnet_29arp_pack_hdr_ethip = {"arp_pack_hdr_ethip", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_29arp_pack_hdr_ethip, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_28arp_pack_hdr_ethip}; +static PyObject *__pyx_pw_4dnet_29arp_pack_hdr_ethip(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_op = 0; PyObject *__pyx_v_sha = 0; PyObject *__pyx_v_spa = 0; PyObject *__pyx_v_dha = 0; PyObject *__pyx_v_dpa = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("arp_pack_hdr_ethip (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_op,&__pyx_n_s_sha,&__pyx_n_s_spa,&__pyx_n_s_dha,&__pyx_n_s_dpa,0}; - PyObject* values[5] = {0,0,0,0,0}; - values[0] = __pyx_k__23; - values[1] = __pyx_k__24; - values[2] = __pyx_k__25; - values[3] = __pyx_k__26; - values[4] = __pyx_k__27; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_op,&__pyx_n_s_sha,&__pyx_n_s_spa,&__pyx_n_s_dha,&__pyx_n_s_dpa,0}; + __pyx_defaults3 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_self); + values[0] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_op); + values[1] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_sha); + values[2] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_spa); + values[3] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_dha); + values[4] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_dpa); + if (__pyx_kwds) { Py_ssize_t kw_args; - const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); - switch (pos_args) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_op); - if (value) { values[0] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_op); + if (value) { values[0] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 771, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sha); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sha); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 771, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_spa); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_spa); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 771, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dha); - if (value) { values[3] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dha); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 771, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dpa); - if (value) { values[4] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dpa); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 771, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "arp_pack_hdr_ethip") < 0)) __PYX_ERR(0, 771, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "arp_pack_hdr_ethip") < 0)) __PYX_ERR(0, 771, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + switch (__pyx_nargs) { + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; @@ -10677,10 +16087,18 @@ static PyObject *__pyx_pw_4dnet_29arp_pack_hdr_ethip(PyObject *__pyx_self, PyObj __pyx_v_dha = values[3]; __pyx_v_dpa = values[4]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("arp_pack_hdr_ethip", 0, 0, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 771, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("arp_pack_hdr_ethip", 0, 0, 5, __pyx_nargs); __PYX_ERR(0, 771, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.arp_pack_hdr_ethip", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -10688,6 +16106,12 @@ static PyObject *__pyx_pw_4dnet_29arp_pack_hdr_ethip(PyObject *__pyx_self, PyObj __pyx_r = __pyx_pf_4dnet_28arp_pack_hdr_ethip(__pyx_self, __pyx_v_op, __pyx_v_sha, __pyx_v_spa, __pyx_v_dha, __pyx_v_dpa); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10705,7 +16129,7 @@ static PyObject *__pyx_pf_4dnet_28arp_pack_hdr_ethip(CYTHON_UNUSED PyObject *__p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("arp_pack_hdr_ethip", 0); + __Pyx_RefNannySetupContext("arp_pack_hdr_ethip", 1); /* "dnet.pyx":786 * cdef eth_addr_t sh, dh @@ -10803,60 +16227,100 @@ static PyObject *__pyx_pf_4dnet_28arp_pack_hdr_ethip(CYTHON_UNUSED PyObject *__p */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_31icmp_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_30icmp_pack_hdr[] = "Return a packed binary string representing an ICMP header.\n\n Keyword arguments:\n itype -- ICMP type\t\t(8-bit integer)\n code -- ICMP code\t\t(8-bit integer)\n "; -static PyMethodDef __pyx_mdef_4dnet_31icmp_pack_hdr = {"icmp_pack_hdr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_31icmp_pack_hdr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_30icmp_pack_hdr}; -static PyObject *__pyx_pw_4dnet_31icmp_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_31icmp_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_30icmp_pack_hdr, "Return a packed binary string representing an ICMP header.\n\n Keyword arguments:\n itype -- ICMP type\t\t(8-bit integer)\n code -- ICMP code\t\t(8-bit integer)\n "); +static PyMethodDef __pyx_mdef_4dnet_31icmp_pack_hdr = {"icmp_pack_hdr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_31icmp_pack_hdr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_30icmp_pack_hdr}; +static PyObject *__pyx_pw_4dnet_31icmp_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_itype = 0; PyObject *__pyx_v_code = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("icmp_pack_hdr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_itype,&__pyx_n_s_code,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_itype,&__pyx_n_s_code,0}; + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itype)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_itype)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 799, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_code)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_code)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 799, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("icmp_pack_hdr", 1, 2, 2, 1); __PYX_ERR(0, 799, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "icmp_pack_hdr") < 0)) __PYX_ERR(0, 799, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "icmp_pack_hdr") < 0)) __PYX_ERR(0, 799, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_itype = values[0]; __pyx_v_code = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("icmp_pack_hdr", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 799, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("icmp_pack_hdr", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 799, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.icmp_pack_hdr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -10864,6 +16328,12 @@ static PyObject *__pyx_pw_4dnet_31icmp_pack_hdr(PyObject *__pyx_self, PyObject * __pyx_r = __pyx_pf_4dnet_30icmp_pack_hdr(__pyx_self, __pyx_v_itype, __pyx_v_code); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -10878,7 +16348,7 @@ static PyObject *__pyx_pf_4dnet_30icmp_pack_hdr(CYTHON_UNUSED PyObject *__pyx_se int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("icmp_pack_hdr", 0); + __Pyx_RefNannySetupContext("icmp_pack_hdr", 1); /* "dnet.pyx":807 * """ @@ -10932,112 +16402,201 @@ static PyObject *__pyx_pf_4dnet_30icmp_pack_hdr(CYTHON_UNUSED PyObject *__pyx_se * """Return a packed binary string representing a TCP header. */ -/* Python wrapper */ -static PyObject *__pyx_pw_4dnet_33tcp_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_32tcp_pack_hdr[] = "Return a packed binary string representing a TCP header.\n\n Keyword arguments:\n sport -- source port\t\t(16-bit integer)\n dport -- destination port\t\t(16-bit integer)\n seq -- sequence number\t\t(32-bit integer)\n ack -- acknowledgment number\t(32-bit integer)\n flags -- control flags (TH_*)\t(8-bit integer bitmask)\n win -- window size\t\t(16-bit integer)\n urp -- urgent pointer\t\t(16-bit integer)\n "; -static PyMethodDef __pyx_mdef_4dnet_33tcp_pack_hdr = {"tcp_pack_hdr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_33tcp_pack_hdr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_32tcp_pack_hdr}; -static PyObject *__pyx_pw_4dnet_33tcp_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { - PyObject *__pyx_v_sport = 0; - PyObject *__pyx_v_dport = 0; - PyObject *__pyx_v_seq = 0; - PyObject *__pyx_v_ack = 0; - PyObject *__pyx_v_flags = 0; - PyObject *__pyx_v_win = 0; - PyObject *__pyx_v_urp = 0; +static PyObject *__pyx_pf_4dnet_46__defaults__(CYTHON_UNUSED PyObject *__pyx_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; - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("tcp_pack_hdr (wrapper)", 0); - { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sport,&__pyx_n_s_dport,&__pyx_n_s_seq,&__pyx_n_s_ack,&__pyx_n_s_flags,&__pyx_n_s_win,&__pyx_n_s_urp,0}; - PyObject* values[7] = {0,0,0,0,0,0,0}; - values[2] = ((PyObject *)__pyx_int_1); - values[3] = ((PyObject *)__pyx_int_0); - values[4] = __pyx_k__28; - values[5] = __pyx_k__29; - values[6] = ((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 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + __Pyx_RefNannySetupContext("__defaults__", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)__pyx_int_1)); + __Pyx_GIVEREF(((PyObject *)__pyx_int_1)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_int_1))) __PYX_ERR(0, 859, __pyx_L1_error); + __Pyx_INCREF(((PyObject *)__pyx_int_0)); + __Pyx_GIVEREF(((PyObject *)__pyx_int_0)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_int_0))) __PYX_ERR(0, 859, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_self)->__pyx_arg_flags); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_self)->__pyx_arg_flags); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_self)->__pyx_arg_flags)) __PYX_ERR(0, 859, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_self)->__pyx_arg_win); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_self)->__pyx_arg_win); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_self)->__pyx_arg_win)) __PYX_ERR(0, 859, __pyx_L1_error); + __Pyx_INCREF(((PyObject *)__pyx_int_0)); + __Pyx_GIVEREF(((PyObject *)__pyx_int_0)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 4, ((PyObject *)__pyx_int_0))) __PYX_ERR(0, 859, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(0, 859, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None)) __PYX_ERR(0, 859, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("dnet.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4dnet_33tcp_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_32tcp_pack_hdr, "Return a packed binary string representing a TCP header.\n\n Keyword arguments:\n sport -- source port\t\t(16-bit integer)\n dport -- destination port\t\t(16-bit integer)\n seq -- sequence number\t\t(32-bit integer)\n ack -- acknowledgment number\t(32-bit integer)\n flags -- control flags (TH_*)\t(8-bit integer bitmask)\n win -- window size\t\t(16-bit integer)\n urp -- urgent pointer\t\t(16-bit integer)\n "); +static PyMethodDef __pyx_mdef_4dnet_33tcp_pack_hdr = {"tcp_pack_hdr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_33tcp_pack_hdr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_32tcp_pack_hdr}; +static PyObject *__pyx_pw_4dnet_33tcp_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_sport = 0; + PyObject *__pyx_v_dport = 0; + PyObject *__pyx_v_seq = 0; + PyObject *__pyx_v_ack = 0; + PyObject *__pyx_v_flags = 0; + PyObject *__pyx_v_win = 0; + PyObject *__pyx_v_urp = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[7] = {0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("tcp_pack_hdr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sport,&__pyx_n_s_dport,&__pyx_n_s_seq,&__pyx_n_s_ack,&__pyx_n_s_flags,&__pyx_n_s_win,&__pyx_n_s_urp,0}; + __pyx_defaults4 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_self); + values[2] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_1))); + values[3] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_0))); + values[4] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_flags); + values[5] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_win); + values[6] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)((PyObject *)__pyx_int_0))); + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); CYTHON_FALLTHROUGH; - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sport)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sport)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 859, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dport)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dport)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 859, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("tcp_pack_hdr", 0, 2, 7, 1); __PYX_ERR(0, 859, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_seq); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_seq); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 859, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 3: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ack); - if (value) { values[3] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ack); + if (value) { values[3] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 859, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 4: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags); - if (value) { values[4] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_flags); + if (value) { values[4] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 859, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 5: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_win); - if (value) { values[5] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_win); + if (value) { values[5] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 859, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 6: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_urp); - if (value) { values[6] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_urp); + if (value) { values[6] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 859, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "tcp_pack_hdr") < 0)) __PYX_ERR(0, 859, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "tcp_pack_hdr") < 0)) __PYX_ERR(0, 859, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 7: values[6] = PyTuple_GET_ITEM(__pyx_args, 6); + switch (__pyx_nargs) { + case 7: values[6] = __Pyx_Arg_FASTCALL(__pyx_args, 6); CYTHON_FALLTHROUGH; - case 6: values[5] = PyTuple_GET_ITEM(__pyx_args, 5); + case 6: values[5] = __Pyx_Arg_FASTCALL(__pyx_args, 5); CYTHON_FALLTHROUGH; - case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + case 5: values[4] = __Pyx_Arg_FASTCALL(__pyx_args, 4); CYTHON_FALLTHROUGH; - case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + case 4: values[3] = __Pyx_Arg_FASTCALL(__pyx_args, 3); CYTHON_FALLTHROUGH; - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -11050,10 +16609,18 @@ static PyObject *__pyx_pw_4dnet_33tcp_pack_hdr(PyObject *__pyx_self, PyObject *_ __pyx_v_win = values[5]; __pyx_v_urp = values[6]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("tcp_pack_hdr", 0, 2, 7, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 859, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("tcp_pack_hdr", 0, 2, 7, __pyx_nargs); __PYX_ERR(0, 859, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.tcp_pack_hdr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -11061,6 +16628,12 @@ static PyObject *__pyx_pw_4dnet_33tcp_pack_hdr(PyObject *__pyx_self, PyObject *_ __pyx_r = __pyx_pf_4dnet_32tcp_pack_hdr(__pyx_self, __pyx_v_sport, __pyx_v_dport, __pyx_v_seq, __pyx_v_ack, __pyx_v_flags, __pyx_v_win, __pyx_v_urp); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11080,7 +16653,7 @@ static PyObject *__pyx_pf_4dnet_32tcp_pack_hdr(CYTHON_UNUSED PyObject *__pyx_sel int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("tcp_pack_hdr", 0); + __Pyx_RefNannySetupContext("tcp_pack_hdr", 1); /* "dnet.pyx":873 * """ @@ -11139,64 +16712,137 @@ static PyObject *__pyx_pf_4dnet_32tcp_pack_hdr(CYTHON_UNUSED PyObject *__pyx_sel * */ +static PyObject *__pyx_pf_4dnet_48__defaults__(CYTHON_UNUSED PyObject *__pyx_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("__defaults__", 1); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(__pyx_defaults5, __pyx_self)->__pyx_arg_ulen); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(__pyx_defaults5, __pyx_self)->__pyx_arg_ulen); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __Pyx_CyFunction_Defaults(__pyx_defaults5, __pyx_self)->__pyx_arg_ulen)) __PYX_ERR(0, 885, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1)) __PYX_ERR(0, 885, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, Py_None)) __PYX_ERR(0, 885, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("dnet.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_35udp_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_34udp_pack_hdr[] = "Return a packed binary string representing a UDP header.\n\n Keyword arguments:\n sport -- source port\t\t(16-bit integer)\n dport -- destination port\t\t(16-bit integer)\n ulen -- UDP header + data length\t(16-bit integer)\n "; -static PyMethodDef __pyx_mdef_4dnet_35udp_pack_hdr = {"udp_pack_hdr", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_35udp_pack_hdr, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_34udp_pack_hdr}; -static PyObject *__pyx_pw_4dnet_35udp_pack_hdr(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_35udp_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_34udp_pack_hdr, "Return a packed binary string representing a UDP header.\n\n Keyword arguments:\n sport -- source port\t\t(16-bit integer)\n dport -- destination port\t\t(16-bit integer)\n ulen -- UDP header + data length\t(16-bit integer)\n "); +static PyMethodDef __pyx_mdef_4dnet_35udp_pack_hdr = {"udp_pack_hdr", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_35udp_pack_hdr, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_34udp_pack_hdr}; +static PyObject *__pyx_pw_4dnet_35udp_pack_hdr(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_sport = 0; PyObject *__pyx_v_dport = 0; PyObject *__pyx_v_ulen = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("udp_pack_hdr (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sport,&__pyx_n_s_dport,&__pyx_n_s_ulen,0}; - PyObject* values[3] = {0,0,0}; - values[2] = __pyx_k__30; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_sport,&__pyx_n_s_dport,&__pyx_n_s_ulen,0}; + __pyx_defaults5 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(__pyx_defaults5, __pyx_self); + values[2] = __Pyx_Arg_NewRef_FASTCALL(__pyx_dynamic_args->__pyx_arg_ulen); + if (__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); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_sport)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_sport)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 885, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dport)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dport)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 885, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("udp_pack_hdr", 0, 2, 3, 1); __PYX_ERR(0, 885, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_ulen); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_ulen); + if (value) { values[2] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 885, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "udp_pack_hdr") < 0)) __PYX_ERR(0, 885, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "udp_pack_hdr") < 0)) __PYX_ERR(0, 885, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -11205,10 +16851,18 @@ static PyObject *__pyx_pw_4dnet_35udp_pack_hdr(PyObject *__pyx_self, PyObject *_ __pyx_v_dport = values[1]; __pyx_v_ulen = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("udp_pack_hdr", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 885, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("udp_pack_hdr", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 885, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.udp_pack_hdr", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -11216,6 +16870,12 @@ static PyObject *__pyx_pw_4dnet_35udp_pack_hdr(PyObject *__pyx_self, PyObject *_ __pyx_r = __pyx_pf_4dnet_34udp_pack_hdr(__pyx_self, __pyx_v_sport, __pyx_v_dport, __pyx_v_ulen); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -11231,7 +16891,7 @@ static PyObject *__pyx_pf_4dnet_34udp_pack_hdr(CYTHON_UNUSED PyObject *__pyx_sel int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("udp_pack_hdr", 0); + __Pyx_RefNannySetupContext("udp_pack_hdr", 1); /* "dnet.pyx":894 * """ @@ -11301,7 +16961,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("ifent_to_dict", 0); + __Pyx_RefNannySetupContext("ifent_to_dict", 1); /* "dnet.pyx":937 * @@ -11324,7 +16984,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { */ __pyx_t_1 = __Pyx_PyObject_FromString(__pyx_v_entry->intf_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 938, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_name, __pyx_t_1) < 0)) __PYX_ERR(0, 938, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_name, __pyx_t_1) < 0))) __PYX_ERR(0, 938, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":939 @@ -11336,7 +16996,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { */ __pyx_t_1 = __Pyx_PyInt_From_unsigned_short(__pyx_v_entry->intf_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 939, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_type, __pyx_t_1) < 0)) __PYX_ERR(0, 939, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_type, __pyx_t_1) < 0))) __PYX_ERR(0, 939, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":940 @@ -11348,7 +17008,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { */ __pyx_t_1 = __Pyx_PyInt_From_unsigned_short(__pyx_v_entry->intf_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 940, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_flags, __pyx_t_1) < 0)) __PYX_ERR(0, 940, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_flags, __pyx_t_1) < 0))) __PYX_ERR(0, 940, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":941 @@ -11360,7 +17020,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { */ __pyx_t_1 = __Pyx_PyInt_From_unsigned_int(__pyx_v_entry->intf_mtu); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 941, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_mtu, __pyx_t_1) < 0)) __PYX_ERR(0, 941, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_mtu, __pyx_t_1) < 0))) __PYX_ERR(0, 941, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":942 @@ -11377,7 +17037,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { __pyx_t_3 = PyObject_RichCompare(__pyx_t_1, __pyx_t_2, Py_NE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 942, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 942, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 942, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; if (__pyx_t_4) { @@ -11393,7 +17053,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { __pyx_t_2 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4dnet_addr), __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 943, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_2); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_addr, __pyx_t_2) < 0)) __PYX_ERR(0, 943, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_addr, __pyx_t_2) < 0))) __PYX_ERR(0, 943, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; /* "dnet.pyx":942 @@ -11419,7 +17079,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { __pyx_t_1 = PyObject_RichCompare(__pyx_t_2, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 944, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 944, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 944, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_4) { @@ -11435,7 +17095,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4dnet_addr), __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 945, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_dst_addr, __pyx_t_3) < 0)) __PYX_ERR(0, 945, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_dst_addr, __pyx_t_3) < 0))) __PYX_ERR(0, 945, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "dnet.pyx":944 @@ -11461,7 +17121,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { __pyx_t_2 = PyObject_RichCompare(__pyx_t_3, __pyx_t_1, Py_NE); __Pyx_XGOTREF(__pyx_t_2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 946, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 946, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 946, __pyx_L1_error) __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; if (__pyx_t_4) { @@ -11477,7 +17137,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { __pyx_t_1 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4dnet_addr), __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 947, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_link_addr, __pyx_t_1) < 0)) __PYX_ERR(0, 947, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_link_addr, __pyx_t_1) < 0))) __PYX_ERR(0, 947, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":946 @@ -11496,7 +17156,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { * l = [] * for i from 0 <= i < entry.intf_alias_num: */ - __pyx_t_4 = ((__pyx_v_entry->intf_alias_num > 0) != 0); + __pyx_t_4 = (__pyx_v_entry->intf_alias_num > 0); if (__pyx_t_4) { /* "dnet.pyx":949 @@ -11544,7 +17204,7 @@ static PyObject *__pyx_f_4dnet_ifent_to_dict(struct intf_entry *__pyx_v_entry) { * return d * */ - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_alias_addrs, __pyx_v_l) < 0)) __PYX_ERR(0, 952, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_alias_addrs, __pyx_v_l) < 0))) __PYX_ERR(0, 952, __pyx_L1_error) /* "dnet.pyx":948 * if entry.intf_link_addr.addr_type != ADDR_TYPE_NONE: @@ -11606,16 +17266,15 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en PyObject *__pyx_t_1 = NULL; char *__pyx_t_2; int __pyx_t_3; - int __pyx_t_4; - unsigned short __pyx_t_5; - unsigned int __pyx_t_6; - struct addr __pyx_t_7; - Py_ssize_t __pyx_t_8; - PyObject *__pyx_t_9 = NULL; + unsigned short __pyx_t_4; + unsigned int __pyx_t_5; + struct addr __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("dict_to_ifent", 0); + __Pyx_RefNannySetupContext("dict_to_ifent", 1); /* "dnet.pyx":956 * @@ -11646,9 +17305,8 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en * entry.intf_flags = d['flags'] * if 'mtu' in d: */ - __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_flags, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 958, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_flags, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 958, __pyx_L1_error) + if (__pyx_t_3) { /* "dnet.pyx":959 * strlcpy(entry.intf_name, s, 16) @@ -11659,9 +17317,9 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 959, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyInt_As_unsigned_short(__pyx_t_1); if (unlikely((__pyx_t_5 == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(0, 959, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyInt_As_unsigned_short(__pyx_t_1); if (unlikely((__pyx_t_4 == (unsigned short)-1) && PyErr_Occurred())) __PYX_ERR(0, 959, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_entry->intf_flags = __pyx_t_5; + __pyx_v_entry->intf_flags = __pyx_t_4; /* "dnet.pyx":958 * s = d['name'] @@ -11679,8 +17337,7 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en * entry.intf_mtu = d['mtu'] * if 'addr' in d: */ - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_mtu, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 960, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_4 != 0); + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_mtu, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 960, __pyx_L1_error) if (__pyx_t_3) { /* "dnet.pyx":961 @@ -11692,9 +17349,9 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_mtu); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 961, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 961, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyInt_As_unsigned_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 961, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_entry->intf_mtu = __pyx_t_6; + __pyx_v_entry->intf_mtu = __pyx_t_5; /* "dnet.pyx":960 * if 'flags' in d: @@ -11712,9 +17369,8 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en * entry.intf_addr = (d['addr'])._addr * if 'dst_addr' in d: */ - __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_addr, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 962, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_addr, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 962, __pyx_L1_error) + if (__pyx_t_3) { /* "dnet.pyx":963 * entry.intf_mtu = d['mtu'] @@ -11725,9 +17381,9 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_addr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 963, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = ((struct __pyx_obj_4dnet_addr *)__pyx_t_1)->_addr; + __pyx_t_6 = ((struct __pyx_obj_4dnet_addr *)__pyx_t_1)->_addr; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_entry->intf_addr = __pyx_t_7; + __pyx_v_entry->intf_addr = __pyx_t_6; /* "dnet.pyx":962 * if 'mtu' in d: @@ -11745,8 +17401,7 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en * entry.intf_dst_addr = (d['dst_addr'])._addr * if 'link_addr' in d: */ - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_dst_addr, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 964, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_4 != 0); + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_dst_addr, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 964, __pyx_L1_error) if (__pyx_t_3) { /* "dnet.pyx":965 @@ -11758,9 +17413,9 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_dst_addr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 965, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = ((struct __pyx_obj_4dnet_addr *)__pyx_t_1)->_addr; + __pyx_t_6 = ((struct __pyx_obj_4dnet_addr *)__pyx_t_1)->_addr; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_entry->intf_dst_addr = __pyx_t_7; + __pyx_v_entry->intf_dst_addr = __pyx_t_6; /* "dnet.pyx":964 * if 'addr' in d: @@ -11778,9 +17433,8 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en * entry.intf_link_addr = (d['link_addr'])._addr * if 'alias_addrs' in d: */ - __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_link_addr, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_3 < 0)) __PYX_ERR(0, 966, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_3 != 0); - if (__pyx_t_4) { + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_link_addr, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 966, __pyx_L1_error) + if (__pyx_t_3) { /* "dnet.pyx":967 * entry.intf_dst_addr = (d['dst_addr'])._addr @@ -11791,9 +17445,9 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_link_addr); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 967, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_7 = ((struct __pyx_obj_4dnet_addr *)__pyx_t_1)->_addr; + __pyx_t_6 = ((struct __pyx_obj_4dnet_addr *)__pyx_t_1)->_addr; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_entry->intf_link_addr = __pyx_t_7; + __pyx_v_entry->intf_link_addr = __pyx_t_6; /* "dnet.pyx":966 * if 'dst_addr' in d: @@ -11811,8 +17465,7 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en * entry.intf_alias_num = len(d['alias_addrs']) * for i from 0 <= i < entry.intf_alias_num: */ - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_alias_addrs, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 968, __pyx_L1_error) - __pyx_t_3 = (__pyx_t_4 != 0); + __pyx_t_3 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_alias_addrs, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 968, __pyx_L1_error) if (__pyx_t_3) { /* "dnet.pyx":969 @@ -11824,9 +17477,9 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_alias_addrs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 969, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_8 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 969, __pyx_L1_error) + __pyx_t_7 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 969, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v_entry->intf_alias_num = __pyx_t_8; + __pyx_v_entry->intf_alias_num = __pyx_t_7; /* "dnet.pyx":970 * if 'alias_addrs' in d: @@ -11835,8 +17488,8 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en * entry.intf_alias_addrs[i] = (d['alias_addrs'][i])._addr * */ - __pyx_t_6 = __pyx_v_entry->intf_alias_num; - for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_6; __pyx_v_i++) { + __pyx_t_5 = __pyx_v_entry->intf_alias_num; + for (__pyx_v_i = 0; __pyx_v_i < __pyx_t_5; __pyx_v_i++) { /* "dnet.pyx":971 * entry.intf_alias_num = len(d['alias_addrs']) @@ -11847,12 +17500,12 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_alias_addrs); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 971, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_9 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 971, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_9); + __pyx_t_8 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_i, long, 1, __Pyx_PyInt_From_long, 0, 1, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_7 = ((struct __pyx_obj_4dnet_addr *)__pyx_t_9)->_addr; - __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; - (__pyx_v_entry->intf_alias_addrs[__pyx_v_i]) = __pyx_t_7; + __pyx_t_6 = ((struct __pyx_obj_4dnet_addr *)__pyx_t_8)->_addr; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + (__pyx_v_entry->intf_alias_addrs[__pyx_v_i]) = __pyx_t_6; } /* "dnet.pyx":968 @@ -11877,7 +17530,7 @@ static PyObject *__pyx_f_4dnet_dict_to_ifent(PyObject *__pyx_v_d, struct intf_en goto __pyx_L0; __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); - __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("dnet.dict_to_ifent", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -11907,13 +17560,12 @@ static int __pyx_f_4dnet___intf_callback(struct intf_entry *__pyx_v_entry, void PyObject *__pyx_t_4 = NULL; PyObject *(*__pyx_t_5)(PyObject *); int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; + int __pyx_t_7; int __pyx_t_8; - int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__intf_callback", 0); + __Pyx_RefNannySetupContext("__intf_callback", 1); /* "dnet.pyx":974 * @@ -11954,7 +17606,7 @@ static int __pyx_f_4dnet___intf_callback(struct intf_entry *__pyx_v_entry, void __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 974, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext; + __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; @@ -11987,7 +17639,8 @@ static int __pyx_f_4dnet___intf_callback(struct intf_entry *__pyx_v_entry, void __Pyx_INCREF(__pyx_v_f); __pyx_t_2 = __pyx_v_f; __pyx_t_4 = NULL; __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -11997,41 +17650,16 @@ static int __pyx_f_4dnet___intf_callback(struct intf_entry *__pyx_v_entry, void __pyx_t_6 = 1; } } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_a}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 975, __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_v_a}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 975, __pyx_L1_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_a}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); __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_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 975, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (__pyx_t_4) { - __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; - } - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); - __Pyx_INCREF(__pyx_v_a); - __Pyx_GIVEREF(__pyx_v_a); - PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_a); - __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 975, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 975, __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; } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_ret = __pyx_t_1; __pyx_t_1 = 0; @@ -12042,9 +17670,9 @@ static int __pyx_f_4dnet___intf_callback(struct intf_entry *__pyx_v_entry, void * ret = 0 * return ret */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_ret); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 976, __pyx_L1_error) - __pyx_t_9 = ((!__pyx_t_8) != 0); - if (__pyx_t_9) { + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_ret); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 976, __pyx_L1_error) + __pyx_t_8 = (!__pyx_t_7); + if (__pyx_t_8) { /* "dnet.pyx":977 * ret = f(ifent_to_dict(entry), a) @@ -12090,7 +17718,6 @@ static int __pyx_f_4dnet___intf_callback(struct intf_entry *__pyx_v_entry, void __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("dnet.__intf_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -12112,12 +17739,20 @@ static int __pyx_f_4dnet___intf_callback(struct intf_entry *__pyx_v_entry, void /* Python wrapper */ static int __pyx_pw_4dnet_4intf_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_4dnet_4intf_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_4dnet_4intf___init__(((struct __pyx_obj_4dnet_intf *)__pyx_v_self)); /* function exit code */ @@ -12133,7 +17768,7 @@ static int __pyx_pf_4dnet_4intf___init__(struct __pyx_obj_4dnet_intf *__pyx_v_se int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":988 * @@ -12151,7 +17786,7 @@ static int __pyx_pf_4dnet_4intf___init__(struct __pyx_obj_4dnet_intf *__pyx_v_se * raise OSError, __oserror() * */ - __pyx_t_1 = ((!(__pyx_v_self->intf != 0)) != 0); + __pyx_t_1 = (!(__pyx_v_self->intf != 0)); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":990 @@ -12205,15 +17840,98 @@ static int __pyx_pf_4dnet_4intf___init__(struct __pyx_obj_4dnet_intf *__pyx_v_se */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4intf_3get(PyObject *__pyx_v_self, PyObject *__pyx_v_name); /*proto*/ -static char __pyx_doc_4dnet_4intf_2get[] = "Return the configuration for a network interface as a dict.\n "; -static PyObject *__pyx_pw_4dnet_4intf_3get(PyObject *__pyx_v_self, PyObject *__pyx_v_name) { +static PyObject *__pyx_pw_4dnet_4intf_3get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4intf_2get, "Return the configuration for a network interface as a dict.\n "); +static PyMethodDef __pyx_mdef_4dnet_4intf_3get = {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_3get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_2get}; +static PyObject *__pyx_pw_4dnet_4intf_3get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4intf_2get(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), ((PyObject *)__pyx_v_name)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_name)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 992, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get") < 0)) __PYX_ERR(0, 992, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 992, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.intf.get", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4intf_2get(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), __pyx_v_name); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -12229,7 +17947,7 @@ static PyObject *__pyx_pf_4dnet_4intf_2get(struct __pyx_obj_4dnet_intf *__pyx_v_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get", 0); + __Pyx_RefNannySetupContext("get", 1); /* "dnet.pyx":997 * cdef intf_entry *ifent @@ -12266,7 +17984,7 @@ static PyObject *__pyx_pf_4dnet_4intf_2get(struct __pyx_obj_4dnet_intf *__pyx_v_ * raise OSError, __oserror() * return ifent_to_dict(ifent) */ - __pyx_t_2 = ((intf_get(__pyx_v_self->intf, __pyx_v_ifent) < 0) != 0); + __pyx_t_2 = (intf_get(__pyx_v_self->intf, __pyx_v_ifent) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":1001 @@ -12333,23 +18051,103 @@ static PyObject *__pyx_pf_4dnet_4intf_2get(struct __pyx_obj_4dnet_intf *__pyx_v_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4intf_5get_src(PyObject *__pyx_v_self, PyObject *__pyx_v_src); /*proto*/ -static char __pyx_doc_4dnet_4intf_4get_src[] = "Return the configuration for the interface whose primary address\n matches the specified source address.\n "; -static PyObject *__pyx_pw_4dnet_4intf_5get_src(PyObject *__pyx_v_self, PyObject *__pyx_v_src) { +static PyObject *__pyx_pw_4dnet_4intf_5get_src(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4intf_4get_src, "Return the configuration for the interface whose primary address\n matches the specified source address.\n "); +static PyMethodDef __pyx_mdef_4dnet_4intf_5get_src = {"get_src", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_5get_src, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_4get_src}; +static PyObject *__pyx_pw_4dnet_4intf_5get_src(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_4dnet_addr *__pyx_v_src = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_src (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_src,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_src)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1004, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_src") < 0)) __PYX_ERR(0, 1004, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_src = ((struct __pyx_obj_4dnet_addr *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_src", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1004, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.intf.get_src", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_src), __pyx_ptype_4dnet_addr, 1, "src", 0))) __PYX_ERR(0, 1004, __pyx_L1_error) - __pyx_r = __pyx_pf_4dnet_4intf_4get_src(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), ((struct __pyx_obj_4dnet_addr *)__pyx_v_src)); + __pyx_r = __pyx_pf_4dnet_4intf_4get_src(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), __pyx_v_src); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -12364,7 +18162,7 @@ static PyObject *__pyx_pf_4dnet_4intf_4get_src(struct __pyx_obj_4dnet_intf *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_src", 0); + __Pyx_RefNannySetupContext("get_src", 1); /* "dnet.pyx":1010 * cdef intf_entry *ifent @@ -12391,7 +18189,7 @@ static PyObject *__pyx_pf_4dnet_4intf_4get_src(struct __pyx_obj_4dnet_intf *__py * raise OSError, __oserror() * return ifent_to_dict(ifent) */ - __pyx_t_1 = ((intf_get_src(__pyx_v_self->intf, __pyx_v_ifent, (&__pyx_v_src->_addr)) < 0) != 0); + __pyx_t_1 = (intf_get_src(__pyx_v_self->intf, __pyx_v_ifent, (&__pyx_v_src->_addr)) < 0); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":1013 @@ -12458,23 +18256,103 @@ static PyObject *__pyx_pf_4dnet_4intf_4get_src(struct __pyx_obj_4dnet_intf *__py */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4intf_7get_dst(PyObject *__pyx_v_self, PyObject *__pyx_v_dst); /*proto*/ -static char __pyx_doc_4dnet_4intf_6get_dst[] = "Return the configuration for the best interface with which to\n reach the specified dst address.\n "; -static PyObject *__pyx_pw_4dnet_4intf_7get_dst(PyObject *__pyx_v_self, PyObject *__pyx_v_dst) { +static PyObject *__pyx_pw_4dnet_4intf_7get_dst(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4intf_6get_dst, "Return the configuration for the best interface with which to\n reach the specified dst address.\n "); +static PyMethodDef __pyx_mdef_4dnet_4intf_7get_dst = {"get_dst", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_7get_dst, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_6get_dst}; +static PyObject *__pyx_pw_4dnet_4intf_7get_dst(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_4dnet_addr *__pyx_v_dst = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get_dst (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dst,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dst)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1016, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get_dst") < 0)) __PYX_ERR(0, 1016, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_dst = ((struct __pyx_obj_4dnet_addr *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_dst", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1016, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.intf.get_dst", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dst), __pyx_ptype_4dnet_addr, 1, "dst", 0))) __PYX_ERR(0, 1016, __pyx_L1_error) - __pyx_r = __pyx_pf_4dnet_4intf_6get_dst(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), ((struct __pyx_obj_4dnet_addr *)__pyx_v_dst)); + __pyx_r = __pyx_pf_4dnet_4intf_6get_dst(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), __pyx_v_dst); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -12489,7 +18367,7 @@ static PyObject *__pyx_pf_4dnet_4intf_6get_dst(struct __pyx_obj_4dnet_intf *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get_dst", 0); + __Pyx_RefNannySetupContext("get_dst", 1); /* "dnet.pyx":1022 * cdef intf_entry *ifent @@ -12516,7 +18394,7 @@ static PyObject *__pyx_pf_4dnet_4intf_6get_dst(struct __pyx_obj_4dnet_intf *__py * raise OSError, __oserror() * return ifent_to_dict(ifent) */ - __pyx_t_1 = ((intf_get_dst(__pyx_v_self->intf, __pyx_v_ifent, (&__pyx_v_dst->_addr)) < 0) != 0); + __pyx_t_1 = (intf_get_dst(__pyx_v_self->intf, __pyx_v_ifent, (&__pyx_v_dst->_addr)) < 0); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":1025 @@ -12583,15 +18461,98 @@ static PyObject *__pyx_pf_4dnet_4intf_6get_dst(struct __pyx_obj_4dnet_intf *__py */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4intf_9set(PyObject *__pyx_v_self, PyObject *__pyx_v_d); /*proto*/ -static char __pyx_doc_4dnet_4intf_8set[] = "Set the configuration for an interface from a dict.\n\n Dict values:\n name -- name of interface to set\t\t(string)\n flags -- interface flags (INTF_FLAG_*)\t(integer bitmask)\n mtu -- interface MTU\t\t\t(integer)\n addr -- primary network address\t\t(addr object)\n dst_addr -- point-to-point dst address\t(addr object)\n link_addr -- link-layer address\t\t(addr object)\n alias_addrs -- additional network addresses\t(list of addr objects)\n "; -static PyObject *__pyx_pw_4dnet_4intf_9set(PyObject *__pyx_v_self, PyObject *__pyx_v_d) { - PyObject *__pyx_r = 0; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("set (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4intf_8set(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), ((PyObject *)__pyx_v_d)); - +static PyObject *__pyx_pw_4dnet_4intf_9set(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4intf_8set, "Set the configuration for an interface from a dict.\n\n Dict values:\n name -- name of interface to set\t\t(string)\n flags -- interface flags (INTF_FLAG_*)\t(integer bitmask)\n mtu -- interface MTU\t\t\t(integer)\n addr -- primary network address\t\t(addr object)\n dst_addr -- point-to-point dst address\t(addr object)\n link_addr -- link-layer address\t\t(addr object)\n alias_addrs -- additional network addresses\t(list of addr objects)\n "); +static PyMethodDef __pyx_mdef_4dnet_4intf_9set = {"set", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_9set, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_8set}; +static PyObject *__pyx_pw_4dnet_4intf_9set(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_d = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("set (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_d,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_d)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1028, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set") < 0)) __PYX_ERR(0, 1028, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_d = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1028, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.intf.set", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4intf_8set(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), __pyx_v_d); + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -12606,7 +18567,7 @@ static PyObject *__pyx_pf_4dnet_4intf_8set(struct __pyx_obj_4dnet_intf *__pyx_v_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set", 0); + __Pyx_RefNannySetupContext("set", 1); /* "dnet.pyx":1042 * cdef intf_entry *ifent @@ -12653,7 +18614,7 @@ static PyObject *__pyx_pf_4dnet_4intf_8set(struct __pyx_obj_4dnet_intf *__pyx_v_ * raise OSError, __oserror() * */ - __pyx_t_2 = ((intf_set(__pyx_v_self->intf, __pyx_v_ifent) < 0) != 0); + __pyx_t_2 = (intf_set(__pyx_v_self->intf, __pyx_v_ifent) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":1047 @@ -12708,52 +18669,82 @@ static PyObject *__pyx_pf_4dnet_4intf_8set(struct __pyx_obj_4dnet_intf *__pyx_v_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4intf_11loop(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_4intf_10loop[] = "Iterate over the system interface table, invoking a user callback\n with each entry, returning the status of the callback routine.\n\n Keyword arguments:\n callback -- callback function with (dict, arg) prototype.\n If this function returns a non-zero value, the loop\n will break early.\n arg -- optional callback argument\n "; -static PyObject *__pyx_pw_4dnet_4intf_11loop(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_4intf_11loop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4intf_10loop, "Iterate over the system interface table, invoking a user callback\n with each entry, returning the status of the callback routine.\n\n Keyword arguments:\n callback -- callback function with (dict, arg) prototype.\n If this function returns a non-zero value, the loop\n will break early.\n arg -- optional callback argument\n "); +static PyMethodDef __pyx_mdef_4dnet_4intf_11loop = {"loop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_11loop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_10loop}; +static PyObject *__pyx_pw_4dnet_4intf_11loop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_callback = 0; PyObject *__pyx_v_arg = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("loop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_arg,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_arg,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_callback)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1049, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_arg); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1049, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "loop") < 0)) __PYX_ERR(0, 1049, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "loop") < 0)) __PYX_ERR(0, 1049, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -12761,10 +18752,18 @@ static PyObject *__pyx_pw_4dnet_4intf_11loop(PyObject *__pyx_v_self, PyObject *_ __pyx_v_callback = values[0]; __pyx_v_arg = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("loop", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1049, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("loop", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1049, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.intf.loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -12772,6 +18771,12 @@ static PyObject *__pyx_pw_4dnet_4intf_11loop(PyObject *__pyx_v_self, PyObject *_ __pyx_r = __pyx_pf_4dnet_4intf_10loop(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), __pyx_v_callback, __pyx_v_arg); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -12784,7 +18789,7 @@ static PyObject *__pyx_pf_4dnet_4intf_10loop(struct __pyx_obj_4dnet_intf *__pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("loop", 0); + __Pyx_RefNannySetupContext("loop", 1); /* "dnet.pyx":1059 * arg -- optional callback argument @@ -12797,10 +18802,10 @@ static PyObject *__pyx_pf_4dnet_4intf_10loop(struct __pyx_obj_4dnet_intf *__pyx_ __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_callback); __Pyx_GIVEREF(__pyx_v_callback); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_callback); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_callback)) __PYX_ERR(0, 1059, __pyx_L1_error); __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg)) __PYX_ERR(0, 1059, __pyx_L1_error); __pyx_v__arg = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; @@ -12849,9 +18854,11 @@ static PyObject *__pyx_pf_4dnet_4intf_10loop(struct __pyx_obj_4dnet_intf *__pyx_ /* Python wrapper */ static PyObject *__pyx_pw_4dnet_4intf_13__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_4intf_13__iter__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_4intf_12__iter__(((struct __pyx_obj_4dnet_intf *)__pyx_v_self)); /* function exit code */ @@ -12868,11 +18875,10 @@ static PyObject *__pyx_pf_4dnet_4intf_12__iter__(struct __pyx_obj_4dnet_intf *__ 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("__iter__", 0); + __Pyx_RefNannySetupContext("__iter__", 1); /* "dnet.pyx":1063 * @@ -12899,7 +18905,8 @@ static PyObject *__pyx_pf_4dnet_4intf_12__iter__(struct __pyx_obj_4dnet_intf *__ __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -12909,41 +18916,16 @@ static PyObject *__pyx_pf_4dnet_4intf_12__iter__(struct __pyx_obj_4dnet_intf *__ __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_v_l}; - __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(0, 1064, __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_v_l}; - __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(0, 1064, __pyx_L1_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_l}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); __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(0, 1064, __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_v_l); - __Pyx_GIVEREF(__pyx_v_l); - PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_l); - __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1064, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1064, __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_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":1065 @@ -12974,7 +18956,6 @@ static PyObject *__pyx_pf_4dnet_4intf_12__iter__(struct __pyx_obj_4dnet_intf *__ __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("dnet.intf.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -12995,8 +18976,10 @@ static PyObject *__pyx_pf_4dnet_4intf_12__iter__(struct __pyx_obj_4dnet_intf *__ /* Python wrapper */ static void __pyx_pw_4dnet_4intf_15__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_4dnet_4intf_15__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_4dnet_4intf_14__dealloc__(((struct __pyx_obj_4dnet_intf *)__pyx_v_self)); /* function exit code */ @@ -13004,9 +18987,7 @@ static void __pyx_pw_4dnet_4intf_15__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_4dnet_4intf_14__dealloc__(struct __pyx_obj_4dnet_intf *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "dnet.pyx":1068 * @@ -13045,21 +19026,48 @@ static void __pyx_pf_4dnet_4intf_14__dealloc__(struct __pyx_obj_4dnet_intf *__py */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.intf cannot be converted to a Python object for pickling") + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4intf_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_4intf_17__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4intf_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_4intf_17__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_4intf_17__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4intf_16__reduce_cython__(((struct __pyx_obj_4dnet_intf *)__pyx_v_self)); /* function exit code */ @@ -13070,33 +19078,28 @@ static PyObject *__pyx_pw_4dnet_4intf_17__reduce_cython__(PyObject *__pyx_v_self static PyObject *__pyx_pf_4dnet_4intf_16__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_intf *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.intf cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.intf cannot be converted to a Python object for pickling") + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__31, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_intf_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.intf cannot be converted to a Python object for pickling") + * raise TypeError, "self.intf 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("dnet.intf.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -13106,20 +19109,103 @@ static PyObject *__pyx_pf_4dnet_4intf_16__reduce_cython__(CYTHON_UNUSED struct _ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.intf cannot be converted to a Python object for pickling") + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.intf cannot be converted to a Python object for pickling") + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4intf_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_4intf_19__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_4intf_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_4intf_19__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_4intf_19__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4intf_18__setstate_cython__(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.intf.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4intf_18__setstate_cython__(((struct __pyx_obj_4dnet_intf *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -13127,33 +19213,28 @@ static PyObject *__pyx_pw_4dnet_4intf_19__setstate_cython__(PyObject *__pyx_v_se static PyObject *__pyx_pf_4dnet_4intf_18__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_intf *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.intf cannot be converted to a Python object for pickling") + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.intf cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__32, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_intf_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.intf cannot be converted to a Python object for pickling") + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.intf cannot be converted to a Python object for pickling") + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.intf.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -13184,13 +19265,12 @@ static int __pyx_f_4dnet___route_callback(struct route_entry *__pyx_v_entry, voi PyObject *(*__pyx_t_5)(PyObject *); struct addr __pyx_t_6; int __pyx_t_7; - PyObject *__pyx_t_8 = NULL; + int __pyx_t_8; int __pyx_t_9; - int __pyx_t_10; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__route_callback", 0); + __Pyx_RefNannySetupContext("__route_callback", 1); /* "dnet.pyx":1090 * @@ -13231,7 +19311,7 @@ static int __pyx_f_4dnet___route_callback(struct route_entry *__pyx_v_entry, voi __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1090, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext; + __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; @@ -13297,16 +19377,17 @@ static int __pyx_f_4dnet___route_callback(struct route_entry *__pyx_v_entry, voi */ __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1094, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)__pyx_v_dst)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_dst)); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_dst)); - __Pyx_INCREF(((PyObject *)__pyx_v_gw)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_gw)); - PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_gw)); + __Pyx_INCREF((PyObject *)__pyx_v_dst); + __Pyx_GIVEREF((PyObject *)__pyx_v_dst); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_dst))) __PYX_ERR(0, 1094, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_gw); + __Pyx_GIVEREF((PyObject *)__pyx_v_gw); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, ((PyObject *)__pyx_v_gw))) __PYX_ERR(0, 1094, __pyx_L1_error); __Pyx_INCREF(__pyx_v_f); __pyx_t_2 = __pyx_v_f; __pyx_t_4 = NULL; __pyx_t_7 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -13316,41 +19397,16 @@ static int __pyx_f_4dnet___route_callback(struct route_entry *__pyx_v_entry, voi __pyx_t_7 = 1; } } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_a}; - __pyx_t_3 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1094, __pyx_L1_error) - __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_a}; - __pyx_t_3 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1094, __pyx_L1_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_1, __pyx_v_a}; + __pyx_t_3 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_7, 2+__pyx_t_7); __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; - __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - } else - #endif - { - __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1094, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - if (__pyx_t_4) { - __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_4); __pyx_t_4 = NULL; - } - __Pyx_GIVEREF(__pyx_t_1); - PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); - __Pyx_INCREF(__pyx_v_a); - __Pyx_GIVEREF(__pyx_v_a); - PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_a); - __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1094, __pyx_L1_error) + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1094, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_ret = __pyx_t_3; __pyx_t_3 = 0; @@ -13361,9 +19417,9 @@ static int __pyx_f_4dnet___route_callback(struct route_entry *__pyx_v_entry, voi * ret = 0 * return ret */ - __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v_ret); if (unlikely(__pyx_t_9 < 0)) __PYX_ERR(0, 1095, __pyx_L1_error) - __pyx_t_10 = ((!__pyx_t_9) != 0); - if (__pyx_t_10) { + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_ret); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 1095, __pyx_L1_error) + __pyx_t_9 = (!__pyx_t_8); + if (__pyx_t_9) { /* "dnet.pyx":1096 * ret = f((dst, gw), a) @@ -13409,7 +19465,6 @@ static int __pyx_f_4dnet___route_callback(struct route_entry *__pyx_v_entry, voi __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("dnet.__route_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -13433,12 +19488,20 @@ static int __pyx_f_4dnet___route_callback(struct route_entry *__pyx_v_entry, voi /* Python wrapper */ static int __pyx_pw_4dnet_5route_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_4dnet_5route_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_4dnet_5route___init__(((struct __pyx_obj_4dnet_route *)__pyx_v_self)); /* function exit code */ @@ -13454,7 +19517,7 @@ static int __pyx_pf_4dnet_5route___init__(struct __pyx_obj_4dnet_route *__pyx_v_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":1107 * @@ -13472,7 +19535,7 @@ static int __pyx_pf_4dnet_5route___init__(struct __pyx_obj_4dnet_route *__pyx_v_ * raise OSError, __oserror() * */ - __pyx_t_1 = ((!(__pyx_v_self->route != 0)) != 0); + __pyx_t_1 = (!(__pyx_v_self->route != 0)); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":1109 @@ -13526,59 +19589,100 @@ static int __pyx_pf_4dnet_5route___init__(struct __pyx_obj_4dnet_route *__pyx_v_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_5route_3add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_5route_2add[] = "Add an entry to the system routing table.\n\n Arguments:\n dst -- ADDR_TYPE_IP network address object\n gw -- ADDR_TYPE_IP network address object\n "; -static PyObject *__pyx_pw_4dnet_5route_3add(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_5route_3add(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_5route_2add, "Add an entry to the system routing table.\n\n Arguments:\n dst -- ADDR_TYPE_IP network address object\n gw -- ADDR_TYPE_IP network address object\n "); +static PyMethodDef __pyx_mdef_4dnet_5route_3add = {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_3add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_5route_2add}; +static PyObject *__pyx_pw_4dnet_5route_3add(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { struct __pyx_obj_4dnet_addr *__pyx_v_dst = 0; struct __pyx_obj_4dnet_addr *__pyx_v_gw = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dst,&__pyx_n_s_gw,0}; - PyObject* values[2] = {0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dst,&__pyx_n_s_gw,0}; + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dst)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dst)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1111, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_gw)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_gw)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1111, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, 1); __PYX_ERR(0, 1111, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "add") < 0)) __PYX_ERR(0, 1111, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add") < 0)) __PYX_ERR(0, 1111, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + } else if (unlikely(__pyx_nargs != 2)) { goto __pyx_L5_argtuple_error; } else { - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); - values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); } __pyx_v_dst = ((struct __pyx_obj_4dnet_addr *)values[0]); __pyx_v_gw = ((struct __pyx_obj_4dnet_addr *)values[1]); } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1111, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("add", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 1111, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.route.add", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -13592,6 +19696,12 @@ static PyObject *__pyx_pw_4dnet_5route_3add(PyObject *__pyx_v_self, PyObject *__ __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -13606,7 +19716,7 @@ static PyObject *__pyx_pf_4dnet_5route_2add(struct __pyx_obj_4dnet_route *__pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("add", 0); + __Pyx_RefNannySetupContext("add", 1); /* "dnet.pyx":1119 * """ @@ -13635,7 +19745,7 @@ static PyObject *__pyx_pf_4dnet_5route_2add(struct __pyx_obj_4dnet_route *__pyx_ * raise OSError, __oserror() * */ - __pyx_t_2 = ((route_add(__pyx_v_self->route, (&__pyx_v_entry)) < 0) != 0); + __pyx_t_2 = (route_add(__pyx_v_self->route, (&__pyx_v_entry)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":1122 @@ -13690,23 +19800,103 @@ static PyObject *__pyx_pf_4dnet_5route_2add(struct __pyx_obj_4dnet_route *__pyx_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_5route_5delete(PyObject *__pyx_v_self, PyObject *__pyx_v_dst); /*proto*/ -static char __pyx_doc_4dnet_5route_4delete[] = "Delete an entry from the system routing table.\n\n Arguments:\n dst -- ADDR_TYPE_IP network address object\n "; -static PyObject *__pyx_pw_4dnet_5route_5delete(PyObject *__pyx_v_self, PyObject *__pyx_v_dst) { +static PyObject *__pyx_pw_4dnet_5route_5delete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_5route_4delete, "Delete an entry from the system routing table.\n\n Arguments:\n dst -- ADDR_TYPE_IP network address object\n "); +static PyMethodDef __pyx_mdef_4dnet_5route_5delete = {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_5delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_5route_4delete}; +static PyObject *__pyx_pw_4dnet_5route_5delete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_4dnet_addr *__pyx_v_dst = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("delete (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dst,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dst)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1124, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delete") < 0)) __PYX_ERR(0, 1124, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_dst = ((struct __pyx_obj_4dnet_addr *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delete", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1124, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.route.delete", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dst), __pyx_ptype_4dnet_addr, 1, "dst", 0))) __PYX_ERR(0, 1124, __pyx_L1_error) - __pyx_r = __pyx_pf_4dnet_5route_4delete(((struct __pyx_obj_4dnet_route *)__pyx_v_self), ((struct __pyx_obj_4dnet_addr *)__pyx_v_dst)); + __pyx_r = __pyx_pf_4dnet_5route_4delete(((struct __pyx_obj_4dnet_route *)__pyx_v_self), __pyx_v_dst); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -13721,7 +19911,7 @@ static PyObject *__pyx_pf_4dnet_5route_4delete(struct __pyx_obj_4dnet_route *__p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("delete", 0); + __Pyx_RefNannySetupContext("delete", 1); /* "dnet.pyx":1131 * """ @@ -13740,7 +19930,7 @@ static PyObject *__pyx_pf_4dnet_5route_4delete(struct __pyx_obj_4dnet_route *__p * raise OSError, __oserror() * */ - __pyx_t_2 = ((route_delete(__pyx_v_self->route, (&__pyx_v_entry)) < 0) != 0); + __pyx_t_2 = (route_delete(__pyx_v_self->route, (&__pyx_v_entry)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":1133 @@ -13795,23 +19985,103 @@ static PyObject *__pyx_pf_4dnet_5route_4delete(struct __pyx_obj_4dnet_route *__p */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_5route_7get(PyObject *__pyx_v_self, PyObject *__pyx_v_dst); /*proto*/ -static char __pyx_doc_4dnet_5route_6get[] = "Return the hardware address for a given protocol address\n in the system routing table.\n\n Arguments:\n dst -- ADDR_TYPE_IP network address object\n "; -static PyObject *__pyx_pw_4dnet_5route_7get(PyObject *__pyx_v_self, PyObject *__pyx_v_dst) { +static PyObject *__pyx_pw_4dnet_5route_7get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_5route_6get, "Return the hardware address for a given protocol address\n in the system routing table.\n\n Arguments:\n dst -- ADDR_TYPE_IP network address object\n "); +static PyMethodDef __pyx_mdef_4dnet_5route_7get = {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_7get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_5route_6get}; +static PyObject *__pyx_pw_4dnet_5route_7get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_4dnet_addr *__pyx_v_dst = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_dst,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dst)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1135, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get") < 0)) __PYX_ERR(0, 1135, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_dst = ((struct __pyx_obj_4dnet_addr *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1135, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.route.get", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_dst), __pyx_ptype_4dnet_addr, 1, "dst", 0))) __PYX_ERR(0, 1135, __pyx_L1_error) - __pyx_r = __pyx_pf_4dnet_5route_6get(((struct __pyx_obj_4dnet_route *)__pyx_v_self), ((struct __pyx_obj_4dnet_addr *)__pyx_v_dst)); + __pyx_r = __pyx_pf_4dnet_5route_6get(((struct __pyx_obj_4dnet_route *)__pyx_v_self), __pyx_v_dst); /* function exit code */ goto __pyx_L0; __pyx_L1_error:; __pyx_r = NULL; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -13827,7 +20097,7 @@ static PyObject *__pyx_pf_4dnet_5route_6get(struct __pyx_obj_4dnet_route *__pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get", 0); + __Pyx_RefNannySetupContext("get", 1); /* "dnet.pyx":1143 * """ @@ -13846,7 +20116,7 @@ static PyObject *__pyx_pf_4dnet_5route_6get(struct __pyx_obj_4dnet_route *__pyx_ * return addr(addr_ntoa(&entry.route_gw)) * return None */ - __pyx_t_2 = ((route_get(__pyx_v_self->route, (&__pyx_v_entry)) == 0) != 0); + __pyx_t_2 = (route_get(__pyx_v_self->route, (&__pyx_v_entry)) == 0); if (__pyx_t_2) { /* "dnet.pyx":1145 @@ -13915,52 +20185,82 @@ static PyObject *__pyx_pf_4dnet_5route_6get(struct __pyx_obj_4dnet_route *__pyx_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_5route_9loop(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_5route_8loop[] = "Iterate over the system routing table, invoking a user callback\n with each entry, returning the status of the callback routine.\n\n Keyword arguments:\n callback -- callback function with ((dst, gw), arg) prototype.\n If this function returns a non-zero value, the loop\n will break early.\n arg -- optional callback argument\n "; -static PyObject *__pyx_pw_4dnet_5route_9loop(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_5route_9loop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_5route_8loop, "Iterate over the system routing table, invoking a user callback\n with each entry, returning the status of the callback routine.\n\n Keyword arguments:\n callback -- callback function with ((dst, gw), arg) prototype.\n If this function returns a non-zero value, the loop\n will break early.\n arg -- optional callback argument\n "); +static PyMethodDef __pyx_mdef_4dnet_5route_9loop = {"loop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_9loop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_5route_8loop}; +static PyObject *__pyx_pw_4dnet_5route_9loop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_callback = 0; PyObject *__pyx_v_arg = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("loop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_arg,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_arg,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_callback)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1148, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_arg); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1148, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "loop") < 0)) __PYX_ERR(0, 1148, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "loop") < 0)) __PYX_ERR(0, 1148, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -13968,10 +20268,18 @@ static PyObject *__pyx_pw_4dnet_5route_9loop(PyObject *__pyx_v_self, PyObject *_ __pyx_v_callback = values[0]; __pyx_v_arg = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("loop", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1148, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("loop", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1148, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.route.loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -13979,6 +20287,12 @@ static PyObject *__pyx_pw_4dnet_5route_9loop(PyObject *__pyx_v_self, PyObject *_ __pyx_r = __pyx_pf_4dnet_5route_8loop(((struct __pyx_obj_4dnet_route *)__pyx_v_self), __pyx_v_callback, __pyx_v_arg); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -13991,7 +20305,7 @@ static PyObject *__pyx_pf_4dnet_5route_8loop(struct __pyx_obj_4dnet_route *__pyx int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("loop", 0); + __Pyx_RefNannySetupContext("loop", 1); /* "dnet.pyx":1158 * arg -- optional callback argument @@ -14004,10 +20318,10 @@ static PyObject *__pyx_pf_4dnet_5route_8loop(struct __pyx_obj_4dnet_route *__pyx __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_callback); __Pyx_GIVEREF(__pyx_v_callback); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_callback); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_callback)) __PYX_ERR(0, 1158, __pyx_L1_error); __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg)) __PYX_ERR(0, 1158, __pyx_L1_error); __pyx_v__arg = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; @@ -14056,9 +20370,11 @@ static PyObject *__pyx_pf_4dnet_5route_8loop(struct __pyx_obj_4dnet_route *__pyx /* Python wrapper */ static PyObject *__pyx_pw_4dnet_5route_11__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_5route_11__iter__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_5route_10__iter__(((struct __pyx_obj_4dnet_route *)__pyx_v_self)); /* function exit code */ @@ -14075,11 +20391,10 @@ static PyObject *__pyx_pf_4dnet_5route_10__iter__(struct __pyx_obj_4dnet_route * 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("__iter__", 0); + __Pyx_RefNannySetupContext("__iter__", 1); /* "dnet.pyx":1162 * @@ -14106,7 +20421,8 @@ static PyObject *__pyx_pf_4dnet_5route_10__iter__(struct __pyx_obj_4dnet_route * __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -14116,41 +20432,16 @@ static PyObject *__pyx_pf_4dnet_5route_10__iter__(struct __pyx_obj_4dnet_route * __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_v_l}; - __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(0, 1163, __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_v_l}; - __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(0, 1163, __pyx_L1_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_l}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); __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(0, 1163, __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_v_l); - __Pyx_GIVEREF(__pyx_v_l); - PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_l); - __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1163, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1163, __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_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":1164 @@ -14181,7 +20472,6 @@ static PyObject *__pyx_pf_4dnet_5route_10__iter__(struct __pyx_obj_4dnet_route * __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("dnet.route.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -14202,8 +20492,10 @@ static PyObject *__pyx_pf_4dnet_5route_10__iter__(struct __pyx_obj_4dnet_route * /* Python wrapper */ static void __pyx_pw_4dnet_5route_13__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_4dnet_5route_13__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_4dnet_5route_12__dealloc__(((struct __pyx_obj_4dnet_route *)__pyx_v_self)); /* function exit code */ @@ -14211,9 +20503,7 @@ static void __pyx_pw_4dnet_5route_13__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_4dnet_5route_12__dealloc__(struct __pyx_obj_4dnet_route *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "dnet.pyx":1167 * @@ -14252,21 +20542,48 @@ static void __pyx_pf_4dnet_5route_12__dealloc__(struct __pyx_obj_4dnet_route *__ */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.route cannot be converted to a Python object for pickling") + * raise TypeError, "self.route cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_5route_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_5route_15__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_5route_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_5route_15__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_5route_15__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_5route_14__reduce_cython__(((struct __pyx_obj_4dnet_route *)__pyx_v_self)); /* function exit code */ @@ -14277,33 +20594,28 @@ static PyObject *__pyx_pw_4dnet_5route_15__reduce_cython__(PyObject *__pyx_v_sel static PyObject *__pyx_pf_4dnet_5route_14__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_route *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.route cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.route cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.route cannot be converted to a Python object for pickling") + * raise TypeError, "self.route cannot be converted to a Python object for pickling" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__33, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_route_cannot_be_converted_t, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.route cannot be converted to a Python object for pickling") + * raise TypeError, "self.route 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("dnet.route.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -14313,20 +20625,103 @@ static PyObject *__pyx_pf_4dnet_5route_14__reduce_cython__(CYTHON_UNUSED struct /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.route cannot be converted to a Python object for pickling") + * raise TypeError, "self.route cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.route cannot be converted to a Python object for pickling") + * raise TypeError, "self.route cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_5route_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_5route_17__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_5route_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_5route_17__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_5route_17__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_5route_16__setstate_cython__(((struct __pyx_obj_4dnet_route *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.route.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_5route_16__setstate_cython__(((struct __pyx_obj_4dnet_route *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -14334,33 +20729,28 @@ static PyObject *__pyx_pw_4dnet_5route_17__setstate_cython__(PyObject *__pyx_v_s static PyObject *__pyx_pf_4dnet_5route_16__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_route *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.route cannot be converted to a Python object for pickling") + * raise TypeError, "self.route cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.route cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.route cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__34, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_route_cannot_be_converted_t, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.route cannot be converted to a Python object for pickling") + * raise TypeError, "self.route cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.route cannot be converted to a Python object for pickling") + * raise TypeError, "self.route cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.route.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -14388,7 +20778,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("rule_to_dict", 0); + __Pyx_RefNannySetupContext("rule_to_dict", 1); /* "dnet.pyx":1201 * @@ -14411,7 +20801,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { */ __pyx_t_1 = __Pyx_PyObject_FromString(__pyx_v_rule->fw_device); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1202, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_device, __pyx_t_1) < 0)) __PYX_ERR(0, 1202, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_device, __pyx_t_1) < 0))) __PYX_ERR(0, 1202, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":1203 @@ -14423,7 +20813,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rule->fw_op); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1203, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_op, __pyx_t_1) < 0)) __PYX_ERR(0, 1203, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_op, __pyx_t_1) < 0))) __PYX_ERR(0, 1203, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":1204 @@ -14435,7 +20825,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rule->fw_dir); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1204, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_dir, __pyx_t_1) < 0)) __PYX_ERR(0, 1204, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_dir, __pyx_t_1) < 0))) __PYX_ERR(0, 1204, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":1205 @@ -14445,7 +20835,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { * d['proto'] = rule.fw_proto * if rule.fw_src.addr_type != ADDR_TYPE_NONE: */ - __pyx_t_2 = ((__pyx_v_rule->fw_proto != 0) != 0); + __pyx_t_2 = (__pyx_v_rule->fw_proto != 0); if (__pyx_t_2) { /* "dnet.pyx":1206 @@ -14457,7 +20847,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rule->fw_proto); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1206, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_proto, __pyx_t_1) < 0)) __PYX_ERR(0, 1206, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_proto, __pyx_t_1) < 0))) __PYX_ERR(0, 1206, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":1205 @@ -14483,7 +20873,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { __pyx_t_4 = PyObject_RichCompare(__pyx_t_1, __pyx_t_3, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1207, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1207, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1207, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; if (__pyx_t_2) { @@ -14499,7 +20889,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { __pyx_t_3 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4dnet_addr), __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1208, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_src, __pyx_t_3) < 0)) __PYX_ERR(0, 1208, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_src, __pyx_t_3) < 0))) __PYX_ERR(0, 1208, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "dnet.pyx":1207 @@ -14525,7 +20915,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { __pyx_t_1 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_NE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1209, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1209, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1209, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { @@ -14541,7 +20931,7 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { __pyx_t_4 = __Pyx_PyObject_CallOneArg(((PyObject *)__pyx_ptype_4dnet_addr), __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1210, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_dst, __pyx_t_4) < 0)) __PYX_ERR(0, 1210, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_dst, __pyx_t_4) < 0))) __PYX_ERR(0, 1210, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "dnet.pyx":1209 @@ -14560,16 +20950,16 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { * d['sport'] = [ rule.fw_sport[0], rule.fw_sport[1] ] * if not (rule.fw_dport[0] == 0 and rule.fw_dport[1] == 0): */ - __pyx_t_5 = (((__pyx_v_rule->fw_sport[0]) == 0) != 0); + __pyx_t_5 = ((__pyx_v_rule->fw_sport[0]) == 0); if (__pyx_t_5) { } else { __pyx_t_2 = __pyx_t_5; goto __pyx_L7_bool_binop_done; } - __pyx_t_5 = (((__pyx_v_rule->fw_sport[1]) == 0) != 0); + __pyx_t_5 = ((__pyx_v_rule->fw_sport[1]) == 0); __pyx_t_2 = __pyx_t_5; __pyx_L7_bool_binop_done:; - __pyx_t_5 = ((!__pyx_t_2) != 0); + __pyx_t_5 = (!__pyx_t_2); if (__pyx_t_5) { /* "dnet.pyx":1212 @@ -14586,12 +20976,12 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1212, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_GIVEREF(__pyx_t_4); - PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_4); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_t_4)) __PYX_ERR(0, 1212, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); - PyList_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_t_1)) __PYX_ERR(0, 1212, __pyx_L1_error); __pyx_t_4 = 0; __pyx_t_1 = 0; - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_sport, __pyx_t_3) < 0)) __PYX_ERR(0, 1212, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_sport, __pyx_t_3) < 0))) __PYX_ERR(0, 1212, __pyx_L1_error) __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "dnet.pyx":1211 @@ -14610,16 +21000,16 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { * d['dport'] = [ rule.fw_dport[0], rule.fw_dport[1] ] * return d */ - __pyx_t_2 = (((__pyx_v_rule->fw_dport[0]) == 0) != 0); + __pyx_t_2 = ((__pyx_v_rule->fw_dport[0]) == 0); if (__pyx_t_2) { } else { __pyx_t_5 = __pyx_t_2; goto __pyx_L10_bool_binop_done; } - __pyx_t_2 = (((__pyx_v_rule->fw_dport[1]) == 0) != 0); + __pyx_t_2 = ((__pyx_v_rule->fw_dport[1]) == 0); __pyx_t_5 = __pyx_t_2; __pyx_L10_bool_binop_done:; - __pyx_t_2 = ((!__pyx_t_5) != 0); + __pyx_t_2 = (!__pyx_t_5); if (__pyx_t_2) { /* "dnet.pyx":1214 @@ -14636,12 +21026,12 @@ static PyObject *__pyx_f_4dnet_rule_to_dict(struct fw_rule *__pyx_v_rule) { __pyx_t_4 = PyList_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1214, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_GIVEREF(__pyx_t_3); - PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_t_3)) __PYX_ERR(0, 1214, __pyx_L1_error); __Pyx_GIVEREF(__pyx_t_1); - PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_t_1)) __PYX_ERR(0, 1214, __pyx_L1_error); __pyx_t_3 = 0; __pyx_t_1 = 0; - if (unlikely(PyDict_SetItem(__pyx_v_d, __pyx_n_u_dport, __pyx_t_4) < 0)) __PYX_ERR(0, 1214, __pyx_L1_error) + if (unlikely((PyDict_SetItem(__pyx_v_d, __pyx_n_u_dport, __pyx_t_4) < 0))) __PYX_ERR(0, 1214, __pyx_L1_error) __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; /* "dnet.pyx":1213 @@ -14703,14 +21093,14 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule char *__pyx_t_2; int __pyx_t_3; int __pyx_t_4; - int __pyx_t_5; + PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; - PyObject *__pyx_t_7 = NULL; + int __pyx_t_7; struct addr __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("dict_to_rule", 0); + __Pyx_RefNannySetupContext("dict_to_rule", 1); /* "dnet.pyx":1218 * @@ -14767,9 +21157,8 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule * rule.fw_proto = d['proto'] * if rule.fw_proto == IP_PROTO_TCP or rule.fw_proto == IP_PROTO_UDP: */ - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_proto, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 1222, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_proto, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 1222, __pyx_L1_error) + if (__pyx_t_4) { /* "dnet.pyx":1223 * rule.fw_dir = d['dir'] @@ -14793,30 +21182,30 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule */ __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_rule->fw_proto); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_IP_PROTO_TCP); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_7 = PyObject_RichCompare(__pyx_t_1, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_7); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1224, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_IP_PROTO_TCP); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyObject_RichCompare(__pyx_t_1, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 1224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_7); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 1224, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; - if (!__pyx_t_4) { + if (!__pyx_t_7) { } else { - __pyx_t_5 = __pyx_t_4; + __pyx_t_4 = __pyx_t_7; goto __pyx_L5_bool_binop_done; } - __pyx_t_7 = __Pyx_PyInt_From_int(__pyx_v_rule->fw_proto); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1224, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_n_s_IP_PROTO_UDP); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1224, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyInt_From_int(__pyx_v_rule->fw_proto); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1224, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = PyObject_RichCompare(__pyx_t_7, __pyx_t_6, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1224, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_IP_PROTO_UDP); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyObject_RichCompare(__pyx_t_6, __pyx_t_5, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; - __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 1224, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 1224, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = __pyx_t_4; + __pyx_t_4 = __pyx_t_7; __pyx_L5_bool_binop_done:; - if (__pyx_t_5) { + if (__pyx_t_4) { /* "dnet.pyx":1225 * rule.fw_proto = d['proto'] @@ -14861,8 +21250,7 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule * rule.fw_src = (d['src'])._addr * if 'dst' in d: */ - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_src, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 1227, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_5 != 0); + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_src, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 1227, __pyx_L1_error) if (__pyx_t_4) { /* "dnet.pyx":1228 @@ -14894,9 +21282,8 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule * rule.fw_dst = (d['dst'])._addr * if 'sport' in d: */ - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_dst, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 1229, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_dst, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 1229, __pyx_L1_error) + if (__pyx_t_4) { /* "dnet.pyx":1230 * rule.fw_src = (d['src'])._addr @@ -14927,8 +21314,7 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule * rule.fw_sport[0] = d['sport'][0] * rule.fw_sport[1] = d['sport'][1] */ - __pyx_t_5 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_sport, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_5 < 0)) __PYX_ERR(0, 1231, __pyx_L1_error) - __pyx_t_4 = (__pyx_t_5 != 0); + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_sport, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 1231, __pyx_L1_error) if (__pyx_t_4) { /* "dnet.pyx":1232 @@ -14940,11 +21326,11 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_sport); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1232, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1232, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1232, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1232, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (__pyx_v_rule->fw_sport[0]) = __pyx_t_3; /* "dnet.pyx":1233 @@ -14954,11 +21340,11 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule * if 'dport' in d: * rule.fw_dport[0] = d['dport'][0] */ - __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_sport); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1233, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1233, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_sport); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1233, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1233, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; (__pyx_v_rule->fw_sport[1]) = __pyx_t_3; @@ -14979,9 +21365,8 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule * rule.fw_dport[0] = d['dport'][0] * rule.fw_dport[1] = d['dport'][1] */ - __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_dport, __pyx_v_d, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 1234, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - if (__pyx_t_5) { + __pyx_t_4 = (__Pyx_PySequence_ContainsTF(__pyx_n_u_dport, __pyx_v_d, Py_EQ)); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 1234, __pyx_L1_error) + if (__pyx_t_4) { /* "dnet.pyx":1235 * rule.fw_sport[1] = d['sport'][1] @@ -14992,11 +21377,11 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule */ __pyx_t_1 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_dport); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1235, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1235, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_1, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_6); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1235, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_5); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1235, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; (__pyx_v_rule->fw_dport[0]) = __pyx_t_3; /* "dnet.pyx":1236 @@ -15006,11 +21391,11 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule * * cdef int __fw_callback(fw_rule *rule, void *arg) except -1: */ - __pyx_t_6 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_dport); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_6, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1236, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyObject_Dict_GetItem(__pyx_v_d, __pyx_n_u_dport); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_t_5, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1236, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; __pyx_t_3 = __Pyx_PyInt_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1236, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; (__pyx_v_rule->fw_dport[1]) = __pyx_t_3; @@ -15037,8 +21422,8 @@ static PyObject *__pyx_f_4dnet_dict_to_rule(PyObject *__pyx_v_d, struct fw_rule 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_AddTraceback("dnet.dict_to_rule", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -15068,13 +21453,12 @@ static int __pyx_f_4dnet___fw_callback(struct fw_rule *__pyx_v_rule, void *__pyx PyObject *__pyx_t_4 = NULL; PyObject *(*__pyx_t_5)(PyObject *); int __pyx_t_6; - PyObject *__pyx_t_7 = NULL; + int __pyx_t_7; int __pyx_t_8; - int __pyx_t_9; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__fw_callback", 0); + __Pyx_RefNannySetupContext("__fw_callback", 1); /* "dnet.pyx":1239 * @@ -15115,7 +21499,7 @@ static int __pyx_f_4dnet___fw_callback(struct fw_rule *__pyx_v_rule, void *__pyx __pyx_t_4 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1239, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_4); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_5 = Py_TYPE(__pyx_t_4)->tp_iternext; + __pyx_t_5 = __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); index = 0; __pyx_t_2 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_2)) goto __pyx_L3_unpacking_failed; __Pyx_GOTREF(__pyx_t_2); index = 1; __pyx_t_3 = __pyx_t_5(__pyx_t_4); if (unlikely(!__pyx_t_3)) goto __pyx_L3_unpacking_failed; @@ -15148,7 +21532,8 @@ static int __pyx_f_4dnet___fw_callback(struct fw_rule *__pyx_v_rule, void *__pyx __Pyx_INCREF(__pyx_v_f); __pyx_t_2 = __pyx_v_f; __pyx_t_4 = NULL; __pyx_t_6 = 0; - if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_2))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -15158,41 +21543,16 @@ static int __pyx_f_4dnet___fw_callback(struct fw_rule *__pyx_v_rule, void *__pyx __pyx_t_6 = 1; } } - #if CYTHON_FAST_PYCALL - if (PyFunction_Check(__pyx_t_2)) { - PyObject *__pyx_temp[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_a}; - __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1240, __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_v_a}; - __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_2, __pyx_temp+1-__pyx_t_6, 2+__pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1240, __pyx_L1_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_a}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_6, 2+__pyx_t_6); __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_7 = PyTuple_New(2+__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1240, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_7); - if (__pyx_t_4) { - __Pyx_GIVEREF(__pyx_t_4); PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4); __pyx_t_4 = NULL; - } - __Pyx_GIVEREF(__pyx_t_3); - PyTuple_SET_ITEM(__pyx_t_7, 0+__pyx_t_6, __pyx_t_3); - __Pyx_INCREF(__pyx_v_a); - __Pyx_GIVEREF(__pyx_v_a); - PyTuple_SET_ITEM(__pyx_t_7, 1+__pyx_t_6, __pyx_v_a); - __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1240, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1240, __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; } - __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __pyx_v_ret = __pyx_t_1; __pyx_t_1 = 0; @@ -15203,9 +21563,9 @@ static int __pyx_f_4dnet___fw_callback(struct fw_rule *__pyx_v_rule, void *__pyx * ret = 0 * return ret */ - __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_v_ret); if (unlikely(__pyx_t_8 < 0)) __PYX_ERR(0, 1241, __pyx_L1_error) - __pyx_t_9 = ((!__pyx_t_8) != 0); - if (__pyx_t_9) { + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v_ret); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 1241, __pyx_L1_error) + __pyx_t_8 = (!__pyx_t_7); + if (__pyx_t_8) { /* "dnet.pyx":1242 * ret = f(rule_to_dict(rule), a) @@ -15251,7 +21611,6 @@ static int __pyx_f_4dnet___fw_callback(struct fw_rule *__pyx_v_rule, void *__pyx __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_7); __Pyx_AddTraceback("dnet.__fw_callback", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; @@ -15273,12 +21632,20 @@ static int __pyx_f_4dnet___fw_callback(struct fw_rule *__pyx_v_rule, void *__pyx /* Python wrapper */ static int __pyx_pw_4dnet_2fw_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_4dnet_2fw_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_4dnet_2fw___init__(((struct __pyx_obj_4dnet_fw *)__pyx_v_self)); /* function exit code */ @@ -15294,7 +21661,7 @@ static int __pyx_pf_4dnet_2fw___init__(struct __pyx_obj_4dnet_fw *__pyx_v_self) int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":1253 * @@ -15312,7 +21679,7 @@ static int __pyx_pf_4dnet_2fw___init__(struct __pyx_obj_4dnet_fw *__pyx_v_self) * raise OSError, __oserror() * */ - __pyx_t_1 = ((!(__pyx_v_self->fw != 0)) != 0); + __pyx_t_1 = (!(__pyx_v_self->fw != 0)); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":1255 @@ -15366,15 +21733,98 @@ static int __pyx_pf_4dnet_2fw___init__(struct __pyx_obj_4dnet_fw *__pyx_v_self) */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_2fw_3add(PyObject *__pyx_v_self, PyObject *__pyx_v_d); /*proto*/ -static char __pyx_doc_4dnet_2fw_2add[] = "Add a firewall rule specified as a dict.\n\n Dict values:\n device -- interface name\t\t\t(string)\n op -- operation (FW_OP_*)\t\t\t(integer)\n dir -- direction (FW_DIR_*)\t\t\t(integer)\n proto -- IP protocol (IP_PROTO_*)\t\t(integer)\n src -- source address / net\t\t\t(addr object)\n dst -- destination address / net\t\t(addr object)\n sport -- source port range or ICMP type/mask\t(list of 2 integers)\n dport -- dest port range or ICMP code/mask\t(list of 2 integers)\n "; -static PyObject *__pyx_pw_4dnet_2fw_3add(PyObject *__pyx_v_self, PyObject *__pyx_v_d) { +static PyObject *__pyx_pw_4dnet_2fw_3add(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_2fw_2add, "Add a firewall rule specified as a dict.\n\n Dict values:\n device -- interface name\t\t\t(string)\n op -- operation (FW_OP_*)\t\t\t(integer)\n dir -- direction (FW_DIR_*)\t\t\t(integer)\n proto -- IP protocol (IP_PROTO_*)\t\t(integer)\n src -- source address / net\t\t\t(addr object)\n dst -- destination address / net\t\t(addr object)\n sport -- source port range or ICMP type/mask\t(list of 2 integers)\n dport -- dest port range or ICMP code/mask\t(list of 2 integers)\n "); +static PyMethodDef __pyx_mdef_4dnet_2fw_3add = {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_3add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2fw_2add}; +static PyObject *__pyx_pw_4dnet_2fw_3add(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_d = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_2fw_2add(((struct __pyx_obj_4dnet_fw *)__pyx_v_self), ((PyObject *)__pyx_v_d)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_d,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_d)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1257, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add") < 0)) __PYX_ERR(0, 1257, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_d = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1257, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.fw.add", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_2fw_2add(((struct __pyx_obj_4dnet_fw *)__pyx_v_self), __pyx_v_d); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -15388,7 +21838,7 @@ static PyObject *__pyx_pf_4dnet_2fw_2add(struct __pyx_obj_4dnet_fw *__pyx_v_self int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("add", 0); + __Pyx_RefNannySetupContext("add", 1); /* "dnet.pyx":1271 * """ @@ -15417,7 +21867,7 @@ static PyObject *__pyx_pf_4dnet_2fw_2add(struct __pyx_obj_4dnet_fw *__pyx_v_self * raise OSError, __oserror() * */ - __pyx_t_2 = ((fw_add(__pyx_v_self->fw, (&__pyx_v_rule)) < 0) != 0); + __pyx_t_2 = (fw_add(__pyx_v_self->fw, (&__pyx_v_rule)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":1274 @@ -15472,15 +21922,98 @@ static PyObject *__pyx_pf_4dnet_2fw_2add(struct __pyx_obj_4dnet_fw *__pyx_v_self */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_2fw_5delete(PyObject *__pyx_v_self, PyObject *__pyx_v_d); /*proto*/ -static char __pyx_doc_4dnet_2fw_4delete[] = "Delete a firewall rule specified as a dict."; -static PyObject *__pyx_pw_4dnet_2fw_5delete(PyObject *__pyx_v_self, PyObject *__pyx_v_d) { +static PyObject *__pyx_pw_4dnet_2fw_5delete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_2fw_4delete, "Delete a firewall rule specified as a dict."); +static PyMethodDef __pyx_mdef_4dnet_2fw_5delete = {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_5delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2fw_4delete}; +static PyObject *__pyx_pw_4dnet_2fw_5delete(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_d = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("delete (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_2fw_4delete(((struct __pyx_obj_4dnet_fw *)__pyx_v_self), ((PyObject *)__pyx_v_d)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_d,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_d)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1276, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "delete") < 0)) __PYX_ERR(0, 1276, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_d = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("delete", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1276, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.fw.delete", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_2fw_4delete(((struct __pyx_obj_4dnet_fw *)__pyx_v_self), __pyx_v_d); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -15494,7 +22027,7 @@ static PyObject *__pyx_pf_4dnet_2fw_4delete(struct __pyx_obj_4dnet_fw *__pyx_v_s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("delete", 0); + __Pyx_RefNannySetupContext("delete", 1); /* "dnet.pyx":1279 * """Delete a firewall rule specified as a dict.""" @@ -15523,7 +22056,7 @@ static PyObject *__pyx_pf_4dnet_2fw_4delete(struct __pyx_obj_4dnet_fw *__pyx_v_s * raise OSError, __oserror() * */ - __pyx_t_2 = ((fw_delete(__pyx_v_self->fw, (&__pyx_v_rule)) < 0) != 0); + __pyx_t_2 = (fw_delete(__pyx_v_self->fw, (&__pyx_v_rule)) < 0); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":1282 @@ -15578,52 +22111,82 @@ static PyObject *__pyx_pf_4dnet_2fw_4delete(struct __pyx_obj_4dnet_fw *__pyx_v_s */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_2fw_7loop(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_2fw_6loop[] = "Iterate over the local firewall ruleset, invoking a user callback\n with each entry, returning the status of the callback routine.\n\n Keyword arguments:\n callback -- callback function with (dict, arg) prototype.\n If this function returns a non-zero value, the loop\n will break early.\n arg -- optional callback argument\n "; -static PyObject *__pyx_pw_4dnet_2fw_7loop(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_2fw_7loop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_2fw_6loop, "Iterate over the local firewall ruleset, invoking a user callback\n with each entry, returning the status of the callback routine.\n\n Keyword arguments:\n callback -- callback function with (dict, arg) prototype.\n If this function returns a non-zero value, the loop\n will break early.\n arg -- optional callback argument\n "); +static PyMethodDef __pyx_mdef_4dnet_2fw_7loop = {"loop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_7loop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2fw_6loop}; +static PyObject *__pyx_pw_4dnet_2fw_7loop(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_callback = 0; PyObject *__pyx_v_arg = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("loop (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_arg,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_callback,&__pyx_n_s_arg,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_callback)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_callback)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1284, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_arg); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_arg); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1284, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "loop") < 0)) __PYX_ERR(0, 1284, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "loop") < 0)) __PYX_ERR(0, 1284, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -15631,10 +22194,18 @@ static PyObject *__pyx_pw_4dnet_2fw_7loop(PyObject *__pyx_v_self, PyObject *__py __pyx_v_callback = values[0]; __pyx_v_arg = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("loop", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1284, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("loop", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1284, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.fw.loop", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -15642,6 +22213,12 @@ static PyObject *__pyx_pw_4dnet_2fw_7loop(PyObject *__pyx_v_self, PyObject *__py __pyx_r = __pyx_pf_4dnet_2fw_6loop(((struct __pyx_obj_4dnet_fw *)__pyx_v_self), __pyx_v_callback, __pyx_v_arg); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -15654,7 +22231,7 @@ static PyObject *__pyx_pf_4dnet_2fw_6loop(struct __pyx_obj_4dnet_fw *__pyx_v_sel int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("loop", 0); + __Pyx_RefNannySetupContext("loop", 1); /* "dnet.pyx":1294 * arg -- optional callback argument @@ -15667,10 +22244,10 @@ static PyObject *__pyx_pf_4dnet_2fw_6loop(struct __pyx_obj_4dnet_fw *__pyx_v_sel __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_v_callback); __Pyx_GIVEREF(__pyx_v_callback); - PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_callback); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_callback)) __PYX_ERR(0, 1294, __pyx_L1_error); __Pyx_INCREF(__pyx_v_arg); __Pyx_GIVEREF(__pyx_v_arg); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_arg)) __PYX_ERR(0, 1294, __pyx_L1_error); __pyx_v__arg = ((PyObject*)__pyx_t_1); __pyx_t_1 = 0; @@ -15719,9 +22296,11 @@ static PyObject *__pyx_pf_4dnet_2fw_6loop(struct __pyx_obj_4dnet_fw *__pyx_v_sel /* Python wrapper */ static PyObject *__pyx_pw_4dnet_2fw_9__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_2fw_9__iter__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_2fw_8__iter__(((struct __pyx_obj_4dnet_fw *)__pyx_v_self)); /* function exit code */ @@ -15738,11 +22317,10 @@ static PyObject *__pyx_pf_4dnet_2fw_8__iter__(struct __pyx_obj_4dnet_fw *__pyx_v 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("__iter__", 0); + __Pyx_RefNannySetupContext("__iter__", 1); /* "dnet.pyx":1298 * @@ -15769,7 +22347,8 @@ static PyObject *__pyx_pf_4dnet_2fw_8__iter__(struct __pyx_obj_4dnet_fw *__pyx_v __Pyx_GOTREF(__pyx_t_3); __pyx_t_4 = NULL; __pyx_t_5 = 0; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_2))) { + #if CYTHON_UNPACK_METHODS + if (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); @@ -15779,41 +22358,16 @@ static PyObject *__pyx_pf_4dnet_2fw_8__iter__(struct __pyx_obj_4dnet_fw *__pyx_v __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_v_l}; - __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(0, 1299, __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_v_l}; - __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(0, 1299, __pyx_L1_error) + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_v_l}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 2+__pyx_t_5); __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(0, 1299, __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_v_l); - __Pyx_GIVEREF(__pyx_v_l); - PyTuple_SET_ITEM(__pyx_t_6, 1+__pyx_t_5, __pyx_v_l); - __pyx_t_3 = 0; - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_2, __pyx_t_6, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1299, __pyx_L1_error) + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1299, __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_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "dnet.pyx":1300 @@ -15844,7 +22398,6 @@ static PyObject *__pyx_pf_4dnet_2fw_8__iter__(struct __pyx_obj_4dnet_fw *__pyx_v __Pyx_XDECREF(__pyx_t_2); __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("dnet.fw.__iter__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -15865,8 +22418,10 @@ static PyObject *__pyx_pf_4dnet_2fw_8__iter__(struct __pyx_obj_4dnet_fw *__pyx_v /* Python wrapper */ static void __pyx_pw_4dnet_2fw_11__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_4dnet_2fw_11__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_4dnet_2fw_10__dealloc__(((struct __pyx_obj_4dnet_fw *)__pyx_v_self)); /* function exit code */ @@ -15874,9 +22429,7 @@ static void __pyx_pw_4dnet_2fw_11__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_4dnet_2fw_10__dealloc__(struct __pyx_obj_4dnet_fw *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "dnet.pyx":1303 * @@ -15915,21 +22468,48 @@ static void __pyx_pf_4dnet_2fw_10__dealloc__(struct __pyx_obj_4dnet_fw *__pyx_v_ */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.fw cannot be converted to a Python object for pickling") + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_2fw_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_2fw_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_2fw_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_2fw_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_2fw_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_2fw_12__reduce_cython__(((struct __pyx_obj_4dnet_fw *)__pyx_v_self)); /* function exit code */ @@ -15940,33 +22520,28 @@ static PyObject *__pyx_pw_4dnet_2fw_13__reduce_cython__(PyObject *__pyx_v_self, static PyObject *__pyx_pf_4dnet_2fw_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_fw *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.fw cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.fw cannot be converted to a Python object for pickling") + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__35, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_fw_cannot_be_converted_to_a, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.fw cannot be converted to a Python object for pickling") + * raise TypeError, "self.fw 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("dnet.fw.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -15976,20 +22551,103 @@ static PyObject *__pyx_pf_4dnet_2fw_12__reduce_cython__(CYTHON_UNUSED struct __p /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.fw cannot be converted to a Python object for pickling") + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.fw cannot be converted to a Python object for pickling") + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_2fw_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_2fw_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_2fw_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_2fw_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_2fw_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_2fw_14__setstate_cython__(((struct __pyx_obj_4dnet_fw *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.fw.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_2fw_14__setstate_cython__(((struct __pyx_obj_4dnet_fw *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -15997,33 +22655,28 @@ static PyObject *__pyx_pw_4dnet_2fw_15__setstate_cython__(PyObject *__pyx_v_self static PyObject *__pyx_pf_4dnet_2fw_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_fw *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.fw cannot be converted to a Python object for pickling") + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.fw cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__36, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_fw_cannot_be_converted_to_a, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.fw cannot be converted to a Python object for pickling") + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.fw cannot be converted to a Python object for pickling") + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.fw.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -16042,12 +22695,20 @@ static PyObject *__pyx_pf_4dnet_2fw_14__setstate_cython__(CYTHON_UNUSED struct _ /* Python wrapper */ static int __pyx_pw_4dnet_4rand_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ static int __pyx_pw_4dnet_4rand_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; 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; + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_VARARGS(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__init__", 0))) return -1; __pyx_r = __pyx_pf_4dnet_4rand___init__(((struct __pyx_obj_4dnet_rand *)__pyx_v_self)); /* function exit code */ @@ -16063,7 +22724,7 @@ static int __pyx_pf_4dnet_4rand___init__(struct __pyx_obj_4dnet_rand *__pyx_v_se int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":1333 * @@ -16081,7 +22742,7 @@ static int __pyx_pf_4dnet_4rand___init__(struct __pyx_obj_4dnet_rand *__pyx_v_se * raise OSError, __oserror() * */ - __pyx_t_1 = ((!(__pyx_v_self->rand != 0)) != 0); + __pyx_t_1 = (!(__pyx_v_self->rand != 0)); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":1335 @@ -16135,15 +22796,98 @@ static int __pyx_pf_4dnet_4rand___init__(struct __pyx_obj_4dnet_rand *__pyx_v_se */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_3get(PyObject *__pyx_v_self, PyObject *__pyx_v_len); /*proto*/ -static char __pyx_doc_4dnet_4rand_2get[] = "Return a string of random bytes.\n \n Arguments:\n len -- number of random bytes to generate\n "; -static PyObject *__pyx_pw_4dnet_4rand_3get(PyObject *__pyx_v_self, PyObject *__pyx_v_len) { +static PyObject *__pyx_pw_4dnet_4rand_3get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4rand_2get, "Return a string of random bytes.\n \n Arguments:\n len -- number of random bytes to generate\n "); +static PyMethodDef __pyx_mdef_4dnet_4rand_3get = {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_3get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_2get}; +static PyObject *__pyx_pw_4dnet_4rand_3get(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_len = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("get (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4rand_2get(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), ((PyObject *)__pyx_v_len)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_len,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_len)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1337, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "get") < 0)) __PYX_ERR(0, 1337, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_len = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1337, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.rand.get", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4rand_2get(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), __pyx_v_len); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -16160,7 +22904,7 @@ static PyObject *__pyx_pf_4dnet_4rand_2get(struct __pyx_obj_4dnet_rand *__pyx_v_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("get", 0); + __Pyx_RefNannySetupContext("get", 1); /* "dnet.pyx":1345 * cdef char buf[1024] @@ -16170,7 +22914,7 @@ static PyObject *__pyx_pf_4dnet_4rand_2get(struct __pyx_obj_4dnet_rand *__pyx_v_ * return PyBytes_FromStringAndSize(buf, len) */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_len, __pyx_int_1024, Py_LE); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1345, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1345, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1345, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { @@ -16291,15 +23035,98 @@ static PyObject *__pyx_pf_4dnet_4rand_2get(struct __pyx_obj_4dnet_rand *__pyx_v_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_5set(PyObject *__pyx_v_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_4rand_4set[] = "Initialize the PRNG from a known seed.\n \n Arguments:\n string -- binary string seed value\n "; -static PyObject *__pyx_pw_4dnet_4rand_5set(PyObject *__pyx_v_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_4rand_5set(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4rand_4set, "Initialize the PRNG from a known seed.\n \n Arguments:\n string -- binary string seed value\n "); +static PyMethodDef __pyx_mdef_4dnet_4rand_5set = {"set", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_5set, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_4set}; +static PyObject *__pyx_pw_4dnet_4rand_5set(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("set (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4rand_4set(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1354, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "set") < 0)) __PYX_ERR(0, 1354, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("set", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1354, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.rand.set", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4rand_4set(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -16311,7 +23138,7 @@ static PyObject *__pyx_pf_4dnet_4rand_4set(struct __pyx_obj_4dnet_rand *__pyx_v_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("set", 0); + __Pyx_RefNannySetupContext("set", 1); /* "dnet.pyx":1360 * string -- binary string seed value @@ -16352,15 +23179,98 @@ static PyObject *__pyx_pf_4dnet_4rand_4set(struct __pyx_obj_4dnet_rand *__pyx_v_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_7add(PyObject *__pyx_v_self, PyObject *__pyx_v_buf); /*proto*/ -static char __pyx_doc_4dnet_4rand_6add[] = "Add additional entropy into the PRNG mix.\n\n Arguments:\n string -- binary string\n "; -static PyObject *__pyx_pw_4dnet_4rand_7add(PyObject *__pyx_v_self, PyObject *__pyx_v_buf) { +static PyObject *__pyx_pw_4dnet_4rand_7add(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4rand_6add, "Add additional entropy into the PRNG mix.\n\n Arguments:\n string -- binary string\n "); +static PyMethodDef __pyx_mdef_4dnet_4rand_7add = {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_7add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_6add}; +static PyObject *__pyx_pw_4dnet_4rand_7add(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_buf = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("add (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4rand_6add(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), ((PyObject *)__pyx_v_buf)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_buf,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_buf)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1362, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "add") < 0)) __PYX_ERR(0, 1362, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_buf = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("add", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1362, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.rand.add", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4rand_6add(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), __pyx_v_buf); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -16372,7 +23282,7 @@ static PyObject *__pyx_pf_4dnet_4rand_6add(struct __pyx_obj_4dnet_rand *__pyx_v_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("add", 0); + __Pyx_RefNannySetupContext("add", 1); /* "dnet.pyx":1368 * string -- binary string @@ -16413,12 +23323,40 @@ static PyObject *__pyx_pf_4dnet_4rand_6add(struct __pyx_obj_4dnet_rand *__pyx_v_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_9uint8(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_4dnet_4rand_8uint8[] = "Return a random 8-bit integer."; -static PyObject *__pyx_pw_4dnet_4rand_9uint8(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4rand_9uint8(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4rand_8uint8, "Return a random 8-bit integer."); +static PyMethodDef __pyx_mdef_4dnet_4rand_9uint8 = {"uint8", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_9uint8, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_8uint8}; +static PyObject *__pyx_pw_4dnet_4rand_9uint8(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("uint8 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("uint8", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "uint8", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4rand_8uint8(((struct __pyx_obj_4dnet_rand *)__pyx_v_self)); /* function exit code */ @@ -16433,7 +23371,7 @@ static PyObject *__pyx_pf_4dnet_4rand_8uint8(struct __pyx_obj_4dnet_rand *__pyx_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("uint8", 0); + __Pyx_RefNannySetupContext("uint8", 1); /* "dnet.pyx":1372 * def uint8(self): @@ -16477,12 +23415,40 @@ static PyObject *__pyx_pf_4dnet_4rand_8uint8(struct __pyx_obj_4dnet_rand *__pyx_ */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_11uint16(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_4dnet_4rand_10uint16[] = "Return a random 16-bit integer."; -static PyObject *__pyx_pw_4dnet_4rand_11uint16(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4rand_11uint16(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4rand_10uint16, "Return a random 16-bit integer."); +static PyMethodDef __pyx_mdef_4dnet_4rand_11uint16 = {"uint16", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_11uint16, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_10uint16}; +static PyObject *__pyx_pw_4dnet_4rand_11uint16(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("uint16 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("uint16", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "uint16", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4rand_10uint16(((struct __pyx_obj_4dnet_rand *)__pyx_v_self)); /* function exit code */ @@ -16497,7 +23463,7 @@ static PyObject *__pyx_pf_4dnet_4rand_10uint16(struct __pyx_obj_4dnet_rand *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("uint16", 0); + __Pyx_RefNannySetupContext("uint16", 1); /* "dnet.pyx":1376 * def uint16(self): @@ -16541,12 +23507,40 @@ static PyObject *__pyx_pf_4dnet_4rand_10uint16(struct __pyx_obj_4dnet_rand *__py */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_13uint32(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_4dnet_4rand_12uint32[] = "Return a random 32-bit integer."; -static PyObject *__pyx_pw_4dnet_4rand_13uint32(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4rand_13uint32(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4rand_12uint32, "Return a random 32-bit integer."); +static PyMethodDef __pyx_mdef_4dnet_4rand_13uint32 = {"uint32", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_13uint32, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_12uint32}; +static PyObject *__pyx_pw_4dnet_4rand_13uint32(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("uint32 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("uint32", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "uint32", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4rand_12uint32(((struct __pyx_obj_4dnet_rand *)__pyx_v_self)); /* function exit code */ @@ -16561,7 +23555,7 @@ static PyObject *__pyx_pf_4dnet_4rand_12uint32(struct __pyx_obj_4dnet_rand *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("uint32", 0); + __Pyx_RefNannySetupContext("uint32", 1); /* "dnet.pyx":1380 * def uint32(self): @@ -16605,52 +23599,82 @@ static PyObject *__pyx_pf_4dnet_4rand_12uint32(struct __pyx_obj_4dnet_rand *__py */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_15xrange(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static char __pyx_doc_4dnet_4rand_14xrange[] = "xrange([start,] stop) -> xrange object\n\n Return a random permutation iterator to walk an unsigned integer range,\n like xrange().\n "; -static PyObject *__pyx_pw_4dnet_4rand_15xrange(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_4rand_15xrange(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_4rand_14xrange, "xrange([start,] stop) -> xrange object\n\n Return a random permutation iterator to walk an unsigned integer range,\n like xrange().\n "); +static PyMethodDef __pyx_mdef_4dnet_4rand_15xrange = {"xrange", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_15xrange, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_14xrange}; +static PyObject *__pyx_pw_4dnet_4rand_15xrange(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v_start = 0; PyObject *__pyx_v_stop = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("xrange (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_stop,0}; - PyObject* values[2] = {0,0}; - values[1] = ((PyObject *)Py_None); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_start,&__pyx_n_s_stop,0}; + values[1] = __Pyx_Arg_NewRef_FASTCALL(((PyObject *)Py_None)); + if (__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); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_start)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1382, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stop); - if (value) { values[1] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stop); + if (value) { values[1] = __Pyx_Arg_NewRef_FASTCALL(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1382, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "xrange") < 0)) __PYX_ERR(0, 1382, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "xrange") < 0)) __PYX_ERR(0, 1382, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + switch (__pyx_nargs) { + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -16658,10 +23682,18 @@ static PyObject *__pyx_pw_4dnet_4rand_15xrange(PyObject *__pyx_v_self, PyObject __pyx_v_start = values[0]; __pyx_v_stop = values[1]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("xrange", 0, 1, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1382, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("xrange", 0, 1, 2, __pyx_nargs); __PYX_ERR(0, 1382, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.rand.xrange", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -16669,6 +23701,12 @@ static PyObject *__pyx_pw_4dnet_4rand_15xrange(PyObject *__pyx_v_self, PyObject __pyx_r = __pyx_pf_4dnet_4rand_14xrange(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), __pyx_v_start, __pyx_v_stop); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -16682,7 +23720,7 @@ static PyObject *__pyx_pf_4dnet_4rand_14xrange(struct __pyx_obj_4dnet_rand *__py int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("xrange", 0); + __Pyx_RefNannySetupContext("xrange", 1); /* "dnet.pyx":1388 * like xrange(). @@ -16692,7 +23730,7 @@ static PyObject *__pyx_pf_4dnet_4rand_14xrange(struct __pyx_obj_4dnet_rand *__py * else: */ __pyx_t_1 = PyObject_RichCompare(__pyx_v_stop, Py_None, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1388, __pyx_L1_error) - __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 1388, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 1388, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; if (__pyx_t_2) { @@ -16706,15 +23744,15 @@ static PyObject *__pyx_pf_4dnet_4rand_14xrange(struct __pyx_obj_4dnet_rand *__py __Pyx_XDECREF(__pyx_r); __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(0, 1389, __pyx_L1_error); __Pyx_INCREF(__pyx_int_0); __Pyx_GIVEREF(__pyx_int_0); - PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_0)) __PYX_ERR(0, 1389, __pyx_L1_error); __Pyx_INCREF(__pyx_v_start); __Pyx_GIVEREF(__pyx_v_start); - PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_start); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_start)) __PYX_ERR(0, 1389, __pyx_L1_error); __pyx_t_3 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_4dnet___rand_xrange), __pyx_t_1, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1389, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; @@ -16742,15 +23780,15 @@ static PyObject *__pyx_pf_4dnet_4rand_14xrange(struct __pyx_obj_4dnet_rand *__py __Pyx_XDECREF(__pyx_r); __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); - __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); - PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self))) __PYX_ERR(0, 1391, __pyx_L1_error); __Pyx_INCREF(__pyx_v_start); __Pyx_GIVEREF(__pyx_v_start); - PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_start); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_v_start)) __PYX_ERR(0, 1391, __pyx_L1_error); __Pyx_INCREF(__pyx_v_stop); __Pyx_GIVEREF(__pyx_v_stop); - PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_stop); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_stop)) __PYX_ERR(0, 1391, __pyx_L1_error); __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_ptype_4dnet___rand_xrange), __pyx_t_3, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1391, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; @@ -16790,8 +23828,10 @@ static PyObject *__pyx_pf_4dnet_4rand_14xrange(struct __pyx_obj_4dnet_rand *__py /* Python wrapper */ static void __pyx_pw_4dnet_4rand_17__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_4dnet_4rand_17__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_4dnet_4rand_16__dealloc__(((struct __pyx_obj_4dnet_rand *)__pyx_v_self)); /* function exit code */ @@ -16799,9 +23839,7 @@ static void __pyx_pw_4dnet_4rand_17__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_4dnet_4rand_16__dealloc__(struct __pyx_obj_4dnet_rand *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "dnet.pyx":1394 * @@ -16840,21 +23878,48 @@ static void __pyx_pf_4dnet_4rand_16__dealloc__(struct __pyx_obj_4dnet_rand *__py */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_4rand_19__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_4rand_19__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_4rand_19__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_4rand_19__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_4rand_18__reduce_cython__(((struct __pyx_obj_4dnet_rand *)__pyx_v_self)); /* function exit code */ @@ -16865,33 +23930,28 @@ static PyObject *__pyx_pw_4dnet_4rand_19__reduce_cython__(PyObject *__pyx_v_self static PyObject *__pyx_pf_4dnet_4rand_18__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_rand *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__37, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_rand_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand 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("dnet.rand.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -16901,54 +23961,132 @@ static PyObject *__pyx_pf_4dnet_4rand_18__reduce_cython__(CYTHON_UNUSED struct _ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_4rand_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_4rand_21__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_4rand_21__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_4rand_21__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_4rand_21__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_4rand_20__setstate_cython__(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); - - /* function exit code */ - __Pyx_RefNannyFinishContext(); - return __pyx_r; -} - -static PyObject *__pyx_pf_4dnet_4rand_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_rand *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.rand.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_4rand_20__setstate_cython__(((struct __pyx_obj_4dnet_rand *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4dnet_4rand_20__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_rand *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__38, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_rand_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.rand.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -16970,64 +24108,92 @@ static int __pyx_pw_4dnet_13__rand_xrange_1__init__(PyObject *__pyx_v_self, PyOb PyObject *__pyx_v_r = 0; PyObject *__pyx_v_start = 0; PyObject *__pyx_v_stop = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_r,&__pyx_n_s_start,&__pyx_n_s_stop,0}; - PyObject* values[3] = {0,0,0}; - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_r,&__pyx_n_s_start,&__pyx_n_s_stop,0}; + if (__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); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_r)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_r)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1410, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_start)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_start)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1410, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 1); __PYX_ERR(0, 1410, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: - if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_stop)) != 0)) kw_args--; + if (likely((values[2] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_stop)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1410, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, 2); __PYX_ERR(0, 1410, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1410, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 1410, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 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); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); + values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); } __pyx_v_r = values[0]; __pyx_v_start = values[1]; __pyx_v_stop = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1410, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 1, 3, 3, __pyx_nargs); __PYX_ERR(0, 1410, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.__rand_xrange.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; @@ -17035,6 +24201,12 @@ static int __pyx_pw_4dnet_13__rand_xrange_1__init__(PyObject *__pyx_v_self, PyOb __pyx_r = __pyx_pf_4dnet_13__rand_xrange___init__(((struct __pyx_obj_4dnet___rand_xrange *)__pyx_v_self), __pyx_v_r, __pyx_v_start, __pyx_v_stop); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -17042,14 +24214,12 @@ static int __pyx_pw_4dnet_13__rand_xrange_1__init__(PyObject *__pyx_v_self, PyOb static int __pyx_pf_4dnet_13__rand_xrange___init__(struct __pyx_obj_4dnet___rand_xrange *__pyx_v_self, PyObject *__pyx_v_r, PyObject *__pyx_v_start, PyObject *__pyx_v_stop) { unsigned int __pyx_v_bits; int __pyx_r; - __Pyx_RefNannyDeclarations rand_t *__pyx_t_1; int __pyx_t_2; int __pyx_t_3; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); /* "dnet.pyx":1413 * cdef unsigned int bits @@ -17229,7 +24399,7 @@ static int __pyx_pf_4dnet_13__rand_xrange___init__(struct __pyx_obj_4dnet___rand * */ while (1) { - __pyx_t_2 = ((__pyx_v_self->max > (1 << __pyx_v_bits)) != 0); + __pyx_t_2 = (__pyx_v_self->max > (1 << __pyx_v_bits)); if (!__pyx_t_2) break; /* "dnet.pyx":1433 @@ -17276,7 +24446,7 @@ static int __pyx_pf_4dnet_13__rand_xrange___init__(struct __pyx_obj_4dnet___rand * self.sboxmask = TEASBOXSIZE - 1 * self.kshift = TEASBOXSHIFT */ - __pyx_t_2 = ((__pyx_e_4dnet_TEASBOXSIZE < (1 << __pyx_v_self->left)) != 0); + __pyx_t_2 = (__pyx_e_4dnet_TEASBOXSIZE < (1 << __pyx_v_self->left)); if (__pyx_t_2) { /* "dnet.pyx":1440 @@ -17344,7 +24514,6 @@ static int __pyx_pf_4dnet_13__rand_xrange___init__(struct __pyx_obj_4dnet___rand __Pyx_AddTraceback("dnet.__rand_xrange.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = -1; __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -17359,9 +24528,11 @@ static int __pyx_pf_4dnet_13__rand_xrange___init__(struct __pyx_obj_4dnet___rand /* Python wrapper */ static PyObject *__pyx_pw_4dnet_13__rand_xrange_3__iter__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_13__rand_xrange_3__iter__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__iter__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_13__rand_xrange_2__iter__(((struct __pyx_obj_4dnet___rand_xrange *)__pyx_v_self)); /* function exit code */ @@ -17372,7 +24543,7 @@ static PyObject *__pyx_pw_4dnet_13__rand_xrange_3__iter__(PyObject *__pyx_v_self static PyObject *__pyx_pf_4dnet_13__rand_xrange_2__iter__(struct __pyx_obj_4dnet___rand_xrange *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__iter__", 0); + __Pyx_RefNannySetupContext("__iter__", 1); /* "dnet.pyx":1447 * @@ -17392,7 +24563,7 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_2__iter__(struct __pyx_obj_4dnet * def __len__(self): */ __Pyx_XDECREF(__pyx_r); - __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_INCREF((PyObject *)__pyx_v_self); __pyx_r = ((PyObject *)__pyx_v_self); goto __pyx_L0; @@ -17422,9 +24593,11 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_2__iter__(struct __pyx_obj_4dnet /* Python wrapper */ static Py_ssize_t __pyx_pw_4dnet_13__rand_xrange_5__len__(PyObject *__pyx_v_self); /*proto*/ static Py_ssize_t __pyx_pw_4dnet_13__rand_xrange_5__len__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; Py_ssize_t __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_13__rand_xrange_4__len__(((struct __pyx_obj_4dnet___rand_xrange *)__pyx_v_self)); /* function exit code */ @@ -17434,8 +24607,6 @@ static Py_ssize_t __pyx_pw_4dnet_13__rand_xrange_5__len__(PyObject *__pyx_v_self static Py_ssize_t __pyx_pf_4dnet_13__rand_xrange_4__len__(struct __pyx_obj_4dnet___rand_xrange *__pyx_v_self) { Py_ssize_t __pyx_r; - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__len__", 0); /* "dnet.pyx":1452 * @@ -17457,7 +24628,6 @@ static Py_ssize_t __pyx_pf_4dnet_13__rand_xrange_4__len__(struct __pyx_obj_4dnet /* function exit code */ __pyx_L0:; - __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -17472,9 +24642,11 @@ static Py_ssize_t __pyx_pf_4dnet_13__rand_xrange_4__len__(struct __pyx_obj_4dnet /* Python wrapper */ static PyObject *__pyx_pw_4dnet_13__rand_xrange_7__next__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_13__rand_xrange_7__next__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__next__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_13__rand_xrange_6__next__(((struct __pyx_obj_4dnet___rand_xrange *)__pyx_v_self)); /* function exit code */ @@ -17488,6 +24660,7 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_6__next__(struct __pyx_obj_4dnet CYTHON_UNUSED long __pyx_v_i; PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations + int __pyx_error_without_exception = 0; /* StopIteration */ int __pyx_t_1; unsigned long __pyx_t_2; int __pyx_t_3; @@ -17495,7 +24668,7 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_6__next__(struct __pyx_obj_4dnet int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__next__", 0); + __Pyx_RefNannySetupContext("__next__", 1); /* "dnet.pyx":1457 * cdef unsigned long c, sum @@ -17504,7 +24677,7 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_6__next__(struct __pyx_obj_4dnet * raise StopIteration * self.cur = self.cur + 1 */ - __pyx_t_1 = ((__pyx_v_self->cur == __pyx_v_self->max) != 0); + __pyx_t_1 = (__pyx_v_self->cur == __pyx_v_self->max); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":1458 @@ -17514,8 +24687,8 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_6__next__(struct __pyx_obj_4dnet * self.cur = self.cur + 1 * while 1: */ - __Pyx_Raise(__pyx_builtin_StopIteration, 0, 0, 0); - __PYX_ERR(0, 1458, __pyx_L1_error) + __pyx_error_without_exception = 1; + goto __pyx_L1_error;; /* "dnet.pyx":1457 * cdef unsigned long c, sum @@ -17635,7 +24808,7 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_6__next__(struct __pyx_obj_4dnet * break * return self.start + c */ - __pyx_t_1 = ((__pyx_v_c < __pyx_v_self->max) != 0); + __pyx_t_1 = (__pyx_v_c < __pyx_v_self->max); if (__pyx_t_1) { /* "dnet.pyx":1471 @@ -17683,7 +24856,9 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_6__next__(struct __pyx_obj_4dnet /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_4); - __Pyx_AddTraceback("dnet.__rand_xrange.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (!__pyx_error_without_exception) { + __Pyx_AddTraceback("dnet.__rand_xrange.__next__", __pyx_clineno, __pyx_lineno, __pyx_filename); + } __pyx_r = NULL; __pyx_L0:; __Pyx_XGIVEREF(__pyx_r); @@ -17693,16 +24868,44 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_6__next__(struct __pyx_obj_4dnet /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_13__rand_xrange_9__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_13__rand_xrange_9__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_13__rand_xrange_9__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_13__rand_xrange_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_13__rand_xrange_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_13__rand_xrange_9__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_13__rand_xrange_8__reduce_cython__(((struct __pyx_obj_4dnet___rand_xrange *)__pyx_v_self)); /* function exit code */ @@ -17713,33 +24916,28 @@ static PyObject *__pyx_pw_4dnet_13__rand_xrange_9__reduce_cython__(PyObject *__p static PyObject *__pyx_pf_4dnet_13__rand_xrange_8__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet___rand_xrange *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__39, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_rand_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand 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("dnet.__rand_xrange.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -17749,20 +24947,103 @@ static PyObject *__pyx_pf_4dnet_13__rand_xrange_8__reduce_cython__(CYTHON_UNUSED /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_13__rand_xrange_11__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_13__rand_xrange_11__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_13__rand_xrange_11__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_13__rand_xrange_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_13__rand_xrange_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_13__rand_xrange_11__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_13__rand_xrange_10__setstate_cython__(((struct __pyx_obj_4dnet___rand_xrange *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.__rand_xrange.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_13__rand_xrange_10__setstate_cython__(((struct __pyx_obj_4dnet___rand_xrange *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -17770,33 +25051,28 @@ static PyObject *__pyx_pw_4dnet_13__rand_xrange_11__setstate_cython__(PyObject * static PyObject *__pyx_pf_4dnet_13__rand_xrange_10__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet___rand_xrange *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__40, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_rand_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.__rand_xrange.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -17818,56 +25094,73 @@ static int __pyx_pw_4dnet_3tun_1__init__(PyObject *__pyx_v_self, PyObject *__pyx struct __pyx_obj_4dnet_addr *__pyx_v_src = 0; struct __pyx_obj_4dnet_addr *__pyx_v_dst = 0; PyObject *__pyx_v_mtu = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; int __pyx_r; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); { - static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_src,&__pyx_n_s_dst,&__pyx_n_s_mtu,0}; - PyObject* values[3] = {0,0,0}; - values[2] = ((PyObject *)__pyx_int_1500); - if (unlikely(__pyx_kwds)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_src,&__pyx_n_s_dst,&__pyx_n_s_mtu,0}; + values[2] = __Pyx_Arg_NewRef_VARARGS(((PyObject *)__pyx_int_1500)); + if (__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); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_VARARGS(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_src)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_src)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1501, __pyx_L3_error) else goto __pyx_L5_argtuple_error; CYTHON_FALLTHROUGH; case 1: - if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dst)) != 0)) kw_args--; + if (likely((values[1] = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_dst)) != 0)) { + (void)__Pyx_Arg_NewRef_VARARGS(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1501, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, 1); __PYX_ERR(0, 1501, __pyx_L3_error) } CYTHON_FALLTHROUGH; case 2: if (kw_args > 0) { - PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mtu); - if (value) { values[2] = value; kw_args--; } + PyObject* value = __Pyx_GetKwValue_VARARGS(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_mtu); + if (value) { values[2] = __Pyx_Arg_NewRef_VARARGS(value); kw_args--; } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1501, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(0, 1501, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__init__") < 0)) __PYX_ERR(0, 1501, __pyx_L3_error) } } else { - switch (PyTuple_GET_SIZE(__pyx_args)) { - case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_VARARGS(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); - values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 2: values[1] = __Pyx_Arg_VARARGS(__pyx_args, 1); + values[0] = __Pyx_Arg_VARARGS(__pyx_args, 0); break; default: goto __pyx_L5_argtuple_error; } @@ -17876,10 +25169,18 @@ static int __pyx_pw_4dnet_3tun_1__init__(PyObject *__pyx_v_self, PyObject *__pyx __pyx_v_dst = ((struct __pyx_obj_4dnet_addr *)values[1]); __pyx_v_mtu = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 1501, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__init__", 0, 2, 3, __pyx_nargs); __PYX_ERR(0, 1501, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.tun.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return -1; @@ -17893,6 +25194,12 @@ static int __pyx_pw_4dnet_3tun_1__init__(PyObject *__pyx_v_self, PyObject *__pyx __pyx_L1_error:; __pyx_r = -1; __pyx_L0:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_VARARGS(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -17906,7 +25213,7 @@ static int __pyx_pf_4dnet_3tun___init__(struct __pyx_obj_4dnet_tun *__pyx_v_self int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__init__", 0); + __Pyx_RefNannySetupContext("__init__", 1); /* "dnet.pyx":1502 * @@ -17935,7 +25242,7 @@ static int __pyx_pf_4dnet_3tun___init__(struct __pyx_obj_4dnet_tun *__pyx_v_self * raise OSError, __oserror() * self.buf = malloc(mtu) */ - __pyx_t_2 = ((!(__pyx_v_self->tun != 0)) != 0); + __pyx_t_2 = (!(__pyx_v_self->tun != 0)); if (unlikely(__pyx_t_2)) { /* "dnet.pyx":1505 @@ -18001,9 +25308,11 @@ static int __pyx_pf_4dnet_3tun___init__(struct __pyx_obj_4dnet_tun *__pyx_v_self /* Python wrapper */ static PyObject *__pyx_pw_4dnet_3tun_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_3tun_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_3tun_4name___get__(((struct __pyx_obj_4dnet_tun *)__pyx_v_self)); /* function exit code */ @@ -18018,7 +25327,7 @@ static PyObject *__pyx_pf_4dnet_3tun_4name___get__(struct __pyx_obj_4dnet_tun *_ int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "dnet.pyx":1511 * """Tunnel interface name.""" @@ -18064,9 +25373,11 @@ static PyObject *__pyx_pf_4dnet_3tun_4name___get__(struct __pyx_obj_4dnet_tun *_ /* Python wrapper */ static PyObject *__pyx_pw_4dnet_3tun_2fd_1__get__(PyObject *__pyx_v_self); /*proto*/ static PyObject *__pyx_pw_4dnet_3tun_2fd_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_r = __pyx_pf_4dnet_3tun_2fd___get__(((struct __pyx_obj_4dnet_tun *)__pyx_v_self)); /* function exit code */ @@ -18081,7 +25392,7 @@ static PyObject *__pyx_pf_4dnet_3tun_2fd___get__(struct __pyx_obj_4dnet_tun *__p int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_RefNannySetupContext("__get__", 1); /* "dnet.pyx":1516 * """File descriptor for tunnel handle.""" @@ -18125,12 +25436,40 @@ static PyObject *__pyx_pf_4dnet_3tun_2fd___get__(struct __pyx_obj_4dnet_tun *__p */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3tun_3fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_4dnet_3tun_2fileno[] = "Return file descriptor for tunnel handle."; -static PyObject *__pyx_pw_4dnet_3tun_3fileno(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_3tun_3fileno(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3tun_2fileno, "Return file descriptor for tunnel handle."); +static PyMethodDef __pyx_mdef_4dnet_3tun_3fileno = {"fileno", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_3fileno, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3tun_2fileno}; +static PyObject *__pyx_pw_4dnet_3tun_3fileno(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("fileno (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("fileno", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "fileno", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_3tun_2fileno(((struct __pyx_obj_4dnet_tun *)__pyx_v_self)); /* function exit code */ @@ -18145,7 +25484,7 @@ static PyObject *__pyx_pf_4dnet_3tun_2fileno(struct __pyx_obj_4dnet_tun *__pyx_v int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("fileno", 0); + __Pyx_RefNannySetupContext("fileno", 1); /* "dnet.pyx":1520 * def fileno(self): @@ -18189,15 +25528,98 @@ static PyObject *__pyx_pf_4dnet_3tun_2fileno(struct __pyx_obj_4dnet_tun *__pyx_v */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3tun_5send(PyObject *__pyx_v_self, PyObject *__pyx_v_pkt); /*proto*/ -static char __pyx_doc_4dnet_3tun_4send[] = "Send an IP packet, returning the number of bytes sent\n or -1 on failure.\n\n Arguments:\n pkt -- binary string representing an IP packet\n "; -static PyObject *__pyx_pw_4dnet_3tun_5send(PyObject *__pyx_v_self, PyObject *__pyx_v_pkt) { +static PyObject *__pyx_pw_4dnet_3tun_5send(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3tun_4send, "Send an IP packet, returning the number of bytes sent\n or -1 on failure.\n\n Arguments:\n pkt -- binary string representing an IP packet\n "); +static PyMethodDef __pyx_mdef_4dnet_3tun_5send = {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_5send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3tun_4send}; +static PyObject *__pyx_pw_4dnet_3tun_5send(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_pkt = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("send (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_3tun_4send(((struct __pyx_obj_4dnet_tun *)__pyx_v_self), ((PyObject *)__pyx_v_pkt)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pkt,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pkt)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1522, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "send") < 0)) __PYX_ERR(0, 1522, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v_pkt = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("send", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 1522, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.tun.send", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_3tun_4send(((struct __pyx_obj_4dnet_tun *)__pyx_v_self), __pyx_v_pkt); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -18210,7 +25632,7 @@ static PyObject *__pyx_pf_4dnet_3tun_4send(struct __pyx_obj_4dnet_tun *__pyx_v_s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("send", 0); + __Pyx_RefNannySetupContext("send", 1); /* "dnet.pyx":1529 * pkt -- binary string representing an IP packet @@ -18255,12 +25677,40 @@ static PyObject *__pyx_pf_4dnet_3tun_4send(struct __pyx_obj_4dnet_tun *__pyx_v_s */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3tun_7recv(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static char __pyx_doc_4dnet_3tun_6recv[] = "Return the next packet delivered to the tunnel interface."; -static PyObject *__pyx_pw_4dnet_3tun_7recv(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_3tun_7recv(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4dnet_3tun_6recv, "Return the next packet delivered to the tunnel interface."); +static PyMethodDef __pyx_mdef_4dnet_3tun_7recv = {"recv", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_7recv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3tun_6recv}; +static PyObject *__pyx_pw_4dnet_3tun_7recv(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("recv (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("recv", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "recv", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_3tun_6recv(((struct __pyx_obj_4dnet_tun *)__pyx_v_self)); /* function exit code */ @@ -18277,7 +25727,7 @@ static PyObject *__pyx_pf_4dnet_3tun_6recv(struct __pyx_obj_4dnet_tun *__pyx_v_s int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("recv", 0); + __Pyx_RefNannySetupContext("recv", 1); /* "dnet.pyx":1534 * """Return the next packet delivered to the tunnel interface.""" @@ -18295,7 +25745,7 @@ static PyObject *__pyx_pf_4dnet_3tun_6recv(struct __pyx_obj_4dnet_tun *__pyx_v_s * raise OSError, __oserror() * return PyBytes_FromStringAndSize(self.buf, n) */ - __pyx_t_1 = ((__pyx_v_n < 0) != 0); + __pyx_t_1 = (__pyx_v_n < 0); if (unlikely(__pyx_t_1)) { /* "dnet.pyx":1536 @@ -18362,11 +25812,39 @@ static PyObject *__pyx_pf_4dnet_3tun_6recv(struct __pyx_obj_4dnet_tun *__pyx_v_s */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3tun_9close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_3tun_9close(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_3tun_9close(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_3tun_9close = {"close", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_9close, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_3tun_9close(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("close (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("close", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "close", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_3tun_8close(((struct __pyx_obj_4dnet_tun *)__pyx_v_self)); /* function exit code */ @@ -18377,7 +25855,7 @@ static PyObject *__pyx_pw_4dnet_3tun_9close(PyObject *__pyx_v_self, CYTHON_UNUSE static PyObject *__pyx_pf_4dnet_3tun_8close(struct __pyx_obj_4dnet_tun *__pyx_v_self) { PyObject *__pyx_r = NULL; __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("close", 0); + __Pyx_RefNannySetupContext("close", 1); /* "dnet.pyx":1540 * @@ -18414,8 +25892,10 @@ static PyObject *__pyx_pf_4dnet_3tun_8close(struct __pyx_obj_4dnet_tun *__pyx_v_ /* Python wrapper */ static void __pyx_pw_4dnet_3tun_11__dealloc__(PyObject *__pyx_v_self); /*proto*/ static void __pyx_pw_4dnet_3tun_11__dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); __pyx_pf_4dnet_3tun_10__dealloc__(((struct __pyx_obj_4dnet_tun *)__pyx_v_self)); /* function exit code */ @@ -18423,9 +25903,7 @@ static void __pyx_pw_4dnet_3tun_11__dealloc__(PyObject *__pyx_v_self) { } static void __pyx_pf_4dnet_3tun_10__dealloc__(struct __pyx_obj_4dnet_tun *__pyx_v_self) { - __Pyx_RefNannyDeclarations int __pyx_t_1; - __Pyx_RefNannySetupContext("__dealloc__", 0); /* "dnet.pyx":1543 * @@ -18488,21 +25966,48 @@ static void __pyx_pf_4dnet_3tun_10__dealloc__(struct __pyx_obj_4dnet_tun *__pyx_ */ /* function exit code */ - __Pyx_RefNannyFinishContext(); } /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.tun cannot be converted to a Python object for pickling") + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3tun_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ -static PyObject *__pyx_pw_4dnet_3tun_13__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { +static PyObject *__pyx_pw_4dnet_3tun_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_3tun_13__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_3tun_13__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { + __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL;} + if (unlikely(__pyx_kwds) && __Pyx_NumKwargs_FASTCALL(__pyx_kwds) && unlikely(!__Pyx_CheckKeywordStrings(__pyx_kwds, "__reduce_cython__", 0))) return NULL; __pyx_r = __pyx_pf_4dnet_3tun_12__reduce_cython__(((struct __pyx_obj_4dnet_tun *)__pyx_v_self)); /* function exit code */ @@ -18513,33 +26018,28 @@ static PyObject *__pyx_pw_4dnet_3tun_13__reduce_cython__(PyObject *__pyx_v_self, static PyObject *__pyx_pf_4dnet_3tun_12__reduce_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_tun *__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); + __Pyx_RefNannySetupContext("__reduce_cython__", 1); /* "(tree fragment)":2 * def __reduce_cython__(self): - * raise TypeError("self.tun cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.tun cannot be converted to a Python object for pickling") + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__41, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_tun_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 2, __pyx_L1_error) /* "(tree fragment)":1 * def __reduce_cython__(self): # <<<<<<<<<<<<<< - * raise TypeError("self.tun cannot be converted to a Python object for pickling") + * raise TypeError, "self.tun 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("dnet.tun.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -18549,20 +26049,103 @@ static PyObject *__pyx_pf_4dnet_3tun_12__reduce_cython__(CYTHON_UNUSED struct __ /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.tun cannot be converted to a Python object for pickling") + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.tun cannot be converted to a Python object for pickling") + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_3tun_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ -static PyObject *__pyx_pw_4dnet_3tun_15__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { +static PyObject *__pyx_pw_4dnet_3tun_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_3tun_15__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_3tun_15__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); - __pyx_r = __pyx_pf_4dnet_3tun_14__setstate_cython__(((struct __pyx_obj_4dnet_tun *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_state,0}; + if (__pyx_kwds) { + Py_ssize_t kw_args; + switch (__pyx_nargs) { + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { + case 0: + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 3, __pyx_L3_error) + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__setstate_cython__") < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } + __Pyx_AddTraceback("dnet.tun.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_4dnet_3tun_14__setstate_cython__(((struct __pyx_obj_4dnet_tun *)__pyx_v_self), __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -18570,33 +26153,28 @@ static PyObject *__pyx_pw_4dnet_3tun_15__setstate_cython__(PyObject *__pyx_v_sel static PyObject *__pyx_pf_4dnet_3tun_14__setstate_cython__(CYTHON_UNUSED struct __pyx_obj_4dnet_tun *__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); + __Pyx_RefNannySetupContext("__setstate_cython__", 1); /* "(tree fragment)":4 - * raise TypeError("self.tun cannot be converted to a Python object for pickling") + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.tun cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" # <<<<<<<<<<<<<< */ - __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__42, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 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_Raise(__pyx_builtin_TypeError, __pyx_kp_s_self_tun_cannot_be_converted_to, 0, 0); __PYX_ERR(1, 4, __pyx_L1_error) /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.tun cannot be converted to a Python object for pickling") + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< - * raise TypeError("self.tun cannot be converted to a Python object for pickling") + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" */ /* function exit code */ __pyx_L1_error:; - __Pyx_XDECREF(__pyx_t_1); __Pyx_AddTraceback("dnet.tun.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __Pyx_XGIVEREF(__pyx_r); @@ -18611,70 +26189,114 @@ static PyObject *__pyx_pf_4dnet_3tun_14__setstate_cython__(CYTHON_UNUSED struct */ /* Python wrapper */ -static PyObject *__pyx_pw_4dnet_37__pyx_unpickle___addr_ip4_iter(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ -static PyMethodDef __pyx_mdef_4dnet_37__pyx_unpickle___addr_ip4_iter = {"__pyx_unpickle___addr_ip4_iter", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_37__pyx_unpickle___addr_ip4_iter, METH_VARARGS|METH_KEYWORDS, 0}; -static PyObject *__pyx_pw_4dnet_37__pyx_unpickle___addr_ip4_iter(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { +static PyObject *__pyx_pw_4dnet_37__pyx_unpickle___addr_ip4_iter(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4dnet_37__pyx_unpickle___addr_ip4_iter = {"__pyx_unpickle___addr_ip4_iter", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_37__pyx_unpickle___addr_ip4_iter, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4dnet_37__pyx_unpickle___addr_ip4_iter(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { PyObject *__pyx_v___pyx_type = 0; long __pyx_v___pyx_checksum; PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; PyObject *__pyx_r = 0; __Pyx_RefNannyDeclarations __Pyx_RefNannySetupContext("__pyx_unpickle___addr_ip4_iter (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_MACROS + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); { - 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)) { + PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + if (__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); + switch (__pyx_nargs) { + case 3: values[2] = __Pyx_Arg_FASTCALL(__pyx_args, 2); CYTHON_FALLTHROUGH; - case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + case 2: values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); CYTHON_FALLTHROUGH; - case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + case 1: values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); CYTHON_FALLTHROUGH; case 0: break; default: goto __pyx_L5_argtuple_error; } - kw_args = PyDict_Size(__pyx_kwds); - switch (pos_args) { + kw_args = __Pyx_NumKwargs_FASTCALL(__pyx_kwds); + switch (__pyx_nargs) { case 0: - if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + if (likely((values[0] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_type)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[0]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) 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--; + if (likely((values[1] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_checksum)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[1]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle___addr_ip4_iter", 1, 3, 3, 1); __PYX_ERR(1, 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--; + if (likely((values[2] = __Pyx_GetKwValue_FASTCALL(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_pyx_state)) != 0)) { + (void)__Pyx_Arg_NewRef_FASTCALL(values[2]); + kw_args--; + } + else if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) else { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle___addr_ip4_iter", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) } } if (unlikely(kw_args > 0)) { - if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle___addr_ip4_iter") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, "__pyx_unpickle___addr_ip4_iter") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) } - } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + } else if (unlikely(__pyx_nargs != 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); + values[0] = __Pyx_Arg_FASTCALL(__pyx_args, 0); + values[1] = __Pyx_Arg_FASTCALL(__pyx_args, 1); + values[2] = __Pyx_Arg_FASTCALL(__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(1, 1, __pyx_L3_error) __pyx_v___pyx_state = values[2]; } - goto __pyx_L4_argument_unpacking_done; + goto __pyx_L6_skip; __pyx_L5_argtuple_error:; - __Pyx_RaiseArgtupleInvalid("__pyx_unpickle___addr_ip4_iter", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle___addr_ip4_iter", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; __pyx_L3_error:; + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_AddTraceback("dnet.__pyx_unpickle___addr_ip4_iter", __pyx_clineno, __pyx_lineno, __pyx_filename); __Pyx_RefNannyFinishContext(); return NULL; @@ -18682,6 +26304,12 @@ static PyObject *__pyx_pw_4dnet_37__pyx_unpickle___addr_ip4_iter(PyObject *__pyx __pyx_r = __pyx_pf_4dnet_36__pyx_unpickle___addr_ip4_iter(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); /* function exit code */ + { + Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + __Pyx_Arg_XDECREF_FASTCALL(values[__pyx_temp]); + } + } __Pyx_RefNannyFinishContext(); return __pyx_r; } @@ -18693,129 +26321,116 @@ static PyObject *__pyx_pf_4dnet_36__pyx_unpickle___addr_ip4_iter(CYTHON_UNUSED P __Pyx_RefNannyDeclarations PyObject *__pyx_t_1 = NULL; int __pyx_t_2; - int __pyx_t_3; + PyObject *__pyx_t_3 = NULL; PyObject *__pyx_t_4 = NULL; - PyObject *__pyx_t_5 = NULL; - PyObject *__pyx_t_6 = NULL; + int __pyx_t_5; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle___addr_ip4_iter", 0); + __Pyx_RefNannySetupContext("__pyx_unpickle___addr_ip4_iter", 1); /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - * if __pyx_checksum not in (0xd0a7020, 0x6aff466, 0x6c108d3): # <<<<<<<<<<<<<< + * if __pyx_checksum not in (0x6aff466, 0x6c108d3, 0xd0a7020): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xd0a7020, 0x6aff466, 0x6c108d3) = (cur, max))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))" % __pyx_checksum */ __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__43, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__2, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_3 = (__pyx_t_2 != 0); - if (__pyx_t_3) { + if (__pyx_t_2) { /* "(tree fragment)":5 * cdef object __pyx_result - * if __pyx_checksum not in (0xd0a7020, 0x6aff466, 0x6c108d3): + * if __pyx_checksum not in (0x6aff466, 0x6c108d3, 0xd0a7020): * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xd0a7020, 0x6aff466, 0x6c108d3) = (cur, max))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))" % __pyx_checksum * __pyx_result = __addr_ip4_iter.__new__(__pyx_type) */ __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_n_s_PickleError); __Pyx_GIVEREF(__pyx_n_s_PickleError); - PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); - __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_3 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_3, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); __Pyx_INCREF(__pyx_t_1); __pyx_v___pyx_PickleError = __pyx_t_1; __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; /* "(tree fragment)":6 - * if __pyx_checksum not in (0xd0a7020, 0x6aff466, 0x6c108d3): + * if __pyx_checksum not in (0x6aff466, 0x6c108d3, 0xd0a7020): * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xd0a7020, 0x6aff466, 0x6c108d3) = (cur, max))" % __pyx_checksum) # <<<<<<<<<<<<<< + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))" % __pyx_checksum # <<<<<<<<<<<<<< * __pyx_result = __addr_ip4_iter.__new__(__pyx_type) * if __pyx_state is not None: */ - __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_5); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_INCREF(__pyx_v___pyx_PickleError); - __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; - 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_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __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(1, 6, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_v___pyx_PickleError, __pyx_t_1, 0, 0); __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __Pyx_Raise(__pyx_t_4, 0, 0, 0); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __PYX_ERR(1, 6, __pyx_L1_error) /* "(tree fragment)":4 * cdef object __pyx_PickleError * cdef object __pyx_result - * if __pyx_checksum not in (0xd0a7020, 0x6aff466, 0x6c108d3): # <<<<<<<<<<<<<< + * if __pyx_checksum not in (0x6aff466, 0x6c108d3, 0xd0a7020): # <<<<<<<<<<<<<< * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xd0a7020, 0x6aff466, 0x6c108d3) = (cur, max))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))" % __pyx_checksum */ } /* "(tree fragment)":7 * from pickle import PickleError as __pyx_PickleError - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xd0a7020, 0x6aff466, 0x6c108d3) = (cur, max))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))" % __pyx_checksum * __pyx_result = __addr_ip4_iter.__new__(__pyx_type) # <<<<<<<<<<<<<< * if __pyx_state is not None: * __pyx_unpickle___addr_ip4_iter__set_state(<__addr_ip4_iter> __pyx_result, __pyx_state) */ - __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_4dnet___addr_ip4_iter), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_t_5 = NULL; - if (CYTHON_UNPACK_METHODS && likely(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_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_ptype_4dnet___addr_ip4_iter), __pyx_n_s_new); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = NULL; + __pyx_t_5 = 0; + #if CYTHON_UNPACK_METHODS + if (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_1, function); + __Pyx_DECREF_SET(__pyx_t_3, function); + __pyx_t_5 = 1; } } - __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); - __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; - if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; - __pyx_v___pyx_result = __pyx_t_4; - __pyx_t_4 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v___pyx_type}; + __pyx_t_1 = __Pyx_PyObject_FastCall(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_v___pyx_result = __pyx_t_1; + __pyx_t_1 = 0; /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xd0a7020, 0x6aff466, 0x6c108d3) = (cur, max))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))" % __pyx_checksum * __pyx_result = __addr_ip4_iter.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle___addr_ip4_iter__set_state(<__addr_ip4_iter> __pyx_result, __pyx_state) * return __pyx_result */ - __pyx_t_3 = (__pyx_v___pyx_state != Py_None); - __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_2 = (__pyx_v___pyx_state != Py_None); if (__pyx_t_2) { /* "(tree fragment)":9 @@ -18825,13 +26440,13 @@ static PyObject *__pyx_pf_4dnet_36__pyx_unpickle___addr_ip4_iter(CYTHON_UNUSED P * return __pyx_result * cdef __pyx_unpickle___addr_ip4_iter__set_state(__addr_ip4_iter __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(1, 9, __pyx_L1_error) - __pyx_t_4 = __pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(((struct __pyx_obj_4dnet___addr_ip4_iter *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_4); - __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_v___pyx_state))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_1 = __pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(((struct __pyx_obj_4dnet___addr_ip4_iter *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; /* "(tree fragment)":8 - * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xd0a7020, 0x6aff466, 0x6c108d3) = (cur, max))" % __pyx_checksum) + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))" % __pyx_checksum * __pyx_result = __addr_ip4_iter.__new__(__pyx_type) * if __pyx_state is not None: # <<<<<<<<<<<<<< * __pyx_unpickle___addr_ip4_iter__set_state(<__addr_ip4_iter> __pyx_result, __pyx_state) @@ -18860,9 +26475,8 @@ static PyObject *__pyx_pf_4dnet_36__pyx_unpickle___addr_ip4_iter(CYTHON_UNUSED P /* function exit code */ __pyx_L1_error:; __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __Pyx_XDECREF(__pyx_t_4); - __Pyx_XDECREF(__pyx_t_5); - __Pyx_XDECREF(__pyx_t_6); __Pyx_AddTraceback("dnet.__pyx_unpickle___addr_ip4_iter", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = NULL; __pyx_L0:; @@ -18888,14 +26502,14 @@ static PyObject *__pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(struct int __pyx_t_2; Py_ssize_t __pyx_t_3; int __pyx_t_4; - int __pyx_t_5; + PyObject *__pyx_t_5 = NULL; PyObject *__pyx_t_6 = NULL; PyObject *__pyx_t_7 = NULL; - PyObject *__pyx_t_8 = NULL; + int __pyx_t_8; int __pyx_lineno = 0; const char *__pyx_filename = NULL; int __pyx_clineno = 0; - __Pyx_RefNannySetupContext("__pyx_unpickle___addr_ip4_iter__set_state", 0); + __Pyx_RefNannySetupContext("__pyx_unpickle___addr_ip4_iter__set_state", 1); /* "(tree fragment)":12 * return __pyx_result @@ -18927,16 +26541,15 @@ static PyObject *__pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(struct PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); __PYX_ERR(1, 13, __pyx_L1_error) } - __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) - __pyx_t_4 = ((__pyx_t_3 > 2) != 0); + __pyx_t_3 = __Pyx_PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = (__pyx_t_3 > 2); if (__pyx_t_4) { } else { __pyx_t_2 = __pyx_t_4; goto __pyx_L4_bool_binop_done; } __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) - __pyx_t_5 = (__pyx_t_4 != 0); - __pyx_t_2 = __pyx_t_5; + __pyx_t_2 = __pyx_t_4; __pyx_L4_bool_binop_done:; if (__pyx_t_2) { @@ -18945,31 +26558,38 @@ static PyObject *__pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(struct * if len(__pyx_state) > 2 and hasattr(__pyx_result, '__dict__'): * __pyx_result.__dict__.update(__pyx_state[2]) # <<<<<<<<<<<<<< */ - __pyx_t_7 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 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(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_8); - __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; if (unlikely(__pyx_v___pyx_state == Py_None)) { PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); __PYX_ERR(1, 14, __pyx_L1_error) } - __pyx_t_7 = NULL; - if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_8))) { - __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); - if (likely(__pyx_t_7)) { - PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_8); - __Pyx_INCREF(__pyx_t_7); + __pyx_t_6 = NULL; + __pyx_t_8 = 0; + #if CYTHON_UNPACK_METHODS + if (likely(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_8, function); + __Pyx_DECREF_SET(__pyx_t_7, function); + __pyx_t_8 = 1; } } - __pyx_t_6 = (__pyx_t_7) ? __Pyx_PyObject_Call2Args(__pyx_t_8, __pyx_t_7, PyTuple_GET_ITEM(__pyx_v___pyx_state, 2)) : __Pyx_PyObject_CallOneArg(__pyx_t_8, PyTuple_GET_ITEM(__pyx_v___pyx_state, 2)); - __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; - if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_6); - __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; - __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, PyTuple_GET_ITEM(__pyx_v___pyx_state, 2)}; + __pyx_t_5 = __Pyx_PyObject_FastCall(__pyx_t_7, __pyx_callargs+1-__pyx_t_8, 1+__pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; /* "(tree fragment)":13 * cdef __pyx_unpickle___addr_ip4_iter__set_state(__addr_ip4_iter __pyx_result, tuple __pyx_state): @@ -18991,9 +26611,9 @@ static PyObject *__pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(struct __pyx_r = Py_None; __Pyx_INCREF(Py_None); goto __pyx_L0; __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); __Pyx_XDECREF(__pyx_t_6); __Pyx_XDECREF(__pyx_t_7); - __Pyx_XDECREF(__pyx_t_8); __Pyx_AddTraceback("dnet.__pyx_unpickle___addr_ip4_iter__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); __pyx_r = 0; __pyx_L0:; @@ -19004,19 +26624,26 @@ static PyObject *__pyx_f_4dnet___pyx_unpickle___addr_ip4_iter__set_state(struct static PyObject *__pyx_tp_new_4dnet_eth(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_eth(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_eth) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -19027,21 +26654,45 @@ static void __pyx_tp_dealloc_4dnet_eth(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyMethodDef __pyx_methods_4dnet_eth[] = { - {"get", (PyCFunction)__pyx_pw_4dnet_3eth_3get, METH_NOARGS, __pyx_doc_4dnet_3eth_2get}, - {"set", (PyCFunction)__pyx_pw_4dnet_3eth_5set, METH_O, __pyx_doc_4dnet_3eth_4set}, - {"send", (PyCFunction)__pyx_pw_4dnet_3eth_7send, METH_O, __pyx_doc_4dnet_3eth_6send}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_3eth_11__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_3eth_13__setstate_cython__, METH_O, 0}, + {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_3get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3eth_2get}, + {"set", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_5set, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3eth_4set}, + {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_7send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3eth_6send}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_11__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3eth_13__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_eth_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_eth}, + {Py_tp_doc, (void *)PyDoc_STR("eth(device) -> Ethernet device object\n\n Open the specified Ethernet device for sending.\n ")}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_eth}, + {Py_tp_init, (void *)__pyx_pw_4dnet_3eth_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_eth}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_eth_spec = { + "dnet.eth", + sizeof(struct __pyx_obj_4dnet_eth), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_eth_slots, +}; +#else static PyTypeObject __pyx_type_4dnet_eth = { PyVarObject_HEAD_INIT(0, 0) - "dnet.eth", /*tp_name*/ + "dnet.""eth", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_eth), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_eth, /*tp_dealloc*/ @@ -19070,7 +26721,7 @@ static PyTypeObject __pyx_type_4dnet_eth = { 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*/ - "eth(device) -> Ethernet device object\n\n Open the specified Ethernet device for sending.\n ", /*tp_doc*/ + PyDoc_STR("eth(device) -> Ethernet device object\n\n Open the specified Ethernet device for sending.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -19084,7 +26735,9 @@ static PyTypeObject __pyx_type_4dnet_eth = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_3eth_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_eth, /*tp_new*/ @@ -19098,34 +26751,49 @@ static PyTypeObject __pyx_type_4dnet_eth = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet_ip(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_ip(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_ip) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -19136,19 +26804,43 @@ static void __pyx_tp_dealloc_4dnet_ip(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyMethodDef __pyx_methods_4dnet_ip[] = { - {"send", (PyCFunction)__pyx_pw_4dnet_2ip_3send, METH_O, __pyx_doc_4dnet_2ip_2send}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_2ip_7__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_2ip_9__setstate_cython__, METH_O, 0}, + {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2ip_3send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2ip_2send}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2ip_7__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2ip_9__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_ip_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_ip}, + {Py_tp_doc, (void *)PyDoc_STR("ip() -> Raw IP object\n\n Open a raw IP socket for sending.\n ")}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_ip}, + {Py_tp_init, (void *)__pyx_pw_4dnet_2ip_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_ip}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_ip_spec = { + "dnet.ip", + sizeof(struct __pyx_obj_4dnet_ip), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_ip_slots, +}; +#else static PyTypeObject __pyx_type_4dnet_ip = { PyVarObject_HEAD_INIT(0, 0) - "dnet.ip", /*tp_name*/ + "dnet.""ip", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_ip), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_ip, /*tp_dealloc*/ @@ -19177,7 +26869,7 @@ static PyTypeObject __pyx_type_4dnet_ip = { 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*/ - "ip() -> Raw IP object\n\n Open a raw IP socket for sending.\n ", /*tp_doc*/ + PyDoc_STR("ip() -> Raw IP object\n\n Open a raw IP socket for sending.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -19191,7 +26883,9 @@ static PyTypeObject __pyx_type_4dnet_ip = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_2ip_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_ip, /*tp_new*/ @@ -19205,37 +26899,59 @@ static PyTypeObject __pyx_type_4dnet_ip = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet_addr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_addr(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_addr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyObject *__pyx_tp_richcompare_4dnet_addr(PyObject *o1, PyObject *o2, int op) { @@ -19264,6 +26980,41 @@ static PyObject *__pyx_tp_richcompare_4dnet_addr(PyObject *o1, PyObject *o2, int } } +static CYTHON_INLINE PyObject *__pyx_nb_add_4dnet_addr_maybe_call_slot(PyTypeObject* type, PyObject *left, PyObject *right ) { + binaryfunc slot; +#if CYTHON_USE_TYPE_SLOTS || PY_MAJOR_VERSION < 3 || CYTHON_COMPILING_IN_PYPY + slot = type->tp_as_number ? type->tp_as_number->nb_add : NULL; +#else + slot = (binaryfunc) PyType_GetSlot(type, Py_nb_add); +#endif + return slot ? slot(left, right ) : __Pyx_NewRef(Py_NotImplemented); +} +static PyObject *__pyx_nb_add_4dnet_addr(PyObject *left, PyObject *right ) { + int maybe_self_is_left, maybe_self_is_right = 0; + maybe_self_is_left = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(left)->tp_as_number && Py_TYPE(left)->tp_as_number->nb_add == &__pyx_nb_add_4dnet_addr) +#endif + || __Pyx_TypeCheck(left, __pyx_ptype_4dnet_addr); + if (maybe_self_is_left) { + PyObject *res; + res = __pyx_pw_4dnet_4addr_7__add__(left, right); + if (res != Py_NotImplemented) return res; + Py_DECREF(res); + } + maybe_self_is_right = Py_TYPE(left) == Py_TYPE(right) +#if CYTHON_USE_TYPE_SLOTS + || (Py_TYPE(right)->tp_as_number && Py_TYPE(right)->tp_as_number->nb_add == &__pyx_nb_add_4dnet_addr) +#endif + || PyType_IsSubtype(Py_TYPE(right), __pyx_ptype_4dnet_addr); + if (maybe_self_is_right) { + return __pyx_nb_add_4dnet_addr_maybe_call_slot(__Pyx_PyType_GetSlot(__pyx_ptype_4dnet_addr, tp_base, PyTypeObject*), left, right ); + } + return __Pyx_NewRef(Py_NotImplemented); +} + + + static PyObject *__pyx_getprop_4dnet_4addr_addrtype(PyObject *o, CYTHON_UNUSED void *x) { return __pyx_pw_4dnet_4addr_8addrtype_1__get__(o); } @@ -19338,27 +27089,60 @@ static int __pyx_setprop_4dnet_4addr_ip6(PyObject *o, PyObject *v, CYTHON_UNUSED } } +static PyObject *__pyx_specialmethod___pyx_pw_4dnet_4addr_33__repr__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + return __pyx_pw_4dnet_4addr_33__repr__(self); +} + static PyMethodDef __pyx_methods_4dnet_addr[] = { - {"bcast", (PyCFunction)__pyx_pw_4dnet_4addr_3bcast, METH_NOARGS, __pyx_doc_4dnet_4addr_2bcast}, - {"net", (PyCFunction)__pyx_pw_4dnet_4addr_5net, METH_NOARGS, __pyx_doc_4dnet_4addr_4net}, - {"__copy__", (PyCFunction)__pyx_pw_4dnet_4addr_9__copy__, METH_NOARGS, 0}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_4addr_35__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_4addr_37__setstate_cython__, METH_O, 0}, + {"bcast", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_3bcast, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4addr_2bcast}, + {"net", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_5net, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4addr_4net}, + {"__copy__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_9__copy__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__repr__", (PyCFunction)__pyx_specialmethod___pyx_pw_4dnet_4addr_33__repr__, METH_NOARGS|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_35__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4addr_37__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_4dnet_addr[] = { - {(char *)"addrtype", __pyx_getprop_4dnet_4addr_addrtype, __pyx_setprop_4dnet_4addr_addrtype, (char *)"Address type (ADDR_TYPE_*) integer.", 0}, - {(char *)"bits", __pyx_getprop_4dnet_4addr_bits, __pyx_setprop_4dnet_4addr_bits, (char *)"Address bitlength integer.", 0}, - {(char *)"data", __pyx_getprop_4dnet_4addr_data, 0, (char *)"Raw address string.", 0}, - {(char *)"eth", __pyx_getprop_4dnet_4addr_eth, __pyx_setprop_4dnet_4addr_eth, (char *)"Ethernet MAC address as binary string.", 0}, - {(char *)"ip", __pyx_getprop_4dnet_4addr_ip, __pyx_setprop_4dnet_4addr_ip, (char *)"IPv4 address as binary string.", 0}, - {(char *)"ip6", __pyx_getprop_4dnet_4addr_ip6, __pyx_setprop_4dnet_4addr_ip6, (char *)"IPv6 address as binary string.", 0}, + {(char *)"addrtype", __pyx_getprop_4dnet_4addr_addrtype, __pyx_setprop_4dnet_4addr_addrtype, (char *)PyDoc_STR("Address type (ADDR_TYPE_*) integer."), 0}, + {(char *)"bits", __pyx_getprop_4dnet_4addr_bits, __pyx_setprop_4dnet_4addr_bits, (char *)PyDoc_STR("Address bitlength integer."), 0}, + {(char *)"data", __pyx_getprop_4dnet_4addr_data, 0, (char *)PyDoc_STR("Raw address string."), 0}, + {(char *)"eth", __pyx_getprop_4dnet_4addr_eth, __pyx_setprop_4dnet_4addr_eth, (char *)PyDoc_STR("Ethernet MAC address as binary string."), 0}, + {(char *)"ip", __pyx_getprop_4dnet_4addr_ip, __pyx_setprop_4dnet_4addr_ip, (char *)PyDoc_STR("IPv4 address as binary string."), 0}, + {(char *)"ip6", __pyx_getprop_4dnet_4addr_ip6, __pyx_setprop_4dnet_4addr_ip6, (char *)PyDoc_STR("IPv6 address as binary string."), 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_addr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_addr}, + {Py_tp_repr, (void *)__pyx_pw_4dnet_4addr_33__repr__}, + {Py_nb_add, (void *)__pyx_nb_add_4dnet_addr}, + {Py_nb_int, (void *)__pyx_pw_4dnet_4addr_27__int__}, + #if PY_MAJOR_VERSION < 3 + {Py_nb_long, (void *)__pyx_pw_4dnet_4addr_29__long__}, + #endif + {Py_sq_contains, (void *)__pyx_pw_4dnet_4addr_23__contains__}, + {Py_tp_hash, (void *)__pyx_pw_4dnet_4addr_25__hash__}, + {Py_tp_doc, (void *)PyDoc_STR("addr(addrtxt=None, addrtype=ADDR_TYPE_NONE) -> network address object\n\n Create a network address object, optionally initialized from a\n human-readable Ethernet, IP, or IPv6 address string.\n ")}, + {Py_tp_richcompare, (void *)__pyx_tp_richcompare_4dnet_addr}, + {Py_tp_iter, (void *)__pyx_pw_4dnet_4addr_31__iter__}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_addr}, + {Py_tp_getset, (void *)__pyx_getsets_4dnet_addr}, + {Py_tp_init, (void *)__pyx_pw_4dnet_4addr_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_addr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_addr_spec = { + "dnet.addr", + sizeof(struct __pyx_obj_4dnet_addr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_addr_slots, +}; +#else static PyNumberMethods __pyx_tp_as_number_addr = { - __pyx_pw_4dnet_4addr_7__add__, /*nb_add*/ + __pyx_nb_add_4dnet_addr, /*nb_add*/ 0, /*nb_subtract*/ 0, /*nb_multiply*/ #if PY_MAJOR_VERSION < 3 || (CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03050000) @@ -19370,7 +27154,7 @@ static PyNumberMethods __pyx_tp_as_number_addr = { 0, /*nb_negative*/ 0, /*nb_positive*/ 0, /*nb_absolute*/ - 0, /*nb_nonzero*/ + 0, /*nb_bool*/ 0, /*nb_invert*/ 0, /*nb_lshift*/ 0, /*nb_rshift*/ @@ -19434,7 +27218,7 @@ static PySequenceMethods __pyx_tp_as_sequence_addr = { static PyTypeObject __pyx_type_4dnet_addr = { PyVarObject_HEAD_INIT(0, 0) - "dnet.addr", /*tp_name*/ + "dnet.""addr", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_addr), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_addr, /*tp_dealloc*/ @@ -19463,7 +27247,7 @@ static PyTypeObject __pyx_type_4dnet_addr = { 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*/ - "addr(addrtxt=None, addrtype=ADDR_TYPE_NONE) -> network address object\n\n Create a network address object, optionally initialized from a\n human-readable Ethernet, IP, or IPv6 address string.\n ", /*tp_doc*/ + PyDoc_STR("addr(addrtxt=None, addrtype=ADDR_TYPE_NONE) -> network address object\n\n Create a network address object, optionally initialized from a\n human-readable Ethernet, IP, or IPv6 address string.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ __pyx_tp_richcompare_4dnet_addr, /*tp_richcompare*/ @@ -19477,7 +27261,9 @@ static PyTypeObject __pyx_type_4dnet_addr = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_4addr_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_addr, /*tp_new*/ @@ -19491,51 +27277,94 @@ static PyTypeObject __pyx_type_4dnet_addr = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet___addr_ip4_iter(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet___addr_ip4_iter(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet___addr_ip4_iter) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } -static PyObject *__pyx_specialmethod___pyx_pw_4dnet_15__addr_ip4_iter_3__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) {return __pyx_pw_4dnet_15__addr_ip4_iter_3__next__(self);} +static PyObject *__pyx_specialmethod___pyx_pw_4dnet_15__addr_ip4_iter_3__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + PyObject *res = __pyx_pw_4dnet_15__addr_ip4_iter_3__next__(self); + if (!res && !PyErr_Occurred()) { PyErr_SetNone(PyExc_StopIteration); } + return res; +} static PyMethodDef __pyx_methods_4dnet___addr_ip4_iter[] = { {"__next__", (PyCFunction)__pyx_specialmethod___pyx_pw_4dnet_15__addr_ip4_iter_3__next__, METH_NOARGS|METH_COEXIST, 0}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_15__addr_ip4_iter_5__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_15__addr_ip4_iter_7__setstate_cython__, METH_O, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_15__addr_ip4_iter_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_15__addr_ip4_iter_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet___addr_ip4_iter_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet___addr_ip4_iter}, + {Py_tp_iternext, (void *)__pyx_pw_4dnet_15__addr_ip4_iter_3__next__}, + {Py_tp_methods, (void *)__pyx_methods_4dnet___addr_ip4_iter}, + {Py_tp_init, (void *)__pyx_pw_4dnet_15__addr_ip4_iter_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet___addr_ip4_iter}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet___addr_ip4_iter_spec = { + "dnet.__addr_ip4_iter", + sizeof(struct __pyx_obj_4dnet___addr_ip4_iter), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet___addr_ip4_iter_slots, +}; +#else static PyTypeObject __pyx_type_4dnet___addr_ip4_iter = { PyVarObject_HEAD_INIT(0, 0) - "dnet.__addr_ip4_iter", /*tp_name*/ + "dnet.""__addr_ip4_iter", /*tp_name*/ sizeof(struct __pyx_obj_4dnet___addr_ip4_iter), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet___addr_ip4_iter, /*tp_dealloc*/ @@ -19578,7 +27407,9 @@ static PyTypeObject __pyx_type_4dnet___addr_ip4_iter = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_15__addr_ip4_iter_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet___addr_ip4_iter, /*tp_new*/ @@ -19592,34 +27423,49 @@ static PyTypeObject __pyx_type_4dnet___addr_ip4_iter = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet_arp(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_arp(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_arp) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -19630,22 +27476,47 @@ static void __pyx_tp_dealloc_4dnet_arp(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyMethodDef __pyx_methods_4dnet_arp[] = { - {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_3arp_3add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_3arp_2add}, - {"delete", (PyCFunction)__pyx_pw_4dnet_3arp_5delete, METH_O, __pyx_doc_4dnet_3arp_4delete}, - {"get", (PyCFunction)__pyx_pw_4dnet_3arp_7get, METH_O, __pyx_doc_4dnet_3arp_6get}, - {"loop", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_3arp_9loop, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_3arp_8loop}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_3arp_15__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_3arp_17__setstate_cython__, METH_O, 0}, + {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_3add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3arp_2add}, + {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_5delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3arp_4delete}, + {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_7get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3arp_6get}, + {"loop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_9loop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3arp_8loop}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3arp_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_arp_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_arp}, + {Py_tp_doc, (void *)PyDoc_STR("arp() -> ARP table object\n\n Open a handle to the system ARP table.\n ")}, + {Py_tp_iter, (void *)__pyx_pw_4dnet_3arp_11__iter__}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_arp}, + {Py_tp_init, (void *)__pyx_pw_4dnet_3arp_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_arp}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_arp_spec = { + "dnet.arp", + sizeof(struct __pyx_obj_4dnet_arp), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_arp_slots, +}; +#else static PyTypeObject __pyx_type_4dnet_arp = { PyVarObject_HEAD_INIT(0, 0) - "dnet.arp", /*tp_name*/ + "dnet.""arp", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_arp), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_arp, /*tp_dealloc*/ @@ -19674,7 +27545,7 @@ static PyTypeObject __pyx_type_4dnet_arp = { 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*/ - "arp() -> ARP table object\n\n Open a handle to the system ARP table.\n ", /*tp_doc*/ + PyDoc_STR("arp() -> ARP table object\n\n Open a handle to the system ARP table.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -19688,7 +27559,9 @@ static PyTypeObject __pyx_type_4dnet_arp = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_3arp_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_arp, /*tp_new*/ @@ -19702,34 +27575,49 @@ static PyTypeObject __pyx_type_4dnet_arp = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet_intf(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_intf(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_intf) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -19740,23 +27628,48 @@ static void __pyx_tp_dealloc_4dnet_intf(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyMethodDef __pyx_methods_4dnet_intf[] = { - {"get", (PyCFunction)__pyx_pw_4dnet_4intf_3get, METH_O, __pyx_doc_4dnet_4intf_2get}, - {"get_src", (PyCFunction)__pyx_pw_4dnet_4intf_5get_src, METH_O, __pyx_doc_4dnet_4intf_4get_src}, - {"get_dst", (PyCFunction)__pyx_pw_4dnet_4intf_7get_dst, METH_O, __pyx_doc_4dnet_4intf_6get_dst}, - {"set", (PyCFunction)__pyx_pw_4dnet_4intf_9set, METH_O, __pyx_doc_4dnet_4intf_8set}, - {"loop", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_4intf_11loop, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_4intf_10loop}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_4intf_17__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_4intf_19__setstate_cython__, METH_O, 0}, + {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_3get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_2get}, + {"get_src", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_5get_src, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_4get_src}, + {"get_dst", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_7get_dst, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_6get_dst}, + {"set", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_9set, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_8set}, + {"loop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_11loop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4intf_10loop}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_17__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4intf_19__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_intf_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_intf}, + {Py_tp_doc, (void *)PyDoc_STR("intf() -> Interface table object\n\n Open a handle to the system network interface table.\n ")}, + {Py_tp_iter, (void *)__pyx_pw_4dnet_4intf_13__iter__}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_intf}, + {Py_tp_init, (void *)__pyx_pw_4dnet_4intf_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_intf}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_intf_spec = { + "dnet.intf", + sizeof(struct __pyx_obj_4dnet_intf), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_intf_slots, +}; +#else static PyTypeObject __pyx_type_4dnet_intf = { PyVarObject_HEAD_INIT(0, 0) - "dnet.intf", /*tp_name*/ + "dnet.""intf", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_intf), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_intf, /*tp_dealloc*/ @@ -19785,7 +27698,7 @@ static PyTypeObject __pyx_type_4dnet_intf = { 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*/ - "intf() -> Interface table object\n\n Open a handle to the system network interface table.\n ", /*tp_doc*/ + PyDoc_STR("intf() -> Interface table object\n\n Open a handle to the system network interface table.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -19799,7 +27712,9 @@ static PyTypeObject __pyx_type_4dnet_intf = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_4intf_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_intf, /*tp_new*/ @@ -19813,34 +27728,49 @@ static PyTypeObject __pyx_type_4dnet_intf = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet_route(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_route(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_route) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -19851,22 +27781,47 @@ static void __pyx_tp_dealloc_4dnet_route(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyMethodDef __pyx_methods_4dnet_route[] = { - {"add", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_5route_3add, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_5route_2add}, - {"delete", (PyCFunction)__pyx_pw_4dnet_5route_5delete, METH_O, __pyx_doc_4dnet_5route_4delete}, - {"get", (PyCFunction)__pyx_pw_4dnet_5route_7get, METH_O, __pyx_doc_4dnet_5route_6get}, - {"loop", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_5route_9loop, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_5route_8loop}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_5route_15__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_5route_17__setstate_cython__, METH_O, 0}, + {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_3add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_5route_2add}, + {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_5delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_5route_4delete}, + {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_7get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_5route_6get}, + {"loop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_9loop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_5route_8loop}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_15__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_5route_17__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_route_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_route}, + {Py_tp_doc, (void *)PyDoc_STR("route() -> Routing table object\n\n Open a handle to the system routing table.\n ")}, + {Py_tp_iter, (void *)__pyx_pw_4dnet_5route_11__iter__}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_route}, + {Py_tp_init, (void *)__pyx_pw_4dnet_5route_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_route}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_route_spec = { + "dnet.route", + sizeof(struct __pyx_obj_4dnet_route), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_route_slots, +}; +#else static PyTypeObject __pyx_type_4dnet_route = { PyVarObject_HEAD_INIT(0, 0) - "dnet.route", /*tp_name*/ + "dnet.""route", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_route), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_route, /*tp_dealloc*/ @@ -19895,7 +27850,7 @@ static PyTypeObject __pyx_type_4dnet_route = { 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*/ - "route() -> Routing table object\n\n Open a handle to the system routing table.\n ", /*tp_doc*/ + PyDoc_STR("route() -> Routing table object\n\n Open a handle to the system routing table.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -19909,7 +27864,9 @@ static PyTypeObject __pyx_type_4dnet_route = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_5route_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_route, /*tp_new*/ @@ -19923,34 +27880,49 @@ static PyTypeObject __pyx_type_4dnet_route = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet_fw(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_fw(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_fw) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -19961,21 +27933,46 @@ static void __pyx_tp_dealloc_4dnet_fw(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyMethodDef __pyx_methods_4dnet_fw[] = { - {"add", (PyCFunction)__pyx_pw_4dnet_2fw_3add, METH_O, __pyx_doc_4dnet_2fw_2add}, - {"delete", (PyCFunction)__pyx_pw_4dnet_2fw_5delete, METH_O, __pyx_doc_4dnet_2fw_4delete}, - {"loop", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_2fw_7loop, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_2fw_6loop}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_2fw_13__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_2fw_15__setstate_cython__, METH_O, 0}, + {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_3add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2fw_2add}, + {"delete", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_5delete, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2fw_4delete}, + {"loop", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_7loop, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_2fw_6loop}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_2fw_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_fw_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_fw}, + {Py_tp_doc, (void *)PyDoc_STR("fw() -> Firewall ruleset object\n \n Open a handle to the local network firewall configuration.\n ")}, + {Py_tp_iter, (void *)__pyx_pw_4dnet_2fw_9__iter__}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_fw}, + {Py_tp_init, (void *)__pyx_pw_4dnet_2fw_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_fw}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_fw_spec = { + "dnet.fw", + sizeof(struct __pyx_obj_4dnet_fw), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_fw_slots, +}; +#else static PyTypeObject __pyx_type_4dnet_fw = { PyVarObject_HEAD_INIT(0, 0) - "dnet.fw", /*tp_name*/ + "dnet.""fw", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_fw), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_fw, /*tp_dealloc*/ @@ -20004,7 +28001,7 @@ static PyTypeObject __pyx_type_4dnet_fw = { 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*/ - "fw() -> Firewall ruleset object\n \n Open a handle to the local network firewall configuration.\n ", /*tp_doc*/ + PyDoc_STR("fw() -> Firewall ruleset object\n \n Open a handle to the local network firewall configuration.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -20018,7 +28015,9 @@ static PyTypeObject __pyx_type_4dnet_fw = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_2fw_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_fw, /*tp_new*/ @@ -20032,34 +28031,49 @@ static PyTypeObject __pyx_type_4dnet_fw = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet_rand(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_rand(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_rand) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -20070,25 +28084,49 @@ static void __pyx_tp_dealloc_4dnet_rand(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyMethodDef __pyx_methods_4dnet_rand[] = { - {"get", (PyCFunction)__pyx_pw_4dnet_4rand_3get, METH_O, __pyx_doc_4dnet_4rand_2get}, - {"set", (PyCFunction)__pyx_pw_4dnet_4rand_5set, METH_O, __pyx_doc_4dnet_4rand_4set}, - {"add", (PyCFunction)__pyx_pw_4dnet_4rand_7add, METH_O, __pyx_doc_4dnet_4rand_6add}, - {"uint8", (PyCFunction)__pyx_pw_4dnet_4rand_9uint8, METH_NOARGS, __pyx_doc_4dnet_4rand_8uint8}, - {"uint16", (PyCFunction)__pyx_pw_4dnet_4rand_11uint16, METH_NOARGS, __pyx_doc_4dnet_4rand_10uint16}, - {"uint32", (PyCFunction)__pyx_pw_4dnet_4rand_13uint32, METH_NOARGS, __pyx_doc_4dnet_4rand_12uint32}, - {"xrange", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_4dnet_4rand_15xrange, METH_VARARGS|METH_KEYWORDS, __pyx_doc_4dnet_4rand_14xrange}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_4rand_19__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_4rand_21__setstate_cython__, METH_O, 0}, + {"get", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_3get, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_2get}, + {"set", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_5set, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_4set}, + {"add", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_7add, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_6add}, + {"uint8", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_9uint8, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_8uint8}, + {"uint16", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_11uint16, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_10uint16}, + {"uint32", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_13uint32, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_12uint32}, + {"xrange", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_15xrange, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_4rand_14xrange}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_19__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_4rand_21__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_rand_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_rand}, + {Py_tp_doc, (void *)PyDoc_STR("rand() -> Pseudo-random number generator\n\n Obtain a handle for fast, cryptographically strong pseudo-random\n number generation. The starting seed is derived from the system\n random data source device (if one exists), or from the current time\n and random stack contents.\n ")}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_rand}, + {Py_tp_init, (void *)__pyx_pw_4dnet_4rand_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_rand}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_rand_spec = { + "dnet.rand", + sizeof(struct __pyx_obj_4dnet_rand), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_rand_slots, +}; +#else static PyTypeObject __pyx_type_4dnet_rand = { PyVarObject_HEAD_INIT(0, 0) - "dnet.rand", /*tp_name*/ + "dnet.""rand", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_rand), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_rand, /*tp_dealloc*/ @@ -20117,7 +28155,7 @@ static PyTypeObject __pyx_type_4dnet_rand = { 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*/ - "rand() -> Pseudo-random number generator\n\n Obtain a handle for fast, cryptographically strong pseudo-random\n number generation. The starting seed is derived from the system\n random data source device (if one exists), or from the current time\n and random stack contents.\n ", /*tp_doc*/ + PyDoc_STR("rand() -> Pseudo-random number generator\n\n Obtain a handle for fast, cryptographically strong pseudo-random\n number generation. The starting seed is derived from the system\n random data source device (if one exists), or from the current time\n and random stack contents.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -20131,7 +28169,9 @@ static PyTypeObject __pyx_type_4dnet_rand = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_4rand_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_rand, /*tp_new*/ @@ -20145,47 +28185,93 @@ static PyTypeObject __pyx_type_4dnet_rand = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet___rand_xrange(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet___rand_xrange(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet___rand_xrange) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } -static PyObject *__pyx_specialmethod___pyx_pw_4dnet_13__rand_xrange_7__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) {return __pyx_pw_4dnet_13__rand_xrange_7__next__(self);} +static PyObject *__pyx_specialmethod___pyx_pw_4dnet_13__rand_xrange_7__next__(PyObject *self, CYTHON_UNUSED PyObject *arg) { + PyObject *res = __pyx_pw_4dnet_13__rand_xrange_7__next__(self); + if (!res && !PyErr_Occurred()) { PyErr_SetNone(PyExc_StopIteration); } + return res; +} static PyMethodDef __pyx_methods_4dnet___rand_xrange[] = { {"__next__", (PyCFunction)__pyx_specialmethod___pyx_pw_4dnet_13__rand_xrange_7__next__, METH_NOARGS|METH_COEXIST, 0}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_13__rand_xrange_9__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_13__rand_xrange_11__setstate_cython__, METH_O, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_13__rand_xrange_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_13__rand_xrange_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet___rand_xrange_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet___rand_xrange}, + {Py_sq_length, (void *)__pyx_pw_4dnet_13__rand_xrange_5__len__}, + {Py_mp_length, (void *)__pyx_pw_4dnet_13__rand_xrange_5__len__}, + {Py_tp_iter, (void *)__pyx_pw_4dnet_13__rand_xrange_3__iter__}, + {Py_tp_iternext, (void *)__pyx_pw_4dnet_13__rand_xrange_7__next__}, + {Py_tp_methods, (void *)__pyx_methods_4dnet___rand_xrange}, + {Py_tp_init, (void *)__pyx_pw_4dnet_13__rand_xrange_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet___rand_xrange}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet___rand_xrange_spec = { + "dnet.__rand_xrange", + sizeof(struct __pyx_obj_4dnet___rand_xrange), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet___rand_xrange_slots, +}; +#else static PySequenceMethods __pyx_tp_as_sequence___rand_xrange = { __pyx_pw_4dnet_13__rand_xrange_5__len__, /*sq_length*/ @@ -20208,7 +28294,7 @@ static PyMappingMethods __pyx_tp_as_mapping___rand_xrange = { static PyTypeObject __pyx_type_4dnet___rand_xrange = { PyVarObject_HEAD_INIT(0, 0) - "dnet.__rand_xrange", /*tp_name*/ + "dnet.""__rand_xrange", /*tp_name*/ sizeof(struct __pyx_obj_4dnet___rand_xrange), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet___rand_xrange, /*tp_dealloc*/ @@ -20251,7 +28337,9 @@ static PyTypeObject __pyx_type_4dnet___rand_xrange = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_13__rand_xrange_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet___rand_xrange, /*tp_new*/ @@ -20265,34 +28353,49 @@ static PyTypeObject __pyx_type_4dnet___rand_xrange = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#endif static PyObject *__pyx_tp_new_4dnet_tun(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { PyObject *o; - if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + #if CYTHON_COMPILING_IN_LIMITED_API + allocfunc alloc_func = (allocfunc)PyType_GetSlot(t, Py_tp_alloc); + o = alloc_func(t, 0); + #else + if (likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { o = (*t->tp_alloc)(t, 0); } else { o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); } if (unlikely(!o)) return 0; + #endif return o; } static void __pyx_tp_dealloc_4dnet_tun(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; + if (unlikely((PY_VERSION_HEX >= 0x03080000 || __Pyx_PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE)) && __Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4dnet_tun) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } } #endif { @@ -20303,7 +28406,14 @@ static void __pyx_tp_dealloc_4dnet_tun(PyObject *o) { __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); PyErr_Restore(etype, eval, etb); } + #if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY (*Py_TYPE(o)->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(Py_TYPE(o), Py_tp_free); + if (tp_free) tp_free(o); + } + #endif } static PyObject *__pyx_getprop_4dnet_3tun_name(PyObject *o, CYTHON_UNUSED void *x) { @@ -20315,24 +28425,42 @@ static PyObject *__pyx_getprop_4dnet_3tun_fd(PyObject *o, CYTHON_UNUSED void *x) } static PyMethodDef __pyx_methods_4dnet_tun[] = { - {"fileno", (PyCFunction)__pyx_pw_4dnet_3tun_3fileno, METH_NOARGS, __pyx_doc_4dnet_3tun_2fileno}, - {"send", (PyCFunction)__pyx_pw_4dnet_3tun_5send, METH_O, __pyx_doc_4dnet_3tun_4send}, - {"recv", (PyCFunction)__pyx_pw_4dnet_3tun_7recv, METH_NOARGS, __pyx_doc_4dnet_3tun_6recv}, - {"close", (PyCFunction)__pyx_pw_4dnet_3tun_9close, METH_NOARGS, 0}, - {"__reduce_cython__", (PyCFunction)__pyx_pw_4dnet_3tun_13__reduce_cython__, METH_NOARGS, 0}, - {"__setstate_cython__", (PyCFunction)__pyx_pw_4dnet_3tun_15__setstate_cython__, METH_O, 0}, + {"fileno", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_3fileno, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3tun_2fileno}, + {"send", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_5send, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3tun_4send}, + {"recv", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_7recv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4dnet_3tun_6recv}, + {"close", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_9close, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_13__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4dnet_3tun_15__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, {0, 0, 0, 0} }; static struct PyGetSetDef __pyx_getsets_4dnet_tun[] = { - {(char *)"name", __pyx_getprop_4dnet_3tun_name, 0, (char *)"Tunnel interface name.", 0}, - {(char *)"fd", __pyx_getprop_4dnet_3tun_fd, 0, (char *)"File descriptor for tunnel handle.", 0}, + {(char *)"name", __pyx_getprop_4dnet_3tun_name, 0, (char *)PyDoc_STR("Tunnel interface name."), 0}, + {(char *)"fd", __pyx_getprop_4dnet_3tun_fd, 0, (char *)PyDoc_STR("File descriptor for tunnel handle."), 0}, {0, 0, 0, 0, 0} }; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4dnet_tun_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4dnet_tun}, + {Py_tp_doc, (void *)PyDoc_STR("tun(src, dst[, mtu]) -> Network tunnel interface handle\n \n Obtain a handle to a network tunnel interface, to which packets\n destined for dst are delivered (with source addresses rewritten to\n src), where they may be read by a userland process and processed\n as desired. Packets written back to the handle are injected into\n the kernel networking subsystem.\n ")}, + {Py_tp_methods, (void *)__pyx_methods_4dnet_tun}, + {Py_tp_getset, (void *)__pyx_getsets_4dnet_tun}, + {Py_tp_init, (void *)__pyx_pw_4dnet_3tun_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_4dnet_tun}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4dnet_tun_spec = { + "dnet.tun", + sizeof(struct __pyx_obj_4dnet_tun), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_4dnet_tun_slots, +}; +#else static PyTypeObject __pyx_type_4dnet_tun = { PyVarObject_HEAD_INIT(0, 0) - "dnet.tun", /*tp_name*/ + "dnet.""tun", /*tp_name*/ sizeof(struct __pyx_obj_4dnet_tun), /*tp_basicsize*/ 0, /*tp_itemsize*/ __pyx_tp_dealloc_4dnet_tun, /*tp_dealloc*/ @@ -20361,7 +28489,7 @@ static PyTypeObject __pyx_type_4dnet_tun = { 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*/ - "tun(src, dst[, mtu]) -> Network tunnel interface handle\n \n Obtain a handle to a network tunnel interface, to which packets\n destined for dst are delivered (with source addresses rewritten to\n src), where they may be read by a userland process and processed\n as desired. Packets written back to the handle are injected into\n the kernel networking subsystem.\n ", /*tp_doc*/ + PyDoc_STR("tun(src, dst[, mtu]) -> Network tunnel interface handle\n \n Obtain a handle to a network tunnel interface, to which packets\n destined for dst are delivered (with source addresses rewritten to\n src), where they may be read by a userland process and processed\n as desired. Packets written back to the handle are injected into\n the kernel networking subsystem.\n "), /*tp_doc*/ 0, /*tp_traverse*/ 0, /*tp_clear*/ 0, /*tp_richcompare*/ @@ -20375,7 +28503,9 @@ static PyTypeObject __pyx_type_4dnet_tun = { 0, /*tp_dict*/ 0, /*tp_descr_get*/ 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS 0, /*tp_dictoffset*/ + #endif __pyx_pw_4dnet_3tun_1__init__, /*tp_init*/ 0, /*tp_alloc*/ __pyx_tp_new_4dnet_tun, /*tp_new*/ @@ -20389,54 +28519,30 @@ static PyTypeObject __pyx_type_4dnet_tun = { 0, /*tp_del*/ 0, /*tp_version_tag*/ #if PY_VERSION_HEX >= 0x030400a1 + #if CYTHON_USE_TP_FINALIZE 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif #endif #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) 0, /*tp_vectorcall*/ #endif - #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + #if __PYX_NEED_TP_PRINT_SLOT == 1 0, /*tp_print*/ #endif - #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 0, /*tp_pypy_flags*/ #endif }; +#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_dnet(PyObject* module); /*proto*/ -static PyModuleDef_Slot __pyx_moduledef_slots[] = { - {Py_mod_create, (void*)__pyx_pymod_create}, - {Py_mod_exec, (void*)__pyx_pymod_exec_dnet}, - {0, NULL} -}; -#endif - -static struct PyModuleDef __pyx_moduledef = { - PyModuleDef_HEAD_INIT, - "dnet", - __pyx_k_dumb_networking_library_This_mod, /* 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 @@ -20446,318 +28552,414 @@ static struct PyModuleDef __pyx_moduledef = { #define CYTHON_SMALL_CODE #endif #endif - -static __Pyx_StringTabEntry __pyx_string_tab[] = { - {&__pyx_kp_u_1_16_2, __pyx_k_1_16_2, sizeof(__pyx_k_1_16_2), 0, 1, 0, 0}, - {&__pyx_n_s_ADDR_TYPE_ETH, __pyx_k_ADDR_TYPE_ETH, sizeof(__pyx_k_ADDR_TYPE_ETH), 0, 0, 1, 1}, - {&__pyx_n_s_ADDR_TYPE_IP, __pyx_k_ADDR_TYPE_IP, sizeof(__pyx_k_ADDR_TYPE_IP), 0, 0, 1, 1}, - {&__pyx_n_s_ADDR_TYPE_IP6, __pyx_k_ADDR_TYPE_IP6, sizeof(__pyx_k_ADDR_TYPE_IP6), 0, 0, 1, 1}, - {&__pyx_n_s_ADDR_TYPE_NONE, __pyx_k_ADDR_TYPE_NONE, sizeof(__pyx_k_ADDR_TYPE_NONE), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_ETHIP_LEN, __pyx_k_ARP_ETHIP_LEN, sizeof(__pyx_k_ARP_ETHIP_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_HDR_LEN, __pyx_k_ARP_HDR_LEN, sizeof(__pyx_k_ARP_HDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_HRD_ETH, __pyx_k_ARP_HRD_ETH, sizeof(__pyx_k_ARP_HRD_ETH), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_HRD_IEEE802, __pyx_k_ARP_HRD_IEEE802, sizeof(__pyx_k_ARP_HRD_IEEE802), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_OP_REPLY, __pyx_k_ARP_OP_REPLY, sizeof(__pyx_k_ARP_OP_REPLY), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_OP_REQUEST, __pyx_k_ARP_OP_REQUEST, sizeof(__pyx_k_ARP_OP_REQUEST), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_OP_REVREPLY, __pyx_k_ARP_OP_REVREPLY, sizeof(__pyx_k_ARP_OP_REVREPLY), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_OP_REVREQUEST, __pyx_k_ARP_OP_REVREQUEST, sizeof(__pyx_k_ARP_OP_REVREQUEST), 0, 0, 1, 1}, - {&__pyx_n_s_ARP_PRO_IP, __pyx_k_ARP_PRO_IP, sizeof(__pyx_k_ARP_PRO_IP), 0, 0, 1, 1}, - {&__pyx_n_u_BSD, __pyx_k_BSD, sizeof(__pyx_k_BSD), 0, 1, 0, 1}, - {&__pyx_kp_u_Copyright_c_2023_Oliver_Falk, __pyx_k_Copyright_c_2023_Oliver_Falk, sizeof(__pyx_k_Copyright_c_2023_Oliver_Falk), 0, 1, 0, 0}, - {&__pyx_n_s_ETH_ADDR_BITS, __pyx_k_ETH_ADDR_BITS, sizeof(__pyx_k_ETH_ADDR_BITS), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_ADDR_BROADCAST, __pyx_k_ETH_ADDR_BROADCAST, sizeof(__pyx_k_ETH_ADDR_BROADCAST), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_ADDR_LEN, __pyx_k_ETH_ADDR_LEN, sizeof(__pyx_k_ETH_ADDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_ADDR_UNSPEC, __pyx_k_ETH_ADDR_UNSPEC, sizeof(__pyx_k_ETH_ADDR_UNSPEC), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_CRC_LEN, __pyx_k_ETH_CRC_LEN, sizeof(__pyx_k_ETH_CRC_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_HDR_LEN, __pyx_k_ETH_HDR_LEN, sizeof(__pyx_k_ETH_HDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_LEN_MAX, __pyx_k_ETH_LEN_MAX, sizeof(__pyx_k_ETH_LEN_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_LEN_MIN, __pyx_k_ETH_LEN_MIN, sizeof(__pyx_k_ETH_LEN_MIN), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_MIN, __pyx_k_ETH_MIN, sizeof(__pyx_k_ETH_MIN), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_MTU, __pyx_k_ETH_MTU, sizeof(__pyx_k_ETH_MTU), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_8021Q, __pyx_k_ETH_TYPE_8021Q, sizeof(__pyx_k_ETH_TYPE_8021Q), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_ARP, __pyx_k_ETH_TYPE_ARP, sizeof(__pyx_k_ETH_TYPE_ARP), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_IP, __pyx_k_ETH_TYPE_IP, sizeof(__pyx_k_ETH_TYPE_IP), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_IPV6, __pyx_k_ETH_TYPE_IPV6, sizeof(__pyx_k_ETH_TYPE_IPV6), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_LEN, __pyx_k_ETH_TYPE_LEN, sizeof(__pyx_k_ETH_TYPE_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_LOOPBACK, __pyx_k_ETH_TYPE_LOOPBACK, sizeof(__pyx_k_ETH_TYPE_LOOPBACK), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_MPLS, __pyx_k_ETH_TYPE_MPLS, sizeof(__pyx_k_ETH_TYPE_MPLS), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_MPLS_MCAST, __pyx_k_ETH_TYPE_MPLS_MCAST, sizeof(__pyx_k_ETH_TYPE_MPLS_MCAST), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_PPPOE, __pyx_k_ETH_TYPE_PPPOE, sizeof(__pyx_k_ETH_TYPE_PPPOE), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_PPPOEDISC, __pyx_k_ETH_TYPE_PPPOEDISC, sizeof(__pyx_k_ETH_TYPE_PPPOEDISC), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_PUP, __pyx_k_ETH_TYPE_PUP, sizeof(__pyx_k_ETH_TYPE_PUP), 0, 0, 1, 1}, - {&__pyx_n_s_ETH_TYPE_REVARP, __pyx_k_ETH_TYPE_REVARP, sizeof(__pyx_k_ETH_TYPE_REVARP), 0, 0, 1, 1}, - {&__pyx_n_s_FW_DIR_IN, __pyx_k_FW_DIR_IN, sizeof(__pyx_k_FW_DIR_IN), 0, 0, 1, 1}, - {&__pyx_n_s_FW_DIR_OUT, __pyx_k_FW_DIR_OUT, sizeof(__pyx_k_FW_DIR_OUT), 0, 0, 1, 1}, - {&__pyx_n_s_FW_OP_ALLOW, __pyx_k_FW_OP_ALLOW, sizeof(__pyx_k_FW_OP_ALLOW), 0, 0, 1, 1}, - {&__pyx_n_s_FW_OP_BLOCK, __pyx_k_FW_OP_BLOCK, sizeof(__pyx_k_FW_OP_BLOCK), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_FLAG_BROADCAST, __pyx_k_INTF_FLAG_BROADCAST, sizeof(__pyx_k_INTF_FLAG_BROADCAST), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_FLAG_LOOPBACK, __pyx_k_INTF_FLAG_LOOPBACK, sizeof(__pyx_k_INTF_FLAG_LOOPBACK), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_FLAG_MULTICAST, __pyx_k_INTF_FLAG_MULTICAST, sizeof(__pyx_k_INTF_FLAG_MULTICAST), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_FLAG_NOARP, __pyx_k_INTF_FLAG_NOARP, sizeof(__pyx_k_INTF_FLAG_NOARP), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_FLAG_POINTOPOINT, __pyx_k_INTF_FLAG_POINTOPOINT, sizeof(__pyx_k_INTF_FLAG_POINTOPOINT), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_FLAG_UP, __pyx_k_INTF_FLAG_UP, sizeof(__pyx_k_INTF_FLAG_UP), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_TYPE_ETH, __pyx_k_INTF_TYPE_ETH, sizeof(__pyx_k_INTF_TYPE_ETH), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_TYPE_LOOPBACK, __pyx_k_INTF_TYPE_LOOPBACK, sizeof(__pyx_k_INTF_TYPE_LOOPBACK), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_TYPE_OTHER, __pyx_k_INTF_TYPE_OTHER, sizeof(__pyx_k_INTF_TYPE_OTHER), 0, 0, 1, 1}, - {&__pyx_n_s_INTF_TYPE_TUN, __pyx_k_INTF_TYPE_TUN, sizeof(__pyx_k_INTF_TYPE_TUN), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_ADDR_BITS, __pyx_k_IP6_ADDR_BITS, sizeof(__pyx_k_IP6_ADDR_BITS), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_ADDR_LEN, __pyx_k_IP6_ADDR_LEN, sizeof(__pyx_k_IP6_ADDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_ADDR_LOOPBACK, __pyx_k_IP6_ADDR_LOOPBACK, sizeof(__pyx_k_IP6_ADDR_LOOPBACK), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_ADDR_UNSPEC, __pyx_k_IP6_ADDR_UNSPEC, sizeof(__pyx_k_IP6_ADDR_UNSPEC), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_HDR_LEN, __pyx_k_IP6_HDR_LEN, sizeof(__pyx_k_IP6_HDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_HLIM_DEFAULT, __pyx_k_IP6_HLIM_DEFAULT, sizeof(__pyx_k_IP6_HLIM_DEFAULT), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_HLIM_MAX, __pyx_k_IP6_HLIM_MAX, sizeof(__pyx_k_IP6_HLIM_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_LEN_MAX, __pyx_k_IP6_LEN_MAX, sizeof(__pyx_k_IP6_LEN_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_LEN_MIN, __pyx_k_IP6_LEN_MIN, sizeof(__pyx_k_IP6_LEN_MIN), 0, 0, 1, 1}, - {&__pyx_n_s_IP6_MTU_MIN, __pyx_k_IP6_MTU_MIN, sizeof(__pyx_k_IP6_MTU_MIN), 0, 0, 1, 1}, - {&__pyx_n_s_IP_ADDR_ANY, __pyx_k_IP_ADDR_ANY, sizeof(__pyx_k_IP_ADDR_ANY), 0, 0, 1, 1}, - {&__pyx_n_s_IP_ADDR_BITS, __pyx_k_IP_ADDR_BITS, sizeof(__pyx_k_IP_ADDR_BITS), 0, 0, 1, 1}, - {&__pyx_n_s_IP_ADDR_BROADCAST, __pyx_k_IP_ADDR_BROADCAST, sizeof(__pyx_k_IP_ADDR_BROADCAST), 0, 0, 1, 1}, - {&__pyx_n_s_IP_ADDR_LEN, __pyx_k_IP_ADDR_LEN, sizeof(__pyx_k_IP_ADDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_IP_ADDR_LOOPBACK, __pyx_k_IP_ADDR_LOOPBACK, sizeof(__pyx_k_IP_ADDR_LOOPBACK), 0, 0, 1, 1}, - {&__pyx_n_s_IP_ADDR_MCAST_ALL, __pyx_k_IP_ADDR_MCAST_ALL, sizeof(__pyx_k_IP_ADDR_MCAST_ALL), 0, 0, 1, 1}, - {&__pyx_n_s_IP_ADDR_MCAST_LOCAL, __pyx_k_IP_ADDR_MCAST_LOCAL, sizeof(__pyx_k_IP_ADDR_MCAST_LOCAL), 0, 0, 1, 1}, - {&__pyx_n_s_IP_DF, __pyx_k_IP_DF, sizeof(__pyx_k_IP_DF), 0, 0, 1, 1}, - {&__pyx_n_s_IP_HDR_LEN, __pyx_k_IP_HDR_LEN, sizeof(__pyx_k_IP_HDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_IP_HDR_LEN_MAX, __pyx_k_IP_HDR_LEN_MAX, sizeof(__pyx_k_IP_HDR_LEN_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_IP_LEN_MAX, __pyx_k_IP_LEN_MAX, sizeof(__pyx_k_IP_LEN_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_IP_LEN_MIN, __pyx_k_IP_LEN_MIN, sizeof(__pyx_k_IP_LEN_MIN), 0, 0, 1, 1}, - {&__pyx_n_s_IP_MF, __pyx_k_IP_MF, sizeof(__pyx_k_IP_MF), 0, 0, 1, 1}, - {&__pyx_n_s_IP_OFFMASK, __pyx_k_IP_OFFMASK, sizeof(__pyx_k_IP_OFFMASK), 0, 0, 1, 1}, - {&__pyx_n_s_IP_OPT_LEN, __pyx_k_IP_OPT_LEN, sizeof(__pyx_k_IP_OPT_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_IP_OPT_LEN_MAX, __pyx_k_IP_OPT_LEN_MAX, sizeof(__pyx_k_IP_OPT_LEN_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_AH, __pyx_k_IP_PROTO_AH, sizeof(__pyx_k_IP_PROTO_AH), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_ESP, __pyx_k_IP_PROTO_ESP, sizeof(__pyx_k_IP_PROTO_ESP), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_GRE, __pyx_k_IP_PROTO_GRE, sizeof(__pyx_k_IP_PROTO_GRE), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_ICMP, __pyx_k_IP_PROTO_ICMP, sizeof(__pyx_k_IP_PROTO_ICMP), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_ICMPV6, __pyx_k_IP_PROTO_ICMPV6, sizeof(__pyx_k_IP_PROTO_ICMPV6), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_IGMP, __pyx_k_IP_PROTO_IGMP, sizeof(__pyx_k_IP_PROTO_IGMP), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_IP, __pyx_k_IP_PROTO_IP, sizeof(__pyx_k_IP_PROTO_IP), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_IPV6, __pyx_k_IP_PROTO_IPV6, sizeof(__pyx_k_IP_PROTO_IPV6), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_MAX, __pyx_k_IP_PROTO_MAX, sizeof(__pyx_k_IP_PROTO_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_RAW, __pyx_k_IP_PROTO_RAW, sizeof(__pyx_k_IP_PROTO_RAW), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_RESERVED, __pyx_k_IP_PROTO_RESERVED, sizeof(__pyx_k_IP_PROTO_RESERVED), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_TCP, __pyx_k_IP_PROTO_TCP, sizeof(__pyx_k_IP_PROTO_TCP), 0, 0, 1, 1}, - {&__pyx_n_s_IP_PROTO_UDP, __pyx_k_IP_PROTO_UDP, sizeof(__pyx_k_IP_PROTO_UDP), 0, 0, 1, 1}, - {&__pyx_n_s_IP_RF, __pyx_k_IP_RF, sizeof(__pyx_k_IP_RF), 0, 0, 1, 1}, - {&__pyx_n_s_IP_TOS_DEFAULT, __pyx_k_IP_TOS_DEFAULT, sizeof(__pyx_k_IP_TOS_DEFAULT), 0, 0, 1, 1}, - {&__pyx_n_s_IP_TTL_DEFAULT, __pyx_k_IP_TTL_DEFAULT, sizeof(__pyx_k_IP_TTL_DEFAULT), 0, 0, 1, 1}, - {&__pyx_n_s_IP_TTL_MAX, __pyx_k_IP_TTL_MAX, sizeof(__pyx_k_IP_TTL_MAX), 0, 0, 1, 1}, - {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, - {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, - {&__pyx_n_s_OSError, __pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 0, 1, 1}, - {&__pyx_kp_u_Oliver_Falk_oliver_linux_kernel, __pyx_k_Oliver_Falk_oliver_linux_kernel, sizeof(__pyx_k_Oliver_Falk_oliver_linux_kernel), 0, 1, 0, 0}, - {&__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_kp_s_Pickling_of_struct_members_such, __pyx_k_Pickling_of_struct_members_such, sizeof(__pyx_k_Pickling_of_struct_members_such), 0, 0, 1, 0}, - {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_HDR_LEN, __pyx_k_TCP_HDR_LEN, sizeof(__pyx_k_TCP_HDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_ALTSUM, __pyx_k_TCP_OPT_ALTSUM, sizeof(__pyx_k_TCP_OPT_ALTSUM), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_ALTSUMDATA, __pyx_k_TCP_OPT_ALTSUMDATA, sizeof(__pyx_k_TCP_OPT_ALTSUMDATA), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_BUBBA, __pyx_k_TCP_OPT_BUBBA, sizeof(__pyx_k_TCP_OPT_BUBBA), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_CC, __pyx_k_TCP_OPT_CC, sizeof(__pyx_k_TCP_OPT_CC), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_CCECHO, __pyx_k_TCP_OPT_CCECHO, sizeof(__pyx_k_TCP_OPT_CCECHO), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_CCNEW, __pyx_k_TCP_OPT_CCNEW, sizeof(__pyx_k_TCP_OPT_CCNEW), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_CORRUPT, __pyx_k_TCP_OPT_CORRUPT, sizeof(__pyx_k_TCP_OPT_CORRUPT), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_ECHO, __pyx_k_TCP_OPT_ECHO, sizeof(__pyx_k_TCP_OPT_ECHO), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_ECHOREPLY, __pyx_k_TCP_OPT_ECHOREPLY, sizeof(__pyx_k_TCP_OPT_ECHOREPLY), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_EOL, __pyx_k_TCP_OPT_EOL, sizeof(__pyx_k_TCP_OPT_EOL), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_MAX, __pyx_k_TCP_OPT_MAX, sizeof(__pyx_k_TCP_OPT_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_MD5, __pyx_k_TCP_OPT_MD5, sizeof(__pyx_k_TCP_OPT_MD5), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_MSS, __pyx_k_TCP_OPT_MSS, sizeof(__pyx_k_TCP_OPT_MSS), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_NOP, __pyx_k_TCP_OPT_NOP, sizeof(__pyx_k_TCP_OPT_NOP), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_POCONN, __pyx_k_TCP_OPT_POCONN, sizeof(__pyx_k_TCP_OPT_POCONN), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_POSVC, __pyx_k_TCP_OPT_POSVC, sizeof(__pyx_k_TCP_OPT_POSVC), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_REC, __pyx_k_TCP_OPT_REC, sizeof(__pyx_k_TCP_OPT_REC), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_SACK, __pyx_k_TCP_OPT_SACK, sizeof(__pyx_k_TCP_OPT_SACK), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_SACKOK, __pyx_k_TCP_OPT_SACKOK, sizeof(__pyx_k_TCP_OPT_SACKOK), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_SCPS, __pyx_k_TCP_OPT_SCPS, sizeof(__pyx_k_TCP_OPT_SCPS), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_SKEETER, __pyx_k_TCP_OPT_SKEETER, sizeof(__pyx_k_TCP_OPT_SKEETER), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_SNACK, __pyx_k_TCP_OPT_SNACK, sizeof(__pyx_k_TCP_OPT_SNACK), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_SNAP, __pyx_k_TCP_OPT_SNAP, sizeof(__pyx_k_TCP_OPT_SNAP), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_TCPCOMP, __pyx_k_TCP_OPT_TCPCOMP, sizeof(__pyx_k_TCP_OPT_TCPCOMP), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_TIMESTAMP, __pyx_k_TCP_OPT_TIMESTAMP, sizeof(__pyx_k_TCP_OPT_TIMESTAMP), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_TRAILSUM, __pyx_k_TCP_OPT_TRAILSUM, sizeof(__pyx_k_TCP_OPT_TRAILSUM), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_OPT_WSCALE, __pyx_k_TCP_OPT_WSCALE, sizeof(__pyx_k_TCP_OPT_WSCALE), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_PORT_MAX, __pyx_k_TCP_PORT_MAX, sizeof(__pyx_k_TCP_PORT_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_TCP_WIN_MAX, __pyx_k_TCP_WIN_MAX, sizeof(__pyx_k_TCP_WIN_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_TH_ACK, __pyx_k_TH_ACK, sizeof(__pyx_k_TH_ACK), 0, 0, 1, 1}, - {&__pyx_n_s_TH_CWR, __pyx_k_TH_CWR, sizeof(__pyx_k_TH_CWR), 0, 0, 1, 1}, - {&__pyx_n_s_TH_ECE, __pyx_k_TH_ECE, sizeof(__pyx_k_TH_ECE), 0, 0, 1, 1}, - {&__pyx_n_s_TH_FIN, __pyx_k_TH_FIN, sizeof(__pyx_k_TH_FIN), 0, 0, 1, 1}, - {&__pyx_n_s_TH_PUSH, __pyx_k_TH_PUSH, sizeof(__pyx_k_TH_PUSH), 0, 0, 1, 1}, - {&__pyx_n_s_TH_RST, __pyx_k_TH_RST, sizeof(__pyx_k_TH_RST), 0, 0, 1, 1}, - {&__pyx_n_s_TH_SYN, __pyx_k_TH_SYN, sizeof(__pyx_k_TH_SYN), 0, 0, 1, 1}, - {&__pyx_n_s_TH_URG, __pyx_k_TH_URG, sizeof(__pyx_k_TH_URG), 0, 0, 1, 1}, - {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, - {&__pyx_n_s_UDP_HDR_LEN, __pyx_k_UDP_HDR_LEN, sizeof(__pyx_k_UDP_HDR_LEN), 0, 0, 1, 1}, - {&__pyx_n_s_UDP_PORT_MAX, __pyx_k_UDP_PORT_MAX, sizeof(__pyx_k_UDP_PORT_MAX), 0, 0, 1, 1}, - {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, - {&__pyx_n_s_ack, __pyx_k_ack, sizeof(__pyx_k_ack), 0, 0, 1, 1}, - {&__pyx_n_s_addr, __pyx_k_addr, sizeof(__pyx_k_addr), 0, 0, 1, 1}, - {&__pyx_n_u_addr, __pyx_k_addr, sizeof(__pyx_k_addr), 0, 1, 0, 1}, - {&__pyx_n_s_addr_ip4_iter, __pyx_k_addr_ip4_iter, sizeof(__pyx_k_addr_ip4_iter), 0, 0, 1, 1}, - {&__pyx_n_s_addrtxt, __pyx_k_addrtxt, sizeof(__pyx_k_addrtxt), 0, 0, 1, 1}, - {&__pyx_n_s_addrtype, __pyx_k_addrtype, sizeof(__pyx_k_addrtype), 0, 0, 1, 1}, - {&__pyx_n_u_alias_addrs, __pyx_k_alias_addrs, sizeof(__pyx_k_alias_addrs), 0, 1, 0, 1}, - {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, - {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, - {&__pyx_n_s_arp, __pyx_k_arp, sizeof(__pyx_k_arp), 0, 0, 1, 1}, - {&__pyx_n_s_arp_pack_hdr_ethip, __pyx_k_arp_pack_hdr_ethip, sizeof(__pyx_k_arp_pack_hdr_ethip), 0, 0, 1, 1}, - {&__pyx_n_s_author, __pyx_k_author, sizeof(__pyx_k_author), 0, 0, 1, 1}, - {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1}, - {&__pyx_kp_u_byte_binary_string, __pyx_k_byte_binary_string, sizeof(__pyx_k_byte_binary_string), 0, 1, 0, 0}, - {&__pyx_n_s_callback, __pyx_k_callback, sizeof(__pyx_k_callback), 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_code, __pyx_k_code, sizeof(__pyx_k_code), 0, 0, 1, 1}, - {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, - {&__pyx_n_s_copyright, __pyx_k_copyright, sizeof(__pyx_k_copyright), 0, 0, 1, 1}, - {&__pyx_n_s_cur, __pyx_k_cur, sizeof(__pyx_k_cur), 0, 0, 1, 1}, - {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1}, - {&__pyx_n_u_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 1, 0, 1}, - {&__pyx_n_s_device, __pyx_k_device, sizeof(__pyx_k_device), 0, 0, 1, 1}, - {&__pyx_n_u_device, __pyx_k_device, sizeof(__pyx_k_device), 0, 1, 0, 1}, - {&__pyx_n_s_dh, __pyx_k_dh, sizeof(__pyx_k_dh), 0, 0, 1, 1}, - {&__pyx_n_s_dha, __pyx_k_dha, sizeof(__pyx_k_dha), 0, 0, 1, 1}, - {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, - {&__pyx_n_u_dir, __pyx_k_dir, sizeof(__pyx_k_dir), 0, 1, 0, 1}, - {&__pyx_n_s_dnet, __pyx_k_dnet, sizeof(__pyx_k_dnet), 0, 0, 1, 1}, - {&__pyx_kp_s_dnet_pyx, __pyx_k_dnet_pyx, sizeof(__pyx_k_dnet_pyx), 0, 0, 1, 0}, - {&__pyx_n_s_dp, __pyx_k_dp, sizeof(__pyx_k_dp), 0, 0, 1, 1}, - {&__pyx_n_s_dpa, __pyx_k_dpa, sizeof(__pyx_k_dpa), 0, 0, 1, 1}, - {&__pyx_n_s_dport, __pyx_k_dport, sizeof(__pyx_k_dport), 0, 0, 1, 1}, - {&__pyx_n_u_dport, __pyx_k_dport, sizeof(__pyx_k_dport), 0, 1, 0, 1}, - {&__pyx_n_s_dst, __pyx_k_dst, sizeof(__pyx_k_dst), 0, 0, 1, 1}, - {&__pyx_n_u_dst, __pyx_k_dst, sizeof(__pyx_k_dst), 0, 1, 0, 1}, - {&__pyx_n_u_dst_addr, __pyx_k_dst_addr, sizeof(__pyx_k_dst_addr), 0, 1, 0, 1}, - {&__pyx_n_s_ea, __pyx_k_ea, sizeof(__pyx_k_ea), 0, 0, 1, 1}, - {&__pyx_n_s_entry, __pyx_k_entry, sizeof(__pyx_k_entry), 0, 0, 1, 1}, - {&__pyx_n_s_eth, __pyx_k_eth, sizeof(__pyx_k_eth), 0, 0, 1, 1}, - {&__pyx_n_s_eth_aton, __pyx_k_eth_aton, sizeof(__pyx_k_eth_aton), 0, 0, 1, 1}, - {&__pyx_n_s_eth_ntoa, __pyx_k_eth_ntoa, sizeof(__pyx_k_eth_ntoa), 0, 0, 1, 1}, - {&__pyx_n_s_eth_pack_hdr, __pyx_k_eth_pack_hdr, sizeof(__pyx_k_eth_pack_hdr), 0, 0, 1, 1}, - {&__pyx_n_s_etype, __pyx_k_etype, sizeof(__pyx_k_etype), 0, 0, 1, 1}, - {&__pyx_n_s_fc, __pyx_k_fc, sizeof(__pyx_k_fc), 0, 0, 1, 1}, - {&__pyx_n_s_fl, __pyx_k_fl, sizeof(__pyx_k_fl), 0, 0, 1, 1}, - {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, - {&__pyx_n_u_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 1, 0, 1}, - {&__pyx_n_s_fw, __pyx_k_fw, sizeof(__pyx_k_fw), 0, 0, 1, 1}, - {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, - {&__pyx_n_s_gw, __pyx_k_gw, sizeof(__pyx_k_gw), 0, 0, 1, 1}, - {&__pyx_n_s_ha, __pyx_k_ha, sizeof(__pyx_k_ha), 0, 0, 1, 1}, - {&__pyx_n_s_hdr, __pyx_k_hdr, sizeof(__pyx_k_hdr), 0, 0, 1, 1}, - {&__pyx_n_s_hlim, __pyx_k_hlim, sizeof(__pyx_k_hlim), 0, 0, 1, 1}, - {&__pyx_kp_u_https_github_com_ofalk_libdnet, __pyx_k_https_github_com_ofalk_libdnet, sizeof(__pyx_k_https_github_com_ofalk_libdnet), 0, 1, 0, 0}, - {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, - {&__pyx_n_s_ia, __pyx_k_ia, sizeof(__pyx_k_ia), 0, 0, 1, 1}, - {&__pyx_n_s_icmp_pack_hdr, __pyx_k_icmp_pack_hdr, sizeof(__pyx_k_icmp_pack_hdr), 0, 0, 1, 1}, - {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, - {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, - {&__pyx_n_s_int, __pyx_k_int, sizeof(__pyx_k_int), 0, 0, 1, 1}, - {&__pyx_n_s_intf, __pyx_k_intf, sizeof(__pyx_k_intf), 0, 0, 1, 1}, - {&__pyx_kp_u_invalid_Ethernet_address, __pyx_k_invalid_Ethernet_address, sizeof(__pyx_k_invalid_Ethernet_address), 0, 1, 0, 0}, - {&__pyx_kp_u_invalid_IP_address, __pyx_k_invalid_IP_address, sizeof(__pyx_k_invalid_IP_address), 0, 1, 0, 0}, - {&__pyx_kp_u_invalid_IPv6_address, __pyx_k_invalid_IPv6_address, sizeof(__pyx_k_invalid_IPv6_address), 0, 1, 0, 0}, - {&__pyx_kp_u_invalid_network_address, __pyx_k_invalid_network_address, sizeof(__pyx_k_invalid_network_address), 0, 1, 0, 0}, - {&__pyx_kp_u_invalid_network_address_2, __pyx_k_invalid_network_address_2, sizeof(__pyx_k_invalid_network_address_2), 0, 1, 0, 0}, - {&__pyx_n_s_ip, __pyx_k_ip, sizeof(__pyx_k_ip), 0, 0, 1, 1}, - {&__pyx_n_s_ip6, __pyx_k_ip6, sizeof(__pyx_k_ip6), 0, 0, 1, 1}, - {&__pyx_n_s_ip6_aton, __pyx_k_ip6_aton, sizeof(__pyx_k_ip6_aton), 0, 0, 1, 1}, - {&__pyx_n_s_ip6_checksum, __pyx_k_ip6_checksum, sizeof(__pyx_k_ip6_checksum), 0, 0, 1, 1}, - {&__pyx_n_s_ip6_ntoa, __pyx_k_ip6_ntoa, sizeof(__pyx_k_ip6_ntoa), 0, 0, 1, 1}, - {&__pyx_n_s_ip6_pack_hdr, __pyx_k_ip6_pack_hdr, sizeof(__pyx_k_ip6_pack_hdr), 0, 0, 1, 1}, - {&__pyx_n_s_ip_aton, __pyx_k_ip_aton, sizeof(__pyx_k_ip_aton), 0, 0, 1, 1}, - {&__pyx_n_s_ip_checksum, __pyx_k_ip_checksum, sizeof(__pyx_k_ip_checksum), 0, 0, 1, 1}, - {&__pyx_n_s_ip_cksum_add, __pyx_k_ip_cksum_add, sizeof(__pyx_k_ip_cksum_add), 0, 0, 1, 1}, - {&__pyx_n_s_ip_cksum_carry, __pyx_k_ip_cksum_carry, sizeof(__pyx_k_ip_cksum_carry), 0, 0, 1, 1}, - {&__pyx_n_s_ip_ntoa, __pyx_k_ip_ntoa, sizeof(__pyx_k_ip_ntoa), 0, 0, 1, 1}, - {&__pyx_n_s_ip_pack_hdr, __pyx_k_ip_pack_hdr, sizeof(__pyx_k_ip_pack_hdr), 0, 0, 1, 1}, - {&__pyx_n_s_iter_append, __pyx_k_iter_append, sizeof(__pyx_k_iter_append), 0, 0, 1, 1}, - {&__pyx_n_s_itype, __pyx_k_itype, sizeof(__pyx_k_itype), 0, 0, 1, 1}, - {&__pyx_n_s_l, __pyx_k_l, sizeof(__pyx_k_l), 0, 0, 1, 1}, - {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1}, - {&__pyx_n_s_license, __pyx_k_license, sizeof(__pyx_k_license), 0, 0, 1, 1}, - {&__pyx_n_u_link_addr, __pyx_k_link_addr, sizeof(__pyx_k_link_addr), 0, 1, 0, 1}, - {&__pyx_n_s_loop, __pyx_k_loop, sizeof(__pyx_k_loop), 0, 0, 1, 1}, - {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, - {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, - {&__pyx_n_s_mtu, __pyx_k_mtu, sizeof(__pyx_k_mtu), 0, 0, 1, 1}, - {&__pyx_n_u_mtu, __pyx_k_mtu, sizeof(__pyx_k_mtu), 0, 1, 0, 1}, - {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, - {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1}, - {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, - {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, - {&__pyx_kp_u_non_Ethernet_address, __pyx_k_non_Ethernet_address, sizeof(__pyx_k_non_Ethernet_address), 0, 1, 0, 0}, - {&__pyx_kp_u_non_IP_address, __pyx_k_non_IP_address, sizeof(__pyx_k_non_IP_address), 0, 1, 0, 0}, - {&__pyx_kp_u_non_IPv6_address, __pyx_k_non_IPv6_address, sizeof(__pyx_k_non_IPv6_address), 0, 1, 0, 0}, - {&__pyx_kp_u_not_a, __pyx_k_not_a, sizeof(__pyx_k_not_a), 0, 1, 0, 0}, - {&__pyx_kp_u_not_a_16_byte_string, __pyx_k_not_a_16_byte_string, sizeof(__pyx_k_not_a_16_byte_string), 0, 1, 0, 0}, - {&__pyx_kp_u_not_a_4_byte_string, __pyx_k_not_a_4_byte_string, sizeof(__pyx_k_not_a_4_byte_string), 0, 1, 0, 0}, - {&__pyx_kp_u_not_a_6_byte_string, __pyx_k_not_a_6_byte_string, sizeof(__pyx_k_not_a_6_byte_string), 0, 1, 0, 0}, - {&__pyx_n_s_nxt, __pyx_k_nxt, sizeof(__pyx_k_nxt), 0, 0, 1, 1}, - {&__pyx_n_s_off, __pyx_k_off, sizeof(__pyx_k_off), 0, 0, 1, 1}, - {&__pyx_n_s_op, __pyx_k_op, sizeof(__pyx_k_op), 0, 0, 1, 1}, - {&__pyx_n_u_op, __pyx_k_op, sizeof(__pyx_k_op), 0, 1, 0, 1}, - {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, - {&__pyx_n_s_pa, __pyx_k_pa, sizeof(__pyx_k_pa), 0, 0, 1, 1}, - {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, - {&__pyx_n_s_pkt, __pyx_k_pkt, sizeof(__pyx_k_pkt), 0, 0, 1, 1}, - {&__pyx_n_s_plen, __pyx_k_plen, sizeof(__pyx_k_plen), 0, 0, 1, 1}, - {&__pyx_n_u_proto, __pyx_k_proto, sizeof(__pyx_k_proto), 0, 1, 0, 1}, - {&__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___addr_ip4_iter, __pyx_k_pyx_unpickle___addr_ip4_iter, sizeof(__pyx_k_pyx_unpickle___addr_ip4_iter), 0, 0, 1, 1}, - {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, - {&__pyx_n_s_rand, __pyx_k_rand, sizeof(__pyx_k_rand), 0, 0, 1, 1}, - {&__pyx_n_s_rand_xrange, __pyx_k_rand_xrange, sizeof(__pyx_k_rand_xrange), 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_route, __pyx_k_route, sizeof(__pyx_k_route), 0, 0, 1, 1}, - {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1}, - {&__pyx_kp_s_self_arp_cannot_be_converted_to, __pyx_k_self_arp_cannot_be_converted_to, sizeof(__pyx_k_self_arp_cannot_be_converted_to), 0, 0, 1, 0}, - {&__pyx_kp_s_self_eth_cannot_be_converted_to, __pyx_k_self_eth_cannot_be_converted_to, sizeof(__pyx_k_self_eth_cannot_be_converted_to), 0, 0, 1, 0}, - {&__pyx_kp_s_self_fw_cannot_be_converted_to_a, __pyx_k_self_fw_cannot_be_converted_to_a, sizeof(__pyx_k_self_fw_cannot_be_converted_to_a), 0, 0, 1, 0}, - {&__pyx_kp_s_self_intf_cannot_be_converted_to, __pyx_k_self_intf_cannot_be_converted_to, sizeof(__pyx_k_self_intf_cannot_be_converted_to), 0, 0, 1, 0}, - {&__pyx_kp_s_self_ip_cannot_be_converted_to_a, __pyx_k_self_ip_cannot_be_converted_to_a, sizeof(__pyx_k_self_ip_cannot_be_converted_to_a), 0, 0, 1, 0}, - {&__pyx_kp_s_self_rand_cannot_be_converted_to, __pyx_k_self_rand_cannot_be_converted_to, sizeof(__pyx_k_self_rand_cannot_be_converted_to), 0, 0, 1, 0}, - {&__pyx_kp_s_self_route_cannot_be_converted_t, __pyx_k_self_route_cannot_be_converted_t, sizeof(__pyx_k_self_route_cannot_be_converted_t), 0, 0, 1, 0}, - {&__pyx_kp_s_self_tun_cannot_be_converted_to, __pyx_k_self_tun_cannot_be_converted_to, sizeof(__pyx_k_self_tun_cannot_be_converted_to), 0, 0, 1, 0}, - {&__pyx_n_s_seq, __pyx_k_seq, sizeof(__pyx_k_seq), 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_sh, __pyx_k_sh, sizeof(__pyx_k_sh), 0, 0, 1, 1}, - {&__pyx_n_s_sha, __pyx_k_sha, sizeof(__pyx_k_sha), 0, 0, 1, 1}, - {&__pyx_n_s_sp, __pyx_k_sp, sizeof(__pyx_k_sp), 0, 0, 1, 1}, - {&__pyx_n_s_spa, __pyx_k_spa, sizeof(__pyx_k_spa), 0, 0, 1, 1}, - {&__pyx_n_s_sport, __pyx_k_sport, sizeof(__pyx_k_sport), 0, 0, 1, 1}, - {&__pyx_n_u_sport, __pyx_k_sport, sizeof(__pyx_k_sport), 0, 1, 0, 1}, - {&__pyx_n_s_src, __pyx_k_src, sizeof(__pyx_k_src), 0, 0, 1, 1}, - {&__pyx_n_u_src, __pyx_k_src, sizeof(__pyx_k_src), 0, 1, 0, 1}, - {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, - {&__pyx_kp_u_start_must_be_an_integer, __pyx_k_start_must_be_an_integer, sizeof(__pyx_k_start_must_be_an_integer), 0, 1, 0, 0}, - {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, - {&__pyx_kp_u_stop_must_be_an_integer, __pyx_k_stop_must_be_an_integer, sizeof(__pyx_k_stop_must_be_an_integer), 0, 1, 0, 0}, - {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, - {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, - {&__pyx_n_s_tcp_pack_hdr, __pyx_k_tcp_pack_hdr, sizeof(__pyx_k_tcp_pack_hdr), 0, 0, 1, 1}, - {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, - {&__pyx_n_s_tos, __pyx_k_tos, sizeof(__pyx_k_tos), 0, 0, 1, 1}, - {&__pyx_n_s_ttl, __pyx_k_ttl, sizeof(__pyx_k_ttl), 0, 0, 1, 1}, - {&__pyx_n_s_tun, __pyx_k_tun, sizeof(__pyx_k_tun), 0, 0, 1, 1}, - {&__pyx_n_u_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 1, 0, 1}, - {&__pyx_n_s_udp_pack_hdr, __pyx_k_udp_pack_hdr, sizeof(__pyx_k_udp_pack_hdr), 0, 0, 1, 1}, - {&__pyx_n_s_ulen, __pyx_k_ulen, sizeof(__pyx_k_ulen), 0, 0, 1, 1}, - {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, - {&__pyx_n_s_url, __pyx_k_url, sizeof(__pyx_k_url), 0, 0, 1, 1}, - {&__pyx_n_s_urp, __pyx_k_urp, sizeof(__pyx_k_urp), 0, 0, 1, 1}, - {&__pyx_n_s_version, __pyx_k_version, sizeof(__pyx_k_version), 0, 0, 1, 1}, - {&__pyx_n_s_win, __pyx_k_win, sizeof(__pyx_k_win), 0, 0, 1, 1}, - {0, 0, 0, 0, 0, 0, 0} -}; +/* #### Code section: pystring_table ### */ + +static int __Pyx_CreateStringTabAndInitStrings(void) { + __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_kp_u_1_18_0, __pyx_k_1_18_0, sizeof(__pyx_k_1_18_0), 0, 1, 0, 0}, + {&__pyx_n_s_ADDR_TYPE_ETH, __pyx_k_ADDR_TYPE_ETH, sizeof(__pyx_k_ADDR_TYPE_ETH), 0, 0, 1, 1}, + {&__pyx_n_s_ADDR_TYPE_IP, __pyx_k_ADDR_TYPE_IP, sizeof(__pyx_k_ADDR_TYPE_IP), 0, 0, 1, 1}, + {&__pyx_n_s_ADDR_TYPE_IP6, __pyx_k_ADDR_TYPE_IP6, sizeof(__pyx_k_ADDR_TYPE_IP6), 0, 0, 1, 1}, + {&__pyx_n_s_ADDR_TYPE_NONE, __pyx_k_ADDR_TYPE_NONE, sizeof(__pyx_k_ADDR_TYPE_NONE), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_ETHIP_LEN, __pyx_k_ARP_ETHIP_LEN, sizeof(__pyx_k_ARP_ETHIP_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_HDR_LEN, __pyx_k_ARP_HDR_LEN, sizeof(__pyx_k_ARP_HDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_HRD_ETH, __pyx_k_ARP_HRD_ETH, sizeof(__pyx_k_ARP_HRD_ETH), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_HRD_IEEE802, __pyx_k_ARP_HRD_IEEE802, sizeof(__pyx_k_ARP_HRD_IEEE802), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_OP_REPLY, __pyx_k_ARP_OP_REPLY, sizeof(__pyx_k_ARP_OP_REPLY), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_OP_REQUEST, __pyx_k_ARP_OP_REQUEST, sizeof(__pyx_k_ARP_OP_REQUEST), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_OP_REVREPLY, __pyx_k_ARP_OP_REVREPLY, sizeof(__pyx_k_ARP_OP_REVREPLY), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_OP_REVREQUEST, __pyx_k_ARP_OP_REVREQUEST, sizeof(__pyx_k_ARP_OP_REVREQUEST), 0, 0, 1, 1}, + {&__pyx_n_s_ARP_PRO_IP, __pyx_k_ARP_PRO_IP, sizeof(__pyx_k_ARP_PRO_IP), 0, 0, 1, 1}, + {&__pyx_n_u_BSD, __pyx_k_BSD, sizeof(__pyx_k_BSD), 0, 1, 0, 1}, + {&__pyx_kp_u_Copyright_c_2023_2024_Oliver_Fal, __pyx_k_Copyright_c_2023_2024_Oliver_Fal, sizeof(__pyx_k_Copyright_c_2023_2024_Oliver_Fal), 0, 1, 0, 0}, + {&__pyx_n_s_ETH_ADDR_BITS, __pyx_k_ETH_ADDR_BITS, sizeof(__pyx_k_ETH_ADDR_BITS), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_ADDR_BROADCAST, __pyx_k_ETH_ADDR_BROADCAST, sizeof(__pyx_k_ETH_ADDR_BROADCAST), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_ADDR_LEN, __pyx_k_ETH_ADDR_LEN, sizeof(__pyx_k_ETH_ADDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_ADDR_UNSPEC, __pyx_k_ETH_ADDR_UNSPEC, sizeof(__pyx_k_ETH_ADDR_UNSPEC), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_CRC_LEN, __pyx_k_ETH_CRC_LEN, sizeof(__pyx_k_ETH_CRC_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_HDR_LEN, __pyx_k_ETH_HDR_LEN, sizeof(__pyx_k_ETH_HDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_LEN_MAX, __pyx_k_ETH_LEN_MAX, sizeof(__pyx_k_ETH_LEN_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_LEN_MIN, __pyx_k_ETH_LEN_MIN, sizeof(__pyx_k_ETH_LEN_MIN), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_MIN, __pyx_k_ETH_MIN, sizeof(__pyx_k_ETH_MIN), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_MTU, __pyx_k_ETH_MTU, sizeof(__pyx_k_ETH_MTU), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_8021Q, __pyx_k_ETH_TYPE_8021Q, sizeof(__pyx_k_ETH_TYPE_8021Q), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_ARP, __pyx_k_ETH_TYPE_ARP, sizeof(__pyx_k_ETH_TYPE_ARP), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_IP, __pyx_k_ETH_TYPE_IP, sizeof(__pyx_k_ETH_TYPE_IP), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_IPV6, __pyx_k_ETH_TYPE_IPV6, sizeof(__pyx_k_ETH_TYPE_IPV6), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_LEN, __pyx_k_ETH_TYPE_LEN, sizeof(__pyx_k_ETH_TYPE_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_LOOPBACK, __pyx_k_ETH_TYPE_LOOPBACK, sizeof(__pyx_k_ETH_TYPE_LOOPBACK), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_MPLS, __pyx_k_ETH_TYPE_MPLS, sizeof(__pyx_k_ETH_TYPE_MPLS), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_MPLS_MCAST, __pyx_k_ETH_TYPE_MPLS_MCAST, sizeof(__pyx_k_ETH_TYPE_MPLS_MCAST), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_PPPOE, __pyx_k_ETH_TYPE_PPPOE, sizeof(__pyx_k_ETH_TYPE_PPPOE), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_PPPOEDISC, __pyx_k_ETH_TYPE_PPPOEDISC, sizeof(__pyx_k_ETH_TYPE_PPPOEDISC), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_PUP, __pyx_k_ETH_TYPE_PUP, sizeof(__pyx_k_ETH_TYPE_PUP), 0, 0, 1, 1}, + {&__pyx_n_s_ETH_TYPE_REVARP, __pyx_k_ETH_TYPE_REVARP, sizeof(__pyx_k_ETH_TYPE_REVARP), 0, 0, 1, 1}, + {&__pyx_n_s_FW_DIR_IN, __pyx_k_FW_DIR_IN, sizeof(__pyx_k_FW_DIR_IN), 0, 0, 1, 1}, + {&__pyx_n_s_FW_DIR_OUT, __pyx_k_FW_DIR_OUT, sizeof(__pyx_k_FW_DIR_OUT), 0, 0, 1, 1}, + {&__pyx_n_s_FW_OP_ALLOW, __pyx_k_FW_OP_ALLOW, sizeof(__pyx_k_FW_OP_ALLOW), 0, 0, 1, 1}, + {&__pyx_n_s_FW_OP_BLOCK, __pyx_k_FW_OP_BLOCK, sizeof(__pyx_k_FW_OP_BLOCK), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_FLAG_BROADCAST, __pyx_k_INTF_FLAG_BROADCAST, sizeof(__pyx_k_INTF_FLAG_BROADCAST), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_FLAG_LOOPBACK, __pyx_k_INTF_FLAG_LOOPBACK, sizeof(__pyx_k_INTF_FLAG_LOOPBACK), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_FLAG_MULTICAST, __pyx_k_INTF_FLAG_MULTICAST, sizeof(__pyx_k_INTF_FLAG_MULTICAST), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_FLAG_NOARP, __pyx_k_INTF_FLAG_NOARP, sizeof(__pyx_k_INTF_FLAG_NOARP), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_FLAG_POINTOPOINT, __pyx_k_INTF_FLAG_POINTOPOINT, sizeof(__pyx_k_INTF_FLAG_POINTOPOINT), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_FLAG_UP, __pyx_k_INTF_FLAG_UP, sizeof(__pyx_k_INTF_FLAG_UP), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_TYPE_ETH, __pyx_k_INTF_TYPE_ETH, sizeof(__pyx_k_INTF_TYPE_ETH), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_TYPE_LOOPBACK, __pyx_k_INTF_TYPE_LOOPBACK, sizeof(__pyx_k_INTF_TYPE_LOOPBACK), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_TYPE_OTHER, __pyx_k_INTF_TYPE_OTHER, sizeof(__pyx_k_INTF_TYPE_OTHER), 0, 0, 1, 1}, + {&__pyx_n_s_INTF_TYPE_TUN, __pyx_k_INTF_TYPE_TUN, sizeof(__pyx_k_INTF_TYPE_TUN), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_ADDR_BITS, __pyx_k_IP6_ADDR_BITS, sizeof(__pyx_k_IP6_ADDR_BITS), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_ADDR_LEN, __pyx_k_IP6_ADDR_LEN, sizeof(__pyx_k_IP6_ADDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_ADDR_LOOPBACK, __pyx_k_IP6_ADDR_LOOPBACK, sizeof(__pyx_k_IP6_ADDR_LOOPBACK), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_ADDR_UNSPEC, __pyx_k_IP6_ADDR_UNSPEC, sizeof(__pyx_k_IP6_ADDR_UNSPEC), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_HDR_LEN, __pyx_k_IP6_HDR_LEN, sizeof(__pyx_k_IP6_HDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_HLIM_DEFAULT, __pyx_k_IP6_HLIM_DEFAULT, sizeof(__pyx_k_IP6_HLIM_DEFAULT), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_HLIM_MAX, __pyx_k_IP6_HLIM_MAX, sizeof(__pyx_k_IP6_HLIM_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_LEN_MAX, __pyx_k_IP6_LEN_MAX, sizeof(__pyx_k_IP6_LEN_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_LEN_MIN, __pyx_k_IP6_LEN_MIN, sizeof(__pyx_k_IP6_LEN_MIN), 0, 0, 1, 1}, + {&__pyx_n_s_IP6_MTU_MIN, __pyx_k_IP6_MTU_MIN, sizeof(__pyx_k_IP6_MTU_MIN), 0, 0, 1, 1}, + {&__pyx_n_s_IP_ADDR_ANY, __pyx_k_IP_ADDR_ANY, sizeof(__pyx_k_IP_ADDR_ANY), 0, 0, 1, 1}, + {&__pyx_n_s_IP_ADDR_BITS, __pyx_k_IP_ADDR_BITS, sizeof(__pyx_k_IP_ADDR_BITS), 0, 0, 1, 1}, + {&__pyx_n_s_IP_ADDR_BROADCAST, __pyx_k_IP_ADDR_BROADCAST, sizeof(__pyx_k_IP_ADDR_BROADCAST), 0, 0, 1, 1}, + {&__pyx_n_s_IP_ADDR_LEN, __pyx_k_IP_ADDR_LEN, sizeof(__pyx_k_IP_ADDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_IP_ADDR_LOOPBACK, __pyx_k_IP_ADDR_LOOPBACK, sizeof(__pyx_k_IP_ADDR_LOOPBACK), 0, 0, 1, 1}, + {&__pyx_n_s_IP_ADDR_MCAST_ALL, __pyx_k_IP_ADDR_MCAST_ALL, sizeof(__pyx_k_IP_ADDR_MCAST_ALL), 0, 0, 1, 1}, + {&__pyx_n_s_IP_ADDR_MCAST_LOCAL, __pyx_k_IP_ADDR_MCAST_LOCAL, sizeof(__pyx_k_IP_ADDR_MCAST_LOCAL), 0, 0, 1, 1}, + {&__pyx_n_s_IP_DF, __pyx_k_IP_DF, sizeof(__pyx_k_IP_DF), 0, 0, 1, 1}, + {&__pyx_n_s_IP_HDR_LEN, __pyx_k_IP_HDR_LEN, sizeof(__pyx_k_IP_HDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_IP_HDR_LEN_MAX, __pyx_k_IP_HDR_LEN_MAX, sizeof(__pyx_k_IP_HDR_LEN_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_IP_LEN_MAX, __pyx_k_IP_LEN_MAX, sizeof(__pyx_k_IP_LEN_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_IP_LEN_MIN, __pyx_k_IP_LEN_MIN, sizeof(__pyx_k_IP_LEN_MIN), 0, 0, 1, 1}, + {&__pyx_n_s_IP_MF, __pyx_k_IP_MF, sizeof(__pyx_k_IP_MF), 0, 0, 1, 1}, + {&__pyx_n_s_IP_OFFMASK, __pyx_k_IP_OFFMASK, sizeof(__pyx_k_IP_OFFMASK), 0, 0, 1, 1}, + {&__pyx_n_s_IP_OPT_LEN, __pyx_k_IP_OPT_LEN, sizeof(__pyx_k_IP_OPT_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_IP_OPT_LEN_MAX, __pyx_k_IP_OPT_LEN_MAX, sizeof(__pyx_k_IP_OPT_LEN_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_AH, __pyx_k_IP_PROTO_AH, sizeof(__pyx_k_IP_PROTO_AH), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_ESP, __pyx_k_IP_PROTO_ESP, sizeof(__pyx_k_IP_PROTO_ESP), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_GRE, __pyx_k_IP_PROTO_GRE, sizeof(__pyx_k_IP_PROTO_GRE), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_ICMP, __pyx_k_IP_PROTO_ICMP, sizeof(__pyx_k_IP_PROTO_ICMP), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_ICMPV6, __pyx_k_IP_PROTO_ICMPV6, sizeof(__pyx_k_IP_PROTO_ICMPV6), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_IGMP, __pyx_k_IP_PROTO_IGMP, sizeof(__pyx_k_IP_PROTO_IGMP), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_IP, __pyx_k_IP_PROTO_IP, sizeof(__pyx_k_IP_PROTO_IP), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_IPV6, __pyx_k_IP_PROTO_IPV6, sizeof(__pyx_k_IP_PROTO_IPV6), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_MAX, __pyx_k_IP_PROTO_MAX, sizeof(__pyx_k_IP_PROTO_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_RAW, __pyx_k_IP_PROTO_RAW, sizeof(__pyx_k_IP_PROTO_RAW), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_RESERVED, __pyx_k_IP_PROTO_RESERVED, sizeof(__pyx_k_IP_PROTO_RESERVED), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_TCP, __pyx_k_IP_PROTO_TCP, sizeof(__pyx_k_IP_PROTO_TCP), 0, 0, 1, 1}, + {&__pyx_n_s_IP_PROTO_UDP, __pyx_k_IP_PROTO_UDP, sizeof(__pyx_k_IP_PROTO_UDP), 0, 0, 1, 1}, + {&__pyx_n_s_IP_RF, __pyx_k_IP_RF, sizeof(__pyx_k_IP_RF), 0, 0, 1, 1}, + {&__pyx_n_s_IP_TOS_DEFAULT, __pyx_k_IP_TOS_DEFAULT, sizeof(__pyx_k_IP_TOS_DEFAULT), 0, 0, 1, 1}, + {&__pyx_n_s_IP_TTL_DEFAULT, __pyx_k_IP_TTL_DEFAULT, sizeof(__pyx_k_IP_TTL_DEFAULT), 0, 0, 1, 1}, + {&__pyx_n_s_IP_TTL_MAX, __pyx_k_IP_TTL_MAX, sizeof(__pyx_k_IP_TTL_MAX), 0, 0, 1, 1}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_n_s_NotImplementedError, __pyx_k_NotImplementedError, sizeof(__pyx_k_NotImplementedError), 0, 0, 1, 1}, + {&__pyx_n_s_OSError, __pyx_k_OSError, sizeof(__pyx_k_OSError), 0, 0, 1, 1}, + {&__pyx_kp_u_Oliver_Falk_oliver_linux_kernel, __pyx_k_Oliver_Falk_oliver_linux_kernel, sizeof(__pyx_k_Oliver_Falk_oliver_linux_kernel), 0, 1, 0, 0}, + {&__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_kp_s_Pickling_of_struct_members_such, __pyx_k_Pickling_of_struct_members_such, sizeof(__pyx_k_Pickling_of_struct_members_such), 0, 0, 1, 0}, + {&__pyx_n_s_StopIteration, __pyx_k_StopIteration, sizeof(__pyx_k_StopIteration), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_HDR_LEN, __pyx_k_TCP_HDR_LEN, sizeof(__pyx_k_TCP_HDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_ALTSUM, __pyx_k_TCP_OPT_ALTSUM, sizeof(__pyx_k_TCP_OPT_ALTSUM), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_ALTSUMDATA, __pyx_k_TCP_OPT_ALTSUMDATA, sizeof(__pyx_k_TCP_OPT_ALTSUMDATA), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_BUBBA, __pyx_k_TCP_OPT_BUBBA, sizeof(__pyx_k_TCP_OPT_BUBBA), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_CC, __pyx_k_TCP_OPT_CC, sizeof(__pyx_k_TCP_OPT_CC), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_CCECHO, __pyx_k_TCP_OPT_CCECHO, sizeof(__pyx_k_TCP_OPT_CCECHO), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_CCNEW, __pyx_k_TCP_OPT_CCNEW, sizeof(__pyx_k_TCP_OPT_CCNEW), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_CORRUPT, __pyx_k_TCP_OPT_CORRUPT, sizeof(__pyx_k_TCP_OPT_CORRUPT), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_ECHO, __pyx_k_TCP_OPT_ECHO, sizeof(__pyx_k_TCP_OPT_ECHO), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_ECHOREPLY, __pyx_k_TCP_OPT_ECHOREPLY, sizeof(__pyx_k_TCP_OPT_ECHOREPLY), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_EOL, __pyx_k_TCP_OPT_EOL, sizeof(__pyx_k_TCP_OPT_EOL), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_MAX, __pyx_k_TCP_OPT_MAX, sizeof(__pyx_k_TCP_OPT_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_MD5, __pyx_k_TCP_OPT_MD5, sizeof(__pyx_k_TCP_OPT_MD5), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_MSS, __pyx_k_TCP_OPT_MSS, sizeof(__pyx_k_TCP_OPT_MSS), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_NOP, __pyx_k_TCP_OPT_NOP, sizeof(__pyx_k_TCP_OPT_NOP), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_POCONN, __pyx_k_TCP_OPT_POCONN, sizeof(__pyx_k_TCP_OPT_POCONN), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_POSVC, __pyx_k_TCP_OPT_POSVC, sizeof(__pyx_k_TCP_OPT_POSVC), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_REC, __pyx_k_TCP_OPT_REC, sizeof(__pyx_k_TCP_OPT_REC), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_SACK, __pyx_k_TCP_OPT_SACK, sizeof(__pyx_k_TCP_OPT_SACK), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_SACKOK, __pyx_k_TCP_OPT_SACKOK, sizeof(__pyx_k_TCP_OPT_SACKOK), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_SCPS, __pyx_k_TCP_OPT_SCPS, sizeof(__pyx_k_TCP_OPT_SCPS), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_SKEETER, __pyx_k_TCP_OPT_SKEETER, sizeof(__pyx_k_TCP_OPT_SKEETER), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_SNACK, __pyx_k_TCP_OPT_SNACK, sizeof(__pyx_k_TCP_OPT_SNACK), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_SNAP, __pyx_k_TCP_OPT_SNAP, sizeof(__pyx_k_TCP_OPT_SNAP), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_TCPCOMP, __pyx_k_TCP_OPT_TCPCOMP, sizeof(__pyx_k_TCP_OPT_TCPCOMP), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_TIMESTAMP, __pyx_k_TCP_OPT_TIMESTAMP, sizeof(__pyx_k_TCP_OPT_TIMESTAMP), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_TRAILSUM, __pyx_k_TCP_OPT_TRAILSUM, sizeof(__pyx_k_TCP_OPT_TRAILSUM), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_OPT_WSCALE, __pyx_k_TCP_OPT_WSCALE, sizeof(__pyx_k_TCP_OPT_WSCALE), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_PORT_MAX, __pyx_k_TCP_PORT_MAX, sizeof(__pyx_k_TCP_PORT_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_TCP_WIN_MAX, __pyx_k_TCP_WIN_MAX, sizeof(__pyx_k_TCP_WIN_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_TH_ACK, __pyx_k_TH_ACK, sizeof(__pyx_k_TH_ACK), 0, 0, 1, 1}, + {&__pyx_n_s_TH_CWR, __pyx_k_TH_CWR, sizeof(__pyx_k_TH_CWR), 0, 0, 1, 1}, + {&__pyx_n_s_TH_ECE, __pyx_k_TH_ECE, sizeof(__pyx_k_TH_ECE), 0, 0, 1, 1}, + {&__pyx_n_s_TH_FIN, __pyx_k_TH_FIN, sizeof(__pyx_k_TH_FIN), 0, 0, 1, 1}, + {&__pyx_n_s_TH_PUSH, __pyx_k_TH_PUSH, sizeof(__pyx_k_TH_PUSH), 0, 0, 1, 1}, + {&__pyx_n_s_TH_RST, __pyx_k_TH_RST, sizeof(__pyx_k_TH_RST), 0, 0, 1, 1}, + {&__pyx_n_s_TH_SYN, __pyx_k_TH_SYN, sizeof(__pyx_k_TH_SYN), 0, 0, 1, 1}, + {&__pyx_n_s_TH_URG, __pyx_k_TH_URG, sizeof(__pyx_k_TH_URG), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_n_s_UDP_HDR_LEN, __pyx_k_UDP_HDR_LEN, sizeof(__pyx_k_UDP_HDR_LEN), 0, 0, 1, 1}, + {&__pyx_n_s_UDP_PORT_MAX, __pyx_k_UDP_PORT_MAX, sizeof(__pyx_k_UDP_PORT_MAX), 0, 0, 1, 1}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s__120, __pyx_k__120, sizeof(__pyx_k__120), 0, 0, 1, 1}, + {&__pyx_kp_u__3, __pyx_k__3, sizeof(__pyx_k__3), 0, 1, 0, 0}, + {&__pyx_n_s_a, __pyx_k_a, sizeof(__pyx_k_a), 0, 0, 1, 1}, + {&__pyx_n_s_ack, __pyx_k_ack, sizeof(__pyx_k_ack), 0, 0, 1, 1}, + {&__pyx_n_s_add, __pyx_k_add, sizeof(__pyx_k_add), 0, 0, 1, 1}, + {&__pyx_n_s_addr, __pyx_k_addr, sizeof(__pyx_k_addr), 0, 0, 1, 1}, + {&__pyx_n_u_addr, __pyx_k_addr, sizeof(__pyx_k_addr), 0, 1, 0, 1}, + {&__pyx_n_s_addr___copy, __pyx_k_addr___copy, sizeof(__pyx_k_addr___copy), 0, 0, 1, 1}, + {&__pyx_n_s_addr___reduce_cython, __pyx_k_addr___reduce_cython, sizeof(__pyx_k_addr___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_addr___setstate_cython, __pyx_k_addr___setstate_cython, sizeof(__pyx_k_addr___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_addr_bcast, __pyx_k_addr_bcast, sizeof(__pyx_k_addr_bcast), 0, 0, 1, 1}, + {&__pyx_n_s_addr_ip4_iter, __pyx_k_addr_ip4_iter, sizeof(__pyx_k_addr_ip4_iter), 0, 0, 1, 1}, + {&__pyx_n_s_addr_ip4_iter___reduce_cython, __pyx_k_addr_ip4_iter___reduce_cython, sizeof(__pyx_k_addr_ip4_iter___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_addr_ip4_iter___setstate_cytho, __pyx_k_addr_ip4_iter___setstate_cytho, sizeof(__pyx_k_addr_ip4_iter___setstate_cytho), 0, 0, 1, 1}, + {&__pyx_n_s_addr_net, __pyx_k_addr_net, sizeof(__pyx_k_addr_net), 0, 0, 1, 1}, + {&__pyx_n_s_addrtxt, __pyx_k_addrtxt, sizeof(__pyx_k_addrtxt), 0, 0, 1, 1}, + {&__pyx_n_s_addrtype, __pyx_k_addrtype, sizeof(__pyx_k_addrtype), 0, 0, 1, 1}, + {&__pyx_n_u_alias_addrs, __pyx_k_alias_addrs, sizeof(__pyx_k_alias_addrs), 0, 1, 0, 1}, + {&__pyx_n_s_append, __pyx_k_append, sizeof(__pyx_k_append), 0, 0, 1, 1}, + {&__pyx_n_s_arg, __pyx_k_arg, sizeof(__pyx_k_arg), 0, 0, 1, 1}, + {&__pyx_n_s_arg_2, __pyx_k_arg_2, sizeof(__pyx_k_arg_2), 0, 0, 1, 1}, + {&__pyx_n_s_arp, __pyx_k_arp, sizeof(__pyx_k_arp), 0, 0, 1, 1}, + {&__pyx_n_s_arp___reduce_cython, __pyx_k_arp___reduce_cython, sizeof(__pyx_k_arp___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_arp___setstate_cython, __pyx_k_arp___setstate_cython, sizeof(__pyx_k_arp___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_arp_add, __pyx_k_arp_add, sizeof(__pyx_k_arp_add), 0, 0, 1, 1}, + {&__pyx_n_s_arp_delete, __pyx_k_arp_delete, sizeof(__pyx_k_arp_delete), 0, 0, 1, 1}, + {&__pyx_n_s_arp_get, __pyx_k_arp_get, sizeof(__pyx_k_arp_get), 0, 0, 1, 1}, + {&__pyx_n_s_arp_loop, __pyx_k_arp_loop, sizeof(__pyx_k_arp_loop), 0, 0, 1, 1}, + {&__pyx_n_s_arp_pack_hdr_ethip, __pyx_k_arp_pack_hdr_ethip, sizeof(__pyx_k_arp_pack_hdr_ethip), 0, 0, 1, 1}, + {&__pyx_n_s_asyncio_coroutines, __pyx_k_asyncio_coroutines, sizeof(__pyx_k_asyncio_coroutines), 0, 0, 1, 1}, + {&__pyx_n_s_author, __pyx_k_author, sizeof(__pyx_k_author), 0, 0, 1, 1}, + {&__pyx_n_s_bcast, __pyx_k_bcast, sizeof(__pyx_k_bcast), 0, 0, 1, 1}, + {&__pyx_n_s_buf, __pyx_k_buf, sizeof(__pyx_k_buf), 0, 0, 1, 1}, + {&__pyx_kp_u_byte_binary_string, __pyx_k_byte_binary_string, sizeof(__pyx_k_byte_binary_string), 0, 1, 0, 0}, + {&__pyx_n_s_callback, __pyx_k_callback, sizeof(__pyx_k_callback), 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_code, __pyx_k_code, sizeof(__pyx_k_code), 0, 0, 1, 1}, + {&__pyx_n_s_copy, __pyx_k_copy, sizeof(__pyx_k_copy), 0, 0, 1, 1}, + {&__pyx_n_s_copyright, __pyx_k_copyright, sizeof(__pyx_k_copyright), 0, 0, 1, 1}, + {&__pyx_n_s_cur, __pyx_k_cur, sizeof(__pyx_k_cur), 0, 0, 1, 1}, + {&__pyx_n_s_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 0, 1, 1}, + {&__pyx_n_u_d, __pyx_k_d, sizeof(__pyx_k_d), 0, 1, 0, 1}, + {&__pyx_n_s_delete, __pyx_k_delete, sizeof(__pyx_k_delete), 0, 0, 1, 1}, + {&__pyx_n_s_device, __pyx_k_device, sizeof(__pyx_k_device), 0, 0, 1, 1}, + {&__pyx_n_u_device, __pyx_k_device, sizeof(__pyx_k_device), 0, 1, 0, 1}, + {&__pyx_n_s_dh, __pyx_k_dh, sizeof(__pyx_k_dh), 0, 0, 1, 1}, + {&__pyx_n_s_dha, __pyx_k_dha, sizeof(__pyx_k_dha), 0, 0, 1, 1}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dict_2, __pyx_k_dict_2, sizeof(__pyx_k_dict_2), 0, 0, 1, 1}, + {&__pyx_n_u_dir, __pyx_k_dir, sizeof(__pyx_k_dir), 0, 1, 0, 1}, + {&__pyx_kp_u_disable, __pyx_k_disable, sizeof(__pyx_k_disable), 0, 1, 0, 0}, + {&__pyx_n_s_dnet, __pyx_k_dnet, sizeof(__pyx_k_dnet), 0, 0, 1, 1}, + {&__pyx_kp_s_dnet_pyx, __pyx_k_dnet_pyx, sizeof(__pyx_k_dnet_pyx), 0, 0, 1, 0}, + {&__pyx_n_s_dp, __pyx_k_dp, sizeof(__pyx_k_dp), 0, 0, 1, 1}, + {&__pyx_n_s_dpa, __pyx_k_dpa, sizeof(__pyx_k_dpa), 0, 0, 1, 1}, + {&__pyx_n_s_dport, __pyx_k_dport, sizeof(__pyx_k_dport), 0, 0, 1, 1}, + {&__pyx_n_u_dport, __pyx_k_dport, sizeof(__pyx_k_dport), 0, 1, 0, 1}, + {&__pyx_n_s_dst, __pyx_k_dst, sizeof(__pyx_k_dst), 0, 0, 1, 1}, + {&__pyx_n_u_dst, __pyx_k_dst, sizeof(__pyx_k_dst), 0, 1, 0, 1}, + {&__pyx_n_u_dst_addr, __pyx_k_dst_addr, sizeof(__pyx_k_dst_addr), 0, 1, 0, 1}, + {&__pyx_n_s_ea, __pyx_k_ea, sizeof(__pyx_k_ea), 0, 0, 1, 1}, + {&__pyx_kp_u_enable, __pyx_k_enable, sizeof(__pyx_k_enable), 0, 1, 0, 0}, + {&__pyx_n_s_entry, __pyx_k_entry, sizeof(__pyx_k_entry), 0, 0, 1, 1}, + {&__pyx_n_s_eth, __pyx_k_eth, sizeof(__pyx_k_eth), 0, 0, 1, 1}, + {&__pyx_n_s_eth___reduce_cython, __pyx_k_eth___reduce_cython, sizeof(__pyx_k_eth___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_eth___setstate_cython, __pyx_k_eth___setstate_cython, sizeof(__pyx_k_eth___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_eth_aton, __pyx_k_eth_aton, sizeof(__pyx_k_eth_aton), 0, 0, 1, 1}, + {&__pyx_n_s_eth_get, __pyx_k_eth_get, sizeof(__pyx_k_eth_get), 0, 0, 1, 1}, + {&__pyx_n_s_eth_ntoa, __pyx_k_eth_ntoa, sizeof(__pyx_k_eth_ntoa), 0, 0, 1, 1}, + {&__pyx_n_s_eth_pack_hdr, __pyx_k_eth_pack_hdr, sizeof(__pyx_k_eth_pack_hdr), 0, 0, 1, 1}, + {&__pyx_n_s_eth_send, __pyx_k_eth_send, sizeof(__pyx_k_eth_send), 0, 0, 1, 1}, + {&__pyx_n_s_eth_set, __pyx_k_eth_set, sizeof(__pyx_k_eth_set), 0, 0, 1, 1}, + {&__pyx_n_s_etype, __pyx_k_etype, sizeof(__pyx_k_etype), 0, 0, 1, 1}, + {&__pyx_n_s_fc, __pyx_k_fc, sizeof(__pyx_k_fc), 0, 0, 1, 1}, + {&__pyx_n_s_fileno, __pyx_k_fileno, sizeof(__pyx_k_fileno), 0, 0, 1, 1}, + {&__pyx_n_s_fl, __pyx_k_fl, sizeof(__pyx_k_fl), 0, 0, 1, 1}, + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_u_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 1, 0, 1}, + {&__pyx_n_s_frame, __pyx_k_frame, sizeof(__pyx_k_frame), 0, 0, 1, 1}, + {&__pyx_n_s_fw, __pyx_k_fw, sizeof(__pyx_k_fw), 0, 0, 1, 1}, + {&__pyx_n_s_fw___reduce_cython, __pyx_k_fw___reduce_cython, sizeof(__pyx_k_fw___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_fw___setstate_cython, __pyx_k_fw___setstate_cython, sizeof(__pyx_k_fw___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_fw_add, __pyx_k_fw_add, sizeof(__pyx_k_fw_add), 0, 0, 1, 1}, + {&__pyx_n_s_fw_delete, __pyx_k_fw_delete, sizeof(__pyx_k_fw_delete), 0, 0, 1, 1}, + {&__pyx_n_s_fw_loop, __pyx_k_fw_loop, sizeof(__pyx_k_fw_loop), 0, 0, 1, 1}, + {&__pyx_kp_u_gc, __pyx_k_gc, sizeof(__pyx_k_gc), 0, 1, 0, 0}, + {&__pyx_n_s_get, __pyx_k_get, sizeof(__pyx_k_get), 0, 0, 1, 1}, + {&__pyx_n_s_get_dst, __pyx_k_get_dst, sizeof(__pyx_k_get_dst), 0, 0, 1, 1}, + {&__pyx_n_s_get_src, __pyx_k_get_src, sizeof(__pyx_k_get_src), 0, 0, 1, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_n_s_gw, __pyx_k_gw, sizeof(__pyx_k_gw), 0, 0, 1, 1}, + {&__pyx_n_s_ha, __pyx_k_ha, sizeof(__pyx_k_ha), 0, 0, 1, 1}, + {&__pyx_n_s_hdr, __pyx_k_hdr, sizeof(__pyx_k_hdr), 0, 0, 1, 1}, + {&__pyx_n_s_hlim, __pyx_k_hlim, sizeof(__pyx_k_hlim), 0, 0, 1, 1}, + {&__pyx_kp_u_https_github_com_ofalk_libdnet, __pyx_k_https_github_com_ofalk_libdnet, sizeof(__pyx_k_https_github_com_ofalk_libdnet), 0, 1, 0, 0}, + {&__pyx_n_s_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__pyx_n_s_ia, __pyx_k_ia, sizeof(__pyx_k_ia), 0, 0, 1, 1}, + {&__pyx_n_s_icmp_pack_hdr, __pyx_k_icmp_pack_hdr, sizeof(__pyx_k_icmp_pack_hdr), 0, 0, 1, 1}, + {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, + {&__pyx_n_s_ifent, __pyx_k_ifent, sizeof(__pyx_k_ifent), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_int, __pyx_k_int, sizeof(__pyx_k_int), 0, 0, 1, 1}, + {&__pyx_n_s_intf, __pyx_k_intf, sizeof(__pyx_k_intf), 0, 0, 1, 1}, + {&__pyx_n_s_intf___reduce_cython, __pyx_k_intf___reduce_cython, sizeof(__pyx_k_intf___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_intf___setstate_cython, __pyx_k_intf___setstate_cython, sizeof(__pyx_k_intf___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_intf_get, __pyx_k_intf_get, sizeof(__pyx_k_intf_get), 0, 0, 1, 1}, + {&__pyx_n_s_intf_get_dst, __pyx_k_intf_get_dst, sizeof(__pyx_k_intf_get_dst), 0, 0, 1, 1}, + {&__pyx_n_s_intf_get_src, __pyx_k_intf_get_src, sizeof(__pyx_k_intf_get_src), 0, 0, 1, 1}, + {&__pyx_n_s_intf_loop, __pyx_k_intf_loop, sizeof(__pyx_k_intf_loop), 0, 0, 1, 1}, + {&__pyx_n_s_intf_set, __pyx_k_intf_set, sizeof(__pyx_k_intf_set), 0, 0, 1, 1}, + {&__pyx_kp_u_invalid_Ethernet_address, __pyx_k_invalid_Ethernet_address, sizeof(__pyx_k_invalid_Ethernet_address), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_IP_address, __pyx_k_invalid_IP_address, sizeof(__pyx_k_invalid_IP_address), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_IPv6_address, __pyx_k_invalid_IPv6_address, sizeof(__pyx_k_invalid_IPv6_address), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_network_address, __pyx_k_invalid_network_address, sizeof(__pyx_k_invalid_network_address), 0, 1, 0, 0}, + {&__pyx_kp_u_invalid_network_address_2, __pyx_k_invalid_network_address_2, sizeof(__pyx_k_invalid_network_address_2), 0, 1, 0, 0}, + {&__pyx_n_s_ip, __pyx_k_ip, sizeof(__pyx_k_ip), 0, 0, 1, 1}, + {&__pyx_n_s_ip6, __pyx_k_ip6, sizeof(__pyx_k_ip6), 0, 0, 1, 1}, + {&__pyx_n_s_ip6_aton, __pyx_k_ip6_aton, sizeof(__pyx_k_ip6_aton), 0, 0, 1, 1}, + {&__pyx_n_s_ip6_checksum, __pyx_k_ip6_checksum, sizeof(__pyx_k_ip6_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_ip6_ntoa, __pyx_k_ip6_ntoa, sizeof(__pyx_k_ip6_ntoa), 0, 0, 1, 1}, + {&__pyx_n_s_ip6_pack_hdr, __pyx_k_ip6_pack_hdr, sizeof(__pyx_k_ip6_pack_hdr), 0, 0, 1, 1}, + {&__pyx_n_s_ip___reduce_cython, __pyx_k_ip___reduce_cython, sizeof(__pyx_k_ip___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ip___setstate_cython, __pyx_k_ip___setstate_cython, sizeof(__pyx_k_ip___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_ip_aton, __pyx_k_ip_aton, sizeof(__pyx_k_ip_aton), 0, 0, 1, 1}, + {&__pyx_n_s_ip_checksum, __pyx_k_ip_checksum, sizeof(__pyx_k_ip_checksum), 0, 0, 1, 1}, + {&__pyx_n_s_ip_cksum_add, __pyx_k_ip_cksum_add, sizeof(__pyx_k_ip_cksum_add), 0, 0, 1, 1}, + {&__pyx_n_s_ip_cksum_carry, __pyx_k_ip_cksum_carry, sizeof(__pyx_k_ip_cksum_carry), 0, 0, 1, 1}, + {&__pyx_n_s_ip_ntoa, __pyx_k_ip_ntoa, sizeof(__pyx_k_ip_ntoa), 0, 0, 1, 1}, + {&__pyx_n_s_ip_pack_hdr, __pyx_k_ip_pack_hdr, sizeof(__pyx_k_ip_pack_hdr), 0, 0, 1, 1}, + {&__pyx_n_s_ip_send, __pyx_k_ip_send, sizeof(__pyx_k_ip_send), 0, 0, 1, 1}, + {&__pyx_n_s_is_coroutine, __pyx_k_is_coroutine, sizeof(__pyx_k_is_coroutine), 0, 0, 1, 1}, + {&__pyx_kp_u_isenabled, __pyx_k_isenabled, sizeof(__pyx_k_isenabled), 0, 1, 0, 0}, + {&__pyx_n_s_iter_append, __pyx_k_iter_append, sizeof(__pyx_k_iter_append), 0, 0, 1, 1}, + {&__pyx_n_s_itype, __pyx_k_itype, sizeof(__pyx_k_itype), 0, 0, 1, 1}, + {&__pyx_n_s_l, __pyx_k_l, sizeof(__pyx_k_l), 0, 0, 1, 1}, + {&__pyx_n_s_len, __pyx_k_len, sizeof(__pyx_k_len), 0, 0, 1, 1}, + {&__pyx_n_s_license, __pyx_k_license, sizeof(__pyx_k_license), 0, 0, 1, 1}, + {&__pyx_n_u_link_addr, __pyx_k_link_addr, sizeof(__pyx_k_link_addr), 0, 1, 0, 1}, + {&__pyx_n_s_loop, __pyx_k_loop, sizeof(__pyx_k_loop), 0, 0, 1, 1}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_max, __pyx_k_max, sizeof(__pyx_k_max), 0, 0, 1, 1}, + {&__pyx_n_s_mtu, __pyx_k_mtu, sizeof(__pyx_k_mtu), 0, 0, 1, 1}, + {&__pyx_n_u_mtu, __pyx_k_mtu, sizeof(__pyx_k_mtu), 0, 1, 0, 1}, + {&__pyx_n_s_n, __pyx_k_n, sizeof(__pyx_k_n), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_u_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 1, 0, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_net, __pyx_k_net, sizeof(__pyx_k_net), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_kp_u_non_Ethernet_address, __pyx_k_non_Ethernet_address, sizeof(__pyx_k_non_Ethernet_address), 0, 1, 0, 0}, + {&__pyx_kp_u_non_IP_address, __pyx_k_non_IP_address, sizeof(__pyx_k_non_IP_address), 0, 1, 0, 0}, + {&__pyx_kp_u_non_IPv6_address, __pyx_k_non_IPv6_address, sizeof(__pyx_k_non_IPv6_address), 0, 1, 0, 0}, + {&__pyx_kp_u_not_a, __pyx_k_not_a, sizeof(__pyx_k_not_a), 0, 1, 0, 0}, + {&__pyx_kp_u_not_a_16_byte_string, __pyx_k_not_a_16_byte_string, sizeof(__pyx_k_not_a_16_byte_string), 0, 1, 0, 0}, + {&__pyx_kp_u_not_a_4_byte_string, __pyx_k_not_a_4_byte_string, sizeof(__pyx_k_not_a_4_byte_string), 0, 1, 0, 0}, + {&__pyx_kp_u_not_a_6_byte_string, __pyx_k_not_a_6_byte_string, sizeof(__pyx_k_not_a_6_byte_string), 0, 1, 0, 0}, + {&__pyx_n_s_nxt, __pyx_k_nxt, sizeof(__pyx_k_nxt), 0, 0, 1, 1}, + {&__pyx_n_s_off, __pyx_k_off, sizeof(__pyx_k_off), 0, 0, 1, 1}, + {&__pyx_n_s_op, __pyx_k_op, sizeof(__pyx_k_op), 0, 0, 1, 1}, + {&__pyx_n_u_op, __pyx_k_op, sizeof(__pyx_k_op), 0, 1, 0, 1}, + {&__pyx_n_s_p, __pyx_k_p, sizeof(__pyx_k_p), 0, 0, 1, 1}, + {&__pyx_n_s_pa, __pyx_k_pa, sizeof(__pyx_k_pa), 0, 0, 1, 1}, + {&__pyx_n_s_pickle, __pyx_k_pickle, sizeof(__pyx_k_pickle), 0, 0, 1, 1}, + {&__pyx_n_s_pkt, __pyx_k_pkt, sizeof(__pyx_k_pkt), 0, 0, 1, 1}, + {&__pyx_n_s_plen, __pyx_k_plen, sizeof(__pyx_k_plen), 0, 0, 1, 1}, + {&__pyx_n_u_proto, __pyx_k_proto, sizeof(__pyx_k_proto), 0, 1, 0, 1}, + {&__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___addr_ip4_iter, __pyx_k_pyx_unpickle___addr_ip4_iter, sizeof(__pyx_k_pyx_unpickle___addr_ip4_iter), 0, 0, 1, 1}, + {&__pyx_n_s_r, __pyx_k_r, sizeof(__pyx_k_r), 0, 0, 1, 1}, + {&__pyx_n_s_rand, __pyx_k_rand, sizeof(__pyx_k_rand), 0, 0, 1, 1}, + {&__pyx_n_s_rand___reduce_cython, __pyx_k_rand___reduce_cython, sizeof(__pyx_k_rand___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_rand___setstate_cython, __pyx_k_rand___setstate_cython, sizeof(__pyx_k_rand___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_rand_add, __pyx_k_rand_add, sizeof(__pyx_k_rand_add), 0, 0, 1, 1}, + {&__pyx_n_s_rand_get, __pyx_k_rand_get, sizeof(__pyx_k_rand_get), 0, 0, 1, 1}, + {&__pyx_n_s_rand_set, __pyx_k_rand_set, sizeof(__pyx_k_rand_set), 0, 0, 1, 1}, + {&__pyx_n_s_rand_uint16, __pyx_k_rand_uint16, sizeof(__pyx_k_rand_uint16), 0, 0, 1, 1}, + {&__pyx_n_s_rand_uint32, __pyx_k_rand_uint32, sizeof(__pyx_k_rand_uint32), 0, 0, 1, 1}, + {&__pyx_n_s_rand_uint8, __pyx_k_rand_uint8, sizeof(__pyx_k_rand_uint8), 0, 0, 1, 1}, + {&__pyx_n_s_rand_xrange, __pyx_k_rand_xrange, sizeof(__pyx_k_rand_xrange), 0, 0, 1, 1}, + {&__pyx_n_s_rand_xrange_2, __pyx_k_rand_xrange_2, sizeof(__pyx_k_rand_xrange_2), 0, 0, 1, 1}, + {&__pyx_n_s_rand_xrange___reduce_cython, __pyx_k_rand_xrange___reduce_cython, sizeof(__pyx_k_rand_xrange___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_rand_xrange___setstate_cython, __pyx_k_rand_xrange___setstate_cython, sizeof(__pyx_k_rand_xrange___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_recv, __pyx_k_recv, sizeof(__pyx_k_recv), 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_route, __pyx_k_route, sizeof(__pyx_k_route), 0, 0, 1, 1}, + {&__pyx_n_s_route___reduce_cython, __pyx_k_route___reduce_cython, sizeof(__pyx_k_route___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_route___setstate_cython, __pyx_k_route___setstate_cython, sizeof(__pyx_k_route___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_route_add, __pyx_k_route_add, sizeof(__pyx_k_route_add), 0, 0, 1, 1}, + {&__pyx_n_s_route_delete, __pyx_k_route_delete, sizeof(__pyx_k_route_delete), 0, 0, 1, 1}, + {&__pyx_n_s_route_get, __pyx_k_route_get, sizeof(__pyx_k_route_get), 0, 0, 1, 1}, + {&__pyx_n_s_route_loop, __pyx_k_route_loop, sizeof(__pyx_k_route_loop), 0, 0, 1, 1}, + {&__pyx_n_s_rule, __pyx_k_rule, sizeof(__pyx_k_rule), 0, 0, 1, 1}, + {&__pyx_n_s_s, __pyx_k_s, sizeof(__pyx_k_s), 0, 0, 1, 1}, + {&__pyx_n_s_self, __pyx_k_self, sizeof(__pyx_k_self), 0, 0, 1, 1}, + {&__pyx_kp_s_self_arp_cannot_be_converted_to, __pyx_k_self_arp_cannot_be_converted_to, sizeof(__pyx_k_self_arp_cannot_be_converted_to), 0, 0, 1, 0}, + {&__pyx_kp_s_self_eth_cannot_be_converted_to, __pyx_k_self_eth_cannot_be_converted_to, sizeof(__pyx_k_self_eth_cannot_be_converted_to), 0, 0, 1, 0}, + {&__pyx_kp_s_self_fw_cannot_be_converted_to_a, __pyx_k_self_fw_cannot_be_converted_to_a, sizeof(__pyx_k_self_fw_cannot_be_converted_to_a), 0, 0, 1, 0}, + {&__pyx_kp_s_self_intf_cannot_be_converted_to, __pyx_k_self_intf_cannot_be_converted_to, sizeof(__pyx_k_self_intf_cannot_be_converted_to), 0, 0, 1, 0}, + {&__pyx_kp_s_self_ip_cannot_be_converted_to_a, __pyx_k_self_ip_cannot_be_converted_to_a, sizeof(__pyx_k_self_ip_cannot_be_converted_to_a), 0, 0, 1, 0}, + {&__pyx_kp_s_self_rand_cannot_be_converted_to, __pyx_k_self_rand_cannot_be_converted_to, sizeof(__pyx_k_self_rand_cannot_be_converted_to), 0, 0, 1, 0}, + {&__pyx_kp_s_self_route_cannot_be_converted_t, __pyx_k_self_route_cannot_be_converted_t, sizeof(__pyx_k_self_route_cannot_be_converted_t), 0, 0, 1, 0}, + {&__pyx_kp_s_self_tun_cannot_be_converted_to, __pyx_k_self_tun_cannot_be_converted_to, sizeof(__pyx_k_self_tun_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_seq, __pyx_k_seq, sizeof(__pyx_k_seq), 0, 0, 1, 1}, + {&__pyx_n_s_set, __pyx_k_set, sizeof(__pyx_k_set), 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_sh, __pyx_k_sh, sizeof(__pyx_k_sh), 0, 0, 1, 1}, + {&__pyx_n_s_sha, __pyx_k_sha, sizeof(__pyx_k_sha), 0, 0, 1, 1}, + {&__pyx_n_s_sp, __pyx_k_sp, sizeof(__pyx_k_sp), 0, 0, 1, 1}, + {&__pyx_n_s_spa, __pyx_k_spa, sizeof(__pyx_k_spa), 0, 0, 1, 1}, + {&__pyx_n_s_sport, __pyx_k_sport, sizeof(__pyx_k_sport), 0, 0, 1, 1}, + {&__pyx_n_u_sport, __pyx_k_sport, sizeof(__pyx_k_sport), 0, 1, 0, 1}, + {&__pyx_n_s_src, __pyx_k_src, sizeof(__pyx_k_src), 0, 0, 1, 1}, + {&__pyx_n_u_src, __pyx_k_src, sizeof(__pyx_k_src), 0, 1, 0, 1}, + {&__pyx_n_s_start, __pyx_k_start, sizeof(__pyx_k_start), 0, 0, 1, 1}, + {&__pyx_kp_u_start_must_be_an_integer, __pyx_k_start_must_be_an_integer, sizeof(__pyx_k_start_must_be_an_integer), 0, 1, 0, 0}, + {&__pyx_n_s_state, __pyx_k_state, sizeof(__pyx_k_state), 0, 0, 1, 1}, + {&__pyx_n_s_stop, __pyx_k_stop, sizeof(__pyx_k_stop), 0, 0, 1, 1}, + {&__pyx_kp_u_stop_must_be_an_integer, __pyx_k_stop_must_be_an_integer, sizeof(__pyx_k_stop_must_be_an_integer), 0, 1, 0, 0}, + {&__pyx_kp_s_stringsource, __pyx_k_stringsource, sizeof(__pyx_k_stringsource), 0, 0, 1, 0}, + {&__pyx_n_s_sum, __pyx_k_sum, sizeof(__pyx_k_sum), 0, 0, 1, 1}, + {&__pyx_n_s_tcp_pack_hdr, __pyx_k_tcp_pack_hdr, sizeof(__pyx_k_tcp_pack_hdr), 0, 0, 1, 1}, + {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1}, + {&__pyx_n_s_tos, __pyx_k_tos, sizeof(__pyx_k_tos), 0, 0, 1, 1}, + {&__pyx_n_s_ttl, __pyx_k_ttl, sizeof(__pyx_k_ttl), 0, 0, 1, 1}, + {&__pyx_n_s_tun, __pyx_k_tun, sizeof(__pyx_k_tun), 0, 0, 1, 1}, + {&__pyx_n_s_tun___reduce_cython, __pyx_k_tun___reduce_cython, sizeof(__pyx_k_tun___reduce_cython), 0, 0, 1, 1}, + {&__pyx_n_s_tun___setstate_cython, __pyx_k_tun___setstate_cython, sizeof(__pyx_k_tun___setstate_cython), 0, 0, 1, 1}, + {&__pyx_n_s_tun_close, __pyx_k_tun_close, sizeof(__pyx_k_tun_close), 0, 0, 1, 1}, + {&__pyx_n_s_tun_fileno, __pyx_k_tun_fileno, sizeof(__pyx_k_tun_fileno), 0, 0, 1, 1}, + {&__pyx_n_s_tun_recv, __pyx_k_tun_recv, sizeof(__pyx_k_tun_recv), 0, 0, 1, 1}, + {&__pyx_n_s_tun_send, __pyx_k_tun_send, sizeof(__pyx_k_tun_send), 0, 0, 1, 1}, + {&__pyx_n_u_type, __pyx_k_type, sizeof(__pyx_k_type), 0, 1, 0, 1}, + {&__pyx_n_s_udp_pack_hdr, __pyx_k_udp_pack_hdr, sizeof(__pyx_k_udp_pack_hdr), 0, 0, 1, 1}, + {&__pyx_n_s_uint16, __pyx_k_uint16, sizeof(__pyx_k_uint16), 0, 0, 1, 1}, + {&__pyx_n_s_uint32, __pyx_k_uint32, sizeof(__pyx_k_uint32), 0, 0, 1, 1}, + {&__pyx_n_s_uint8, __pyx_k_uint8, sizeof(__pyx_k_uint8), 0, 0, 1, 1}, + {&__pyx_n_s_ulen, __pyx_k_ulen, sizeof(__pyx_k_ulen), 0, 0, 1, 1}, + {&__pyx_n_s_update, __pyx_k_update, sizeof(__pyx_k_update), 0, 0, 1, 1}, + {&__pyx_n_s_url, __pyx_k_url, sizeof(__pyx_k_url), 0, 0, 1, 1}, + {&__pyx_n_s_urp, __pyx_k_urp, sizeof(__pyx_k_urp), 0, 0, 1, 1}, + {&__pyx_n_s_use_setstate, __pyx_k_use_setstate, sizeof(__pyx_k_use_setstate), 0, 0, 1, 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_win, __pyx_k_win, sizeof(__pyx_k_win), 0, 0, 1, 1}, + {&__pyx_n_s_xrange, __pyx_k_xrange, sizeof(__pyx_k_xrange), 0, 0, 1, 1}, + {0, 0, 0, 0, 0, 0, 0} + }; + return __Pyx_InitStrings(__pyx_string_tab); +} +/* #### Code section: cached_builtins ### */ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(0, 47, __pyx_L1_error) __pyx_builtin_OSError = __Pyx_GetBuiltinName(__pyx_n_s_OSError); if (!__pyx_builtin_OSError) __PYX_ERR(0, 114, __pyx_L1_error) @@ -20769,215 +28971,91 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) { __pyx_L1_error:; return -1; } +/* #### Code section: cached_constants ### */ 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.eth cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.eth cannot be converted to a Python object for pickling") - */ - __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_self_eth_cannot_be_converted_to); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple_); - __Pyx_GIVEREF(__pyx_tuple_); - /* "(tree fragment)":4 - * raise TypeError("self.eth cannot be converted to a Python object for pickling") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.eth cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0x6aff466, 0x6c108d3, 0xd0a7020): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError, "Incompatible checksums (0x%x vs (0x6aff466, 0x6c108d3, 0xd0a7020) = (cur, max))" % __pyx_checksum */ - __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_self_eth_cannot_be_converted_to); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_tuple__2 = PyTuple_Pack(3, __pyx_int_112194662, __pyx_int_113314003, __pyx_int_218787872); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 4, __pyx_L1_error) __Pyx_GOTREF(__pyx_tuple__2); __Pyx_GIVEREF(__pyx_tuple__2); - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("self.ip cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.ip cannot be converted to a Python object for pickling") - */ - __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_self_ip_cannot_be_converted_to_a); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__6); - __Pyx_GIVEREF(__pyx_tuple__6); - - /* "(tree fragment)":4 - * raise TypeError("self.ip cannot be converted to a Python object for pickling") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.ip cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - */ - __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_self_ip_cannot_be_converted_to_a); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__7); - __Pyx_GIVEREF(__pyx_tuple__7); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") - */ - __pyx_tuple__19 = PyTuple_Pack(1, __pyx_kp_s_Pickling_of_struct_members_such); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__19); - __Pyx_GIVEREF(__pyx_tuple__19); - - /* "(tree fragment)":4 - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)") # <<<<<<<<<<<<<< - */ - __pyx_tuple__20 = PyTuple_Pack(1, __pyx_kp_s_Pickling_of_struct_members_such); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__20); - __Pyx_GIVEREF(__pyx_tuple__20); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("self.arp cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.arp cannot be converted to a Python object for pickling") - */ - __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_self_arp_cannot_be_converted_to); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__21); - __Pyx_GIVEREF(__pyx_tuple__21); - - /* "(tree fragment)":4 - * raise TypeError("self.arp cannot be converted to a Python object for pickling") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.arp cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - */ - __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_self_arp_cannot_be_converted_to); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__22); - __Pyx_GIVEREF(__pyx_tuple__22); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("self.intf cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.intf cannot be converted to a Python object for pickling") - */ - __pyx_tuple__31 = PyTuple_Pack(1, __pyx_kp_s_self_intf_cannot_be_converted_to); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__31); - __Pyx_GIVEREF(__pyx_tuple__31); - - /* "(tree fragment)":4 - * raise TypeError("self.intf cannot be converted to a Python object for pickling") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.intf cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - */ - __pyx_tuple__32 = PyTuple_Pack(1, __pyx_kp_s_self_intf_cannot_be_converted_to); if (unlikely(!__pyx_tuple__32)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__32); - __Pyx_GIVEREF(__pyx_tuple__32); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("self.route cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.route cannot be converted to a Python object for pickling") - */ - __pyx_tuple__33 = PyTuple_Pack(1, __pyx_kp_s_self_route_cannot_be_converted_t); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__33); - __Pyx_GIVEREF(__pyx_tuple__33); - - /* "(tree fragment)":4 - * raise TypeError("self.route cannot be converted to a Python object for pickling") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.route cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - */ - __pyx_tuple__34 = PyTuple_Pack(1, __pyx_kp_s_self_route_cannot_be_converted_t); if (unlikely(!__pyx_tuple__34)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__34); - __Pyx_GIVEREF(__pyx_tuple__34); - - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("self.fw cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.fw cannot be converted to a Python object for pickling") - */ - __pyx_tuple__35 = PyTuple_Pack(1, __pyx_kp_s_self_fw_cannot_be_converted_to_a); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__35); - __Pyx_GIVEREF(__pyx_tuple__35); - - /* "(tree fragment)":4 - * raise TypeError("self.fw cannot be converted to a Python object for pickling") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.fw cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + /* "dnet.pyx":54 + * return strerror(errno) + * + * def __iter_append(entry, l): # <<<<<<<<<<<<<< + * l.append(entry) + * */ - __pyx_tuple__36 = PyTuple_Pack(1, __pyx_kp_s_self_fw_cannot_be_converted_to_a); if (unlikely(!__pyx_tuple__36)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__36); - __Pyx_GIVEREF(__pyx_tuple__36); + __pyx_tuple__4 = PyTuple_Pack(2, __pyx_n_s_entry, __pyx_n_s_l); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_codeobj__5 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_iter_append, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 54, __pyx_L1_error) - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + /* "dnet.pyx":116 + * raise OSError, __oserror() + * + * def get(self): # <<<<<<<<<<<<<< + * """Return the MAC address associated with the device as a + * binary string.""" */ - __pyx_tuple__37 = PyTuple_Pack(1, __pyx_kp_s_self_rand_cannot_be_converted_to); if (unlikely(!__pyx_tuple__37)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__37); - __Pyx_GIVEREF(__pyx_tuple__37); + __pyx_tuple__6 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_ea); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + __pyx_codeobj__7 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__6, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_get, 116, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__7)) __PYX_ERR(0, 116, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("self.rand cannot be converted to a Python object for pickling") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< + /* "dnet.pyx":124 + * return PyBytes_FromStringAndSize(ea.data, 6) + * + * def set(self, value): # <<<<<<<<<<<<<< + * """Set the MAC address for the device, returning 0 on success, + * -1 on failure. */ - __pyx_tuple__38 = PyTuple_Pack(1, __pyx_kp_s_self_rand_cannot_be_converted_to); if (unlikely(!__pyx_tuple__38)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__38); - __Pyx_GIVEREF(__pyx_tuple__38); + __pyx_tuple__8 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_value, __pyx_n_s_ea); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_set, 124, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 124, __pyx_L1_error) - /* "(tree fragment)":2 - * def __reduce_cython__(self): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + /* "dnet.pyx":136 + * raise OSError, __oserror() + * + * def send(self, frame): # <<<<<<<<<<<<<< + * """Send an Ethernet frame, returning the number of bytes sent + * or -1 on failure. */ - __pyx_tuple__39 = PyTuple_Pack(1, __pyx_kp_s_self_rand_cannot_be_converted_to); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__39); - __Pyx_GIVEREF(__pyx_tuple__39); + __pyx_tuple__10 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_frame); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + __pyx_codeobj__11 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__10, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_send, 136, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__11)) __PYX_ERR(0, 136, __pyx_L1_error) - /* "(tree fragment)":4 - * raise TypeError("self.rand cannot be converted to a Python object for pickling") + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.rand cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< */ - __pyx_tuple__40 = PyTuple_Pack(1, __pyx_kp_s_self_rand_cannot_be_converted_to); if (unlikely(!__pyx_tuple__40)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__40); - __Pyx_GIVEREF(__pyx_tuple__40); + __pyx_tuple__12 = PyTuple_Pack(1, __pyx_n_s_self); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + __pyx_codeobj__13 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__13)) __PYX_ERR(1, 1, __pyx_L1_error) - /* "(tree fragment)":2 + /* "(tree fragment)":3 * def __reduce_cython__(self): - * raise TypeError("self.tun cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.tun cannot be converted to a Python object for pickling") - */ - __pyx_tuple__41 = PyTuple_Pack(1, __pyx_kp_s_self_tun_cannot_be_converted_to); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(1, 2, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__41); - __Pyx_GIVEREF(__pyx_tuple__41); - - /* "(tree fragment)":4 - * raise TypeError("self.tun cannot be converted to a Python object for pickling") - * def __setstate_cython__(self, __pyx_state): - * raise TypeError("self.tun cannot be converted to a Python object for pickling") # <<<<<<<<<<<<<< - */ - __pyx_tuple__42 = PyTuple_Pack(1, __pyx_kp_s_self_tun_cannot_be_converted_to); if (unlikely(!__pyx_tuple__42)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__42); - __Pyx_GIVEREF(__pyx_tuple__42); - __pyx_tuple__43 = PyTuple_Pack(3, __pyx_int_218787872, __pyx_int_112194662, __pyx_int_113314003); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(1, 4, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__43); - __Pyx_GIVEREF(__pyx_tuple__43); - - /* "dnet.pyx":54 - * return strerror(errno) - * - * def __iter_append(entry, l): # <<<<<<<<<<<<<< - * l.append(entry) - * + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" */ - __pyx_tuple__44 = PyTuple_Pack(2, __pyx_n_s_entry, __pyx_n_s_l); if (unlikely(!__pyx_tuple__44)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__44); - __Pyx_GIVEREF(__pyx_tuple__44); - __pyx_codeobj__45 = (PyObject*)__Pyx_PyCode_New(2, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__44, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_iter_append, 54, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__45)) __PYX_ERR(0, 54, __pyx_L1_error) + __pyx_tuple__14 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pyx_state); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + __pyx_codeobj__15 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__15)) __PYX_ERR(1, 3, __pyx_L1_error) /* "dnet.pyx":149 * eth_close(self.eth) @@ -20986,10 +29064,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Convert an Ethernet MAC address from 6-byte packed binary string to * a printable string ('00:de:ad:be:ef:00').""" */ - __pyx_tuple__46 = PyTuple_Pack(2, __pyx_n_s_buf, __pyx_n_s_ea); if (unlikely(!__pyx_tuple__46)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__46); - __Pyx_GIVEREF(__pyx_tuple__46); - __pyx_codeobj__47 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__46, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_eth_ntoa, 149, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__47)) __PYX_ERR(0, 149, __pyx_L1_error) + __pyx_tuple__16 = PyTuple_Pack(2, __pyx_n_s_buf, __pyx_n_s_ea); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + __pyx_codeobj__17 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_eth_ntoa, 149, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__17)) __PYX_ERR(0, 149, __pyx_L1_error) /* "dnet.pyx":156 * return __eth_ntoa(&ea) @@ -20998,10 +29076,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Convert an Ethernet MAC address from a printable string to a * packed binary string ('\\x00\\xde\\xad\\xbe\\xef\\x00').""" */ - __pyx_tuple__48 = PyTuple_Pack(2, __pyx_n_s_buf, __pyx_n_s_ea); if (unlikely(!__pyx_tuple__48)) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__48); - __Pyx_GIVEREF(__pyx_tuple__48); - __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__48, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_eth_aton, 156, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(0, 156, __pyx_L1_error) + __pyx_codeobj__18 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__16, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_eth_aton, 156, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__18)) __PYX_ERR(0, 156, __pyx_L1_error) /* "dnet.pyx":164 * return PyBytes_FromStringAndSize(ea.data, 6) @@ -21010,10 +29085,37 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * etype=ETH_TYPE_IP): * """Return a packed binary string representing an Ethernet header. */ - __pyx_tuple__50 = PyTuple_Pack(6, __pyx_n_s_dst, __pyx_n_s_src, __pyx_n_s_etype, __pyx_n_s_hdr, __pyx_n_s_s, __pyx_n_s_d); if (unlikely(!__pyx_tuple__50)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__50); - __Pyx_GIVEREF(__pyx_tuple__50); - __pyx_codeobj__51 = (PyObject*)__Pyx_PyCode_New(3, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__50, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_eth_pack_hdr, 164, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__51)) __PYX_ERR(0, 164, __pyx_L1_error) + __pyx_tuple__19 = PyTuple_Pack(6, __pyx_n_s_dst, __pyx_n_s_src, __pyx_n_s_etype, __pyx_n_s_hdr, __pyx_n_s_s, __pyx_n_s_d); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + __pyx_codeobj__20 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 6, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__19, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_eth_pack_hdr, 164, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__20)) __PYX_ERR(0, 164, __pyx_L1_error) + + /* "dnet.pyx":254 + * raise OSError, __oserror() + * + * def send(self, pkt): # <<<<<<<<<<<<<< + * """Send an IP packet, returning the number of bytes sent + * or -1 on failure. + */ + __pyx_tuple__21 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_pkt); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + __pyx_codeobj__22 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_send, 254, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__22)) __PYX_ERR(0, 254, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__23 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__23)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__24 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__24)) __PYX_ERR(1, 3, __pyx_L1_error) /* "dnet.pyx":267 * ip_close(self.ip) @@ -21022,10 +29124,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Convert an IP address from a 4-byte packed binary string or * integer to a printable string ('10.0.0.1').""" */ - __pyx_tuple__52 = PyTuple_Pack(3, __pyx_n_s_buf, __pyx_n_s_ia, __pyx_n_s_i); if (unlikely(!__pyx_tuple__52)) __PYX_ERR(0, 267, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__52); - __Pyx_GIVEREF(__pyx_tuple__52); - __pyx_codeobj__53 = (PyObject*)__Pyx_PyCode_New(1, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__52, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_ntoa, 267, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__53)) __PYX_ERR(0, 267, __pyx_L1_error) + __pyx_tuple__25 = PyTuple_Pack(3, __pyx_n_s_buf, __pyx_n_s_ia, __pyx_n_s_i); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + __pyx_codeobj__26 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__25, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_ntoa, 267, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__26)) __PYX_ERR(0, 267, __pyx_L1_error) /* "dnet.pyx":280 * return __ip_ntoa(&ia) @@ -21034,10 +29136,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Convert an IP address from a printable string to a * packed binary string ('\\x0a\\x00\\x00\\x01').""" */ - __pyx_tuple__54 = PyTuple_Pack(2, __pyx_n_s_buf, __pyx_n_s_ia); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 280, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__54); - __Pyx_GIVEREF(__pyx_tuple__54); - __pyx_codeobj__55 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__54, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_aton, 280, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__55)) __PYX_ERR(0, 280, __pyx_L1_error) + __pyx_tuple__27 = PyTuple_Pack(2, __pyx_n_s_buf, __pyx_n_s_ia); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_aton, 280, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __PYX_ERR(0, 280, __pyx_L1_error) /* "dnet.pyx":288 * return PyBytes_FromStringAndSize(&ia, 4) @@ -21046,10 +29148,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Return packed binary string representing an IP packet * with the IP and transport-layer checksums set. */ - __pyx_tuple__56 = PyTuple_Pack(5, __pyx_n_s_pkt, __pyx_n_s_buf, __pyx_n_s_p, __pyx_n_s_n, __pyx_n_s_s); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__56); - __Pyx_GIVEREF(__pyx_tuple__56); - __pyx_codeobj__57 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__56, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_checksum, 288, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__57)) __PYX_ERR(0, 288, __pyx_L1_error) + __pyx_tuple__29 = PyTuple_Pack(5, __pyx_n_s_pkt, __pyx_n_s_buf, __pyx_n_s_p, __pyx_n_s_n, __pyx_n_s_s); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + __pyx_codeobj__30 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__29, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_checksum, 288, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__30)) __PYX_ERR(0, 288, __pyx_L1_error) /* "dnet.pyx":311 * raise TypeError @@ -21058,10 +29160,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * cdef char *p * cdef int n */ - __pyx_tuple__58 = PyTuple_Pack(4, __pyx_n_s_buf, __pyx_n_s_sum, __pyx_n_s_p, __pyx_n_s_n); if (unlikely(!__pyx_tuple__58)) __PYX_ERR(0, 311, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__58); - __Pyx_GIVEREF(__pyx_tuple__58); - __pyx_codeobj__59 = (PyObject*)__Pyx_PyCode_New(2, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__58, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_cksum_add, 311, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__59)) __PYX_ERR(0, 311, __pyx_L1_error) + __pyx_tuple__31 = PyTuple_Pack(4, __pyx_n_s_buf, __pyx_n_s_sum, __pyx_n_s_p, __pyx_n_s_n); if (unlikely(!__pyx_tuple__31)) __PYX_ERR(0, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__31); + __Pyx_GIVEREF(__pyx_tuple__31); + __pyx_codeobj__32 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__31, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_cksum_add, 311, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__32)) __PYX_ERR(0, 311, __pyx_L1_error) /* "dnet.pyx":319 * raise TypeError @@ -21070,10 +29172,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * return __ip_cksum_carry(sum) * */ - __pyx_tuple__60 = PyTuple_Pack(2, __pyx_n_s_sum, __pyx_n_s_sum); if (unlikely(!__pyx_tuple__60)) __PYX_ERR(0, 319, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__60); - __Pyx_GIVEREF(__pyx_tuple__60); - __pyx_codeobj__61 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__60, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_cksum_carry, 319, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__61)) __PYX_ERR(0, 319, __pyx_L1_error) + __pyx_tuple__33 = PyTuple_Pack(1, __pyx_n_s_sum); if (unlikely(!__pyx_tuple__33)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__33); + __Pyx_GIVEREF(__pyx_tuple__33); + __pyx_codeobj__34 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__33, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_cksum_carry, 319, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__34)) __PYX_ERR(0, 319, __pyx_L1_error) /* "dnet.pyx":322 * return __ip_cksum_carry(sum) @@ -21082,10 +29184,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * ttl=IP_TTL_DEFAULT, p=IP_PROTO_IP, * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): */ - __pyx_tuple__62 = PyTuple_Pack(11, __pyx_n_s_tos, __pyx_n_s_len, __pyx_n_s_id, __pyx_n_s_off, __pyx_n_s_ttl, __pyx_n_s_p, __pyx_n_s_src, __pyx_n_s_dst, __pyx_n_s_hdr, __pyx_n_s_s, __pyx_n_s_d); if (unlikely(!__pyx_tuple__62)) __PYX_ERR(0, 322, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__62); - __Pyx_GIVEREF(__pyx_tuple__62); - __pyx_codeobj__63 = (PyObject*)__Pyx_PyCode_New(8, 0, 11, 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_dnet_pyx, __pyx_n_s_ip_pack_hdr, 322, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__63)) __PYX_ERR(0, 322, __pyx_L1_error) + __pyx_tuple__35 = PyTuple_Pack(11, __pyx_n_s_tos, __pyx_n_s_len, __pyx_n_s_id, __pyx_n_s_off, __pyx_n_s_ttl, __pyx_n_s_p, __pyx_n_s_src, __pyx_n_s_dst, __pyx_n_s_hdr, __pyx_n_s_s, __pyx_n_s_d); if (unlikely(!__pyx_tuple__35)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__35); + __Pyx_GIVEREF(__pyx_tuple__35); + __pyx_codeobj__36 = (PyObject*)__Pyx_PyCode_New(8, 0, 0, 11, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__35, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip_pack_hdr, 322, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__36)) __PYX_ERR(0, 322, __pyx_L1_error) /* "dnet.pyx":372 * IP6_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", 16) @@ -21094,10 +29196,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Convert an IPv6 address from a 16-byte packed binary string to a * printable string ('10.0.0.1').""" */ - __pyx_tuple__64 = PyTuple_Pack(2, __pyx_n_s_buf, __pyx_n_s_ia); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 372, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__64); - __Pyx_GIVEREF(__pyx_tuple__64); - __pyx_codeobj__65 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 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_dnet_pyx, __pyx_n_s_ip6_ntoa, 372, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__65)) __PYX_ERR(0, 372, __pyx_L1_error) + __pyx_codeobj__37 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip6_ntoa, 372, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__37)) __PYX_ERR(0, 372, __pyx_L1_error) /* "dnet.pyx":379 * return __ip6_ntoa(&ia) @@ -21106,10 +29205,7 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Convert an IPv6 address from a printable string to a * packed binary string ('\\x0a\\x00\\x00\\x01').""" */ - __pyx_tuple__66 = PyTuple_Pack(2, __pyx_n_s_buf, __pyx_n_s_ia); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 379, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__66); - __Pyx_GIVEREF(__pyx_tuple__66); - __pyx_codeobj__67 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 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_dnet_pyx, __pyx_n_s_ip6_aton, 379, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__67)) __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_codeobj__38 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip6_aton, 379, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__38)) __PYX_ERR(0, 379, __pyx_L1_error) /* "dnet.pyx":387 * return PyBytes_FromStringAndSize(&ia, 16) @@ -21118,10 +29214,10 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Return a packed binary string representing an IPv6 packet * with the IPv6 and transport-layer checksums set. */ - __pyx_tuple__68 = PyTuple_Pack(1, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__68); - __Pyx_GIVEREF(__pyx_tuple__68); - __pyx_codeobj__69 = (PyObject*)__Pyx_PyCode_New(1, 0, 1, 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_dnet_pyx, __pyx_n_s_ip6_checksum, 387, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__69)) __PYX_ERR(0, 387, __pyx_L1_error) + __pyx_tuple__39 = PyTuple_Pack(1, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__39)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__39); + __Pyx_GIVEREF(__pyx_tuple__39); + __pyx_codeobj__40 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__39, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip6_checksum, 387, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__40)) __PYX_ERR(0, 387, __pyx_L1_error) /* "dnet.pyx":397 * return buf @@ -21130,46 +29226,178 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * src=IP6_ADDR_UNSPEC, dst=IP6_ADDR_UNSPEC): * """Return a packed binary string representing an IPv6 header. */ - __pyx_tuple__70 = PyTuple_Pack(10, __pyx_n_s_fc, __pyx_n_s_fl, __pyx_n_s_plen, __pyx_n_s_nxt, __pyx_n_s_hlim, __pyx_n_s_src, __pyx_n_s_dst, __pyx_n_s_hdr, __pyx_n_s_s, __pyx_n_s_d); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 397, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__70); - __Pyx_GIVEREF(__pyx_tuple__70); - __pyx_codeobj__71 = (PyObject*)__Pyx_PyCode_New(7, 0, 10, 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_dnet_pyx, __pyx_n_s_ip6_pack_hdr, 397, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__71)) __PYX_ERR(0, 397, __pyx_L1_error) + __pyx_tuple__41 = PyTuple_Pack(10, __pyx_n_s_fc, __pyx_n_s_fl, __pyx_n_s_plen, __pyx_n_s_nxt, __pyx_n_s_hlim, __pyx_n_s_src, __pyx_n_s_dst, __pyx_n_s_hdr, __pyx_n_s_s, __pyx_n_s_d); if (unlikely(!__pyx_tuple__41)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__41); + __Pyx_GIVEREF(__pyx_tuple__41); + __pyx_codeobj__42 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 10, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__41, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_ip6_pack_hdr, 397, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__42)) __PYX_ERR(0, 397, __pyx_L1_error) - /* "dnet.pyx":771 - * arp_close(self.arp) + /* "dnet.pyx":531 + * self._addr.addr_bits = IP6_ADDR_BITS * - * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, # <<<<<<<<<<<<<< - * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, - * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): + * def bcast(self): # <<<<<<<<<<<<<< + * """Return an addr object for our broadcast address.""" + * bcast = addr() */ - __pyx_tuple__72 = PyTuple_Pack(10, __pyx_n_s_op, __pyx_n_s_sha, __pyx_n_s_spa, __pyx_n_s_dha, __pyx_n_s_dpa, __pyx_n_s_buf, __pyx_n_s_sh, __pyx_n_s_dh, __pyx_n_s_sp, __pyx_n_s_dp); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 771, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__72); - __Pyx_GIVEREF(__pyx_tuple__72); - __pyx_codeobj__73 = (PyObject*)__Pyx_PyCode_New(5, 0, 10, 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_dnet_pyx, __pyx_n_s_arp_pack_hdr_ethip, 771, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__73)) __PYX_ERR(0, 771, __pyx_L1_error) + __pyx_tuple__43 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_bcast); if (unlikely(!__pyx_tuple__43)) __PYX_ERR(0, 531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__43); + __Pyx_GIVEREF(__pyx_tuple__43); + __pyx_codeobj__44 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__43, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_bcast, 531, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__44)) __PYX_ERR(0, 531, __pyx_L1_error) - /* "dnet.pyx":799 - * void __icmp_pack_hdr "icmp_pack_hdr" (char *hdr, int type, int code) - * - * def icmp_pack_hdr(itype, code): # <<<<<<<<<<<<<< - * """Return a packed binary string representing an ICMP header. + /* "dnet.pyx":537 + * return bcast * + * def net(self): # <<<<<<<<<<<<<< + * """Return an addr object for our network address.""" + * net = addr() */ - __pyx_tuple__74 = PyTuple_Pack(3, __pyx_n_s_itype, __pyx_n_s_code, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 799, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__74); - __Pyx_GIVEREF(__pyx_tuple__74); - __pyx_codeobj__75 = (PyObject*)__Pyx_PyCode_New(2, 0, 3, 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_dnet_pyx, __pyx_n_s_icmp_pack_hdr, 799, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__75)) __PYX_ERR(0, 799, __pyx_L1_error) + __pyx_tuple__45 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_net); if (unlikely(!__pyx_tuple__45)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__45); + __Pyx_GIVEREF(__pyx_tuple__45); + __pyx_codeobj__46 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__45, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_net, 537, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__46)) __PYX_ERR(0, 537, __pyx_L1_error) - /* "dnet.pyx":859 - * TCP_OPT_MAX = 27 + /* "dnet.pyx":555 + * return z * - * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, # <<<<<<<<<<<<<< - * win=TCP_WIN_MAX, urp=0): - * """Return a packed binary string representing a TCP header. + * def __copy__(self): # <<<<<<<<<<<<<< + * a = addr() + * (a)._addr = self._addr */ - __pyx_tuple__76 = PyTuple_Pack(8, __pyx_n_s_sport, __pyx_n_s_dport, __pyx_n_s_seq, __pyx_n_s_ack, __pyx_n_s_flags, __pyx_n_s_win, __pyx_n_s_urp, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 859, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__76); - __Pyx_GIVEREF(__pyx_tuple__76); - __pyx_codeobj__77 = (PyObject*)__Pyx_PyCode_New(7, 0, 8, 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_dnet_pyx, __pyx_n_s_tcp_pack_hdr, 859, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__77)) __PYX_ERR(0, 859, __pyx_L1_error) + __pyx_tuple__47 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_a); if (unlikely(!__pyx_tuple__47)) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__47); + __Pyx_GIVEREF(__pyx_tuple__47); + __pyx_codeobj__48 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__47, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_copy, 555, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__48)) __PYX_ERR(0, 555, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__49 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__49)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" + */ + __pyx_codeobj__50 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__50)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + __pyx_tuple__51 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_state, __pyx_n_s_dict_2, __pyx_n_s_use_setstate); if (unlikely(!__pyx_tuple__51)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__51); + __Pyx_GIVEREF(__pyx_tuple__51); + __pyx_codeobj__52 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__51, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__52)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle___addr_ip4_iter__set_state(self, __pyx_state) + */ + __pyx_codeobj__53 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 16, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__53)) __PYX_ERR(1, 16, __pyx_L1_error) + + /* "dnet.pyx":712 + * raise OSError, __oserror() + * + * def add(self, addr pa, addr ha): # <<<<<<<<<<<<<< + * """Add an entry to the system ARP table. + * + */ + __pyx_tuple__54 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_pa, __pyx_n_s_ha, __pyx_n_s_entry); if (unlikely(!__pyx_tuple__54)) __PYX_ERR(0, 712, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__54); + __Pyx_GIVEREF(__pyx_tuple__54); + __pyx_codeobj__55 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__54, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_add, 712, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__55)) __PYX_ERR(0, 712, __pyx_L1_error) + + /* "dnet.pyx":725 + * raise OSError, __oserror() + * + * def delete(self, addr pa): # <<<<<<<<<<<<<< + * """Delete an entry from the system ARP table. + * + */ + __pyx_tuple__56 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_pa, __pyx_n_s_entry); if (unlikely(!__pyx_tuple__56)) __PYX_ERR(0, 725, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__56); + __Pyx_GIVEREF(__pyx_tuple__56); + __pyx_codeobj__57 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__56, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_delete, 725, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__57)) __PYX_ERR(0, 725, __pyx_L1_error) + + /* "dnet.pyx":736 + * raise OSError, __oserror() + * + * def get(self, addr pa): # <<<<<<<<<<<<<< + * """Return the hardware address for a given protocol address + * in the system ARP table. + */ + __pyx_codeobj__58 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__56, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_get, 736, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__58)) __PYX_ERR(0, 736, __pyx_L1_error) + + /* "dnet.pyx":749 + * return None + * + * def loop(self, callback, arg=None): # <<<<<<<<<<<<<< + * """Iterate over the system ARP table, invoking a user callback + * with each entry, returning the status of the callback routine. + */ + __pyx_tuple__59 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_callback, __pyx_n_s_arg, __pyx_n_s_arg_2); if (unlikely(!__pyx_tuple__59)) __PYX_ERR(0, 749, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__59); + __Pyx_GIVEREF(__pyx_tuple__59); + __pyx_codeobj__60 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_loop, 749, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__60)) __PYX_ERR(0, 749, __pyx_L1_error) + __pyx_tuple__61 = PyTuple_Pack(1, Py_None); if (unlikely(!__pyx_tuple__61)) __PYX_ERR(0, 749, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__61); + __Pyx_GIVEREF(__pyx_tuple__61); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__62 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__62)) __PYX_ERR(1, 1, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__63 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__63)) __PYX_ERR(1, 3, __pyx_L1_error) + + /* "dnet.pyx":771 + * arp_close(self.arp) + * + * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, # <<<<<<<<<<<<<< + * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, + * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): + */ + __pyx_tuple__64 = PyTuple_Pack(10, __pyx_n_s_op, __pyx_n_s_sha, __pyx_n_s_spa, __pyx_n_s_dha, __pyx_n_s_dpa, __pyx_n_s_buf, __pyx_n_s_sh, __pyx_n_s_dh, __pyx_n_s_sp, __pyx_n_s_dp); if (unlikely(!__pyx_tuple__64)) __PYX_ERR(0, 771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__64); + __Pyx_GIVEREF(__pyx_tuple__64); + __pyx_codeobj__65 = (PyObject*)__Pyx_PyCode_New(5, 0, 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_dnet_pyx, __pyx_n_s_arp_pack_hdr_ethip, 771, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__65)) __PYX_ERR(0, 771, __pyx_L1_error) + + /* "dnet.pyx":799 + * void __icmp_pack_hdr "icmp_pack_hdr" (char *hdr, int type, int code) + * + * def icmp_pack_hdr(itype, code): # <<<<<<<<<<<<<< + * """Return a packed binary string representing an ICMP header. + * + */ + __pyx_tuple__66 = PyTuple_Pack(3, __pyx_n_s_itype, __pyx_n_s_code, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__66)) __PYX_ERR(0, 799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__66); + __Pyx_GIVEREF(__pyx_tuple__66); + __pyx_codeobj__67 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 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_dnet_pyx, __pyx_n_s_icmp_pack_hdr, 799, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__67)) __PYX_ERR(0, 799, __pyx_L1_error) + + /* "dnet.pyx":859 + * TCP_OPT_MAX = 27 + * + * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, # <<<<<<<<<<<<<< + * win=TCP_WIN_MAX, urp=0): + * """Return a packed binary string representing a TCP header. + */ + __pyx_tuple__68 = PyTuple_Pack(8, __pyx_n_s_sport, __pyx_n_s_dport, __pyx_n_s_seq, __pyx_n_s_ack, __pyx_n_s_flags, __pyx_n_s_win, __pyx_n_s_urp, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__68)) __PYX_ERR(0, 859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__68); + __Pyx_GIVEREF(__pyx_tuple__68); + __pyx_codeobj__69 = (PyObject*)__Pyx_PyCode_New(7, 0, 0, 8, 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_dnet_pyx, __pyx_n_s_tcp_pack_hdr, 859, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__69)) __PYX_ERR(0, 859, __pyx_L1_error) /* "dnet.pyx":885 * UDP_PORT_MAX = 65535 @@ -21178,3932 +29406,7056 @@ static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { * """Return a packed binary string representing a UDP header. * */ - __pyx_tuple__78 = PyTuple_Pack(4, __pyx_n_s_sport, __pyx_n_s_dport, __pyx_n_s_ulen, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 885, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__78); - __Pyx_GIVEREF(__pyx_tuple__78); - __pyx_codeobj__79 = (PyObject*)__Pyx_PyCode_New(3, 0, 4, 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_dnet_pyx, __pyx_n_s_udp_pack_hdr, 885, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__79)) __PYX_ERR(0, 885, __pyx_L1_error) + __pyx_tuple__70 = PyTuple_Pack(4, __pyx_n_s_sport, __pyx_n_s_dport, __pyx_n_s_ulen, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__70)) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__70); + __Pyx_GIVEREF(__pyx_tuple__70); + __pyx_codeobj__71 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 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_dnet_pyx, __pyx_n_s_udp_pack_hdr, 885, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__71)) __PYX_ERR(0, 885, __pyx_L1_error) - /* "(tree fragment)":1 - * def __pyx_unpickle___addr_ip4_iter(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result + /* "dnet.pyx":992 + * raise OSError, __oserror() + * + * def get(self, name): # <<<<<<<<<<<<<< + * """Return the configuration for a network interface as a dict. + * """ */ - __pyx_tuple__80 = 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__80)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_GOTREF(__pyx_tuple__80); - __Pyx_GIVEREF(__pyx_tuple__80); - __pyx_codeobj__81 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 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_stringsource, __pyx_n_s_pyx_unpickle___addr_ip4_iter, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__81)) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} + __pyx_tuple__72 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_name, __pyx_n_s_ifent, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__72)) __PYX_ERR(0, 992, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__72); + __Pyx_GIVEREF(__pyx_tuple__72); + __pyx_codeobj__73 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 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_dnet_pyx, __pyx_n_s_get, 992, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__73)) __PYX_ERR(0, 992, __pyx_L1_error) -static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { - if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_7 = PyInt_FromLong(7); if (unlikely(!__pyx_int_7)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_8 = PyInt_FromLong(8); if (unlikely(!__pyx_int_8)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_9 = PyInt_FromLong(9); if (unlikely(!__pyx_int_9)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_11 = PyInt_FromLong(11); if (unlikely(!__pyx_int_11)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_12 = PyInt_FromLong(12); if (unlikely(!__pyx_int_12)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_13 = PyInt_FromLong(13); if (unlikely(!__pyx_int_13)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_14 = PyInt_FromLong(14); if (unlikely(!__pyx_int_14)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_15 = PyInt_FromLong(15); if (unlikely(!__pyx_int_15)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_16 = PyInt_FromLong(16); if (unlikely(!__pyx_int_16)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_17 = PyInt_FromLong(17); if (unlikely(!__pyx_int_17)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_18 = PyInt_FromLong(18); if (unlikely(!__pyx_int_18)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_19 = PyInt_FromLong(19); if (unlikely(!__pyx_int_19)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_20 = PyInt_FromLong(20); if (unlikely(!__pyx_int_20)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_21 = PyInt_FromLong(21); if (unlikely(!__pyx_int_21)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_22 = PyInt_FromLong(22); if (unlikely(!__pyx_int_22)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_23 = PyInt_FromLong(23); if (unlikely(!__pyx_int_23)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_24 = PyInt_FromLong(24); if (unlikely(!__pyx_int_24)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_26 = PyInt_FromLong(26); if (unlikely(!__pyx_int_26)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_27 = PyInt_FromLong(27); if (unlikely(!__pyx_int_27)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_32 = PyInt_FromLong(32); if (unlikely(!__pyx_int_32)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_40 = PyInt_FromLong(40); if (unlikely(!__pyx_int_40)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_41 = PyInt_FromLong(41); if (unlikely(!__pyx_int_41)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_47 = PyInt_FromLong(47); if (unlikely(!__pyx_int_47)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_48 = PyInt_FromLong(48); if (unlikely(!__pyx_int_48)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_50 = PyInt_FromLong(50); if (unlikely(!__pyx_int_50)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_51 = PyInt_FromLong(51); if (unlikely(!__pyx_int_51)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_53 = PyInt_FromLong(53); if (unlikely(!__pyx_int_53)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_58 = PyInt_FromLong(58); if (unlikely(!__pyx_int_58)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_64 = PyInt_FromLong(64); if (unlikely(!__pyx_int_64)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_128 = PyInt_FromLong(128); if (unlikely(!__pyx_int_128)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_255 = PyInt_FromLong(255); if (unlikely(!__pyx_int_255)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_512 = PyInt_FromLong(512); if (unlikely(!__pyx_int_512)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1024 = PyInt_FromLong(1024); if (unlikely(!__pyx_int_1024)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1280 = PyInt_FromLong(1280); if (unlikely(!__pyx_int_1280)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1500 = PyInt_FromLong(1500); if (unlikely(!__pyx_int_1500)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_1518 = PyInt_FromLong(1518); if (unlikely(!__pyx_int_1518)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2048 = PyInt_FromLong(2048); if (unlikely(!__pyx_int_2048)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_2054 = PyInt_FromLong(2054); if (unlikely(!__pyx_int_2054)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_8191 = PyInt_FromLong(8191); if (unlikely(!__pyx_int_8191)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_8192 = PyInt_FromLong(8192); if (unlikely(!__pyx_int_8192)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_16384 = PyInt_FromLong(16384L); if (unlikely(!__pyx_int_16384)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_32768 = PyInt_FromLong(32768L); if (unlikely(!__pyx_int_32768)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_32821 = PyInt_FromLong(32821L); if (unlikely(!__pyx_int_32821)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_33024 = PyInt_FromLong(33024L); if (unlikely(!__pyx_int_33024)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_34525 = PyInt_FromLong(34525L); if (unlikely(!__pyx_int_34525)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_34887 = PyInt_FromLong(34887L); if (unlikely(!__pyx_int_34887)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_34888 = PyInt_FromLong(34888L); if (unlikely(!__pyx_int_34888)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_34915 = PyInt_FromLong(34915L); if (unlikely(!__pyx_int_34915)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_34916 = PyInt_FromLong(34916L); if (unlikely(!__pyx_int_34916)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_36864 = PyInt_FromLong(36864L); if (unlikely(!__pyx_int_36864)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_65535 = PyInt_FromLong(65535L); if (unlikely(!__pyx_int_65535)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_112194662 = PyInt_FromLong(112194662L); if (unlikely(!__pyx_int_112194662)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_113314003 = PyInt_FromLong(113314003L); if (unlikely(!__pyx_int_113314003)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_int_218787872 = PyInt_FromLong(218787872L); if (unlikely(!__pyx_int_218787872)) __PYX_ERR(0, 1, __pyx_L1_error) - return 0; - __pyx_L1_error:; - return -1; -} + /* "dnet.pyx":1004 + * return ifent_to_dict(ifent) + * + * def get_src(self, addr src): # <<<<<<<<<<<<<< + * """Return the configuration for the interface whose primary address + * matches the specified source address. + */ + __pyx_tuple__74 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_src, __pyx_n_s_ifent, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__74)) __PYX_ERR(0, 1004, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__74); + __Pyx_GIVEREF(__pyx_tuple__74); + __pyx_codeobj__75 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 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_dnet_pyx, __pyx_n_s_get_src, 1004, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__75)) __PYX_ERR(0, 1004, __pyx_L1_error) -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*/ + /* "dnet.pyx":1016 + * return ifent_to_dict(ifent) + * + * def get_dst(self, addr dst): # <<<<<<<<<<<<<< + * """Return the configuration for the best interface with which to + * reach the specified dst address. + */ + __pyx_tuple__76 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_dst, __pyx_n_s_ifent, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__76)) __PYX_ERR(0, 1016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__76); + __Pyx_GIVEREF(__pyx_tuple__76); + __pyx_codeobj__77 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 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_dnet_pyx, __pyx_n_s_get_dst, 1016, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__77)) __PYX_ERR(0, 1016, __pyx_L1_error) -static int __Pyx_modinit_global_init_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); - /*--- Global init code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "dnet.pyx":1028 + * return ifent_to_dict(ifent) + * + * def set(self, d): # <<<<<<<<<<<<<< + * """Set the configuration for an interface from a dict. + * + */ + __pyx_tuple__78 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_d, __pyx_n_s_ifent, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__78)) __PYX_ERR(0, 1028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__78); + __Pyx_GIVEREF(__pyx_tuple__78); + __pyx_codeobj__79 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 4, 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_dnet_pyx, __pyx_n_s_set, 1028, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__79)) __PYX_ERR(0, 1028, __pyx_L1_error) -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; -} + /* "dnet.pyx":1049 + * raise OSError, __oserror() + * + * def loop(self, callback, arg=None): # <<<<<<<<<<<<<< + * """Iterate over the system interface table, invoking a user callback + * with each entry, returning the status of the callback routine. + */ + __pyx_codeobj__80 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_loop, 1049, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__80)) __PYX_ERR(0, 1049, __pyx_L1_error) -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; -} + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__81 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__81)) __PYX_ERR(1, 1, __pyx_L1_error) -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_4dnet_eth) < 0) __PYX_ERR(0, 104, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_eth.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_eth.tp_dictoffset && __pyx_type_4dnet_eth.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_eth.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_eth, (PyObject *)&__pyx_type_4dnet_eth) < 0) __PYX_ERR(0, 104, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_eth) < 0) __PYX_ERR(0, 104, __pyx_L1_error) - __pyx_ptype_4dnet_eth = &__pyx_type_4dnet_eth; - if (PyType_Ready(&__pyx_type_4dnet_ip) < 0) __PYX_ERR(0, 242, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_ip.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_ip.tp_dictoffset && __pyx_type_4dnet_ip.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_ip.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ip, (PyObject *)&__pyx_type_4dnet_ip) < 0) __PYX_ERR(0, 242, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_ip) < 0) __PYX_ERR(0, 242, __pyx_L1_error) - __pyx_ptype_4dnet_ip = &__pyx_type_4dnet_ip; - if (PyType_Ready(&__pyx_type_4dnet_addr) < 0) __PYX_ERR(0, 438, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_addr.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_addr.tp_dictoffset && __pyx_type_4dnet_addr.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_addr.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_addr, (PyObject *)&__pyx_type_4dnet_addr) < 0) __PYX_ERR(0, 438, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_addr) < 0) __PYX_ERR(0, 438, __pyx_L1_error) - __pyx_ptype_4dnet_addr = &__pyx_type_4dnet_addr; - if (PyType_Ready(&__pyx_type_4dnet___addr_ip4_iter) < 0) __PYX_ERR(0, 635, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet___addr_ip4_iter.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet___addr_ip4_iter.tp_dictoffset && __pyx_type_4dnet___addr_ip4_iter.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet___addr_ip4_iter.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_addr_ip4_iter, (PyObject *)&__pyx_type_4dnet___addr_ip4_iter) < 0) __PYX_ERR(0, 635, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet___addr_ip4_iter) < 0) __PYX_ERR(0, 635, __pyx_L1_error) - __pyx_ptype_4dnet___addr_ip4_iter = &__pyx_type_4dnet___addr_ip4_iter; - if (PyType_Ready(&__pyx_type_4dnet_arp) < 0) __PYX_ERR(0, 700, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_arp.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_arp.tp_dictoffset && __pyx_type_4dnet_arp.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_arp.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_arp, (PyObject *)&__pyx_type_4dnet_arp) < 0) __PYX_ERR(0, 700, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_arp) < 0) __PYX_ERR(0, 700, __pyx_L1_error) - __pyx_ptype_4dnet_arp = &__pyx_type_4dnet_arp; - if (PyType_Ready(&__pyx_type_4dnet_intf) < 0) __PYX_ERR(0, 980, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_intf.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_intf.tp_dictoffset && __pyx_type_4dnet_intf.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_intf.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_intf, (PyObject *)&__pyx_type_4dnet_intf) < 0) __PYX_ERR(0, 980, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_intf) < 0) __PYX_ERR(0, 980, __pyx_L1_error) - __pyx_ptype_4dnet_intf = &__pyx_type_4dnet_intf; - if (PyType_Ready(&__pyx_type_4dnet_route) < 0) __PYX_ERR(0, 1099, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_route.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_route.tp_dictoffset && __pyx_type_4dnet_route.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_route.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_route, (PyObject *)&__pyx_type_4dnet_route) < 0) __PYX_ERR(0, 1099, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_route) < 0) __PYX_ERR(0, 1099, __pyx_L1_error) - __pyx_ptype_4dnet_route = &__pyx_type_4dnet_route; - if (PyType_Ready(&__pyx_type_4dnet_fw) < 0) __PYX_ERR(0, 1245, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_fw.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_fw.tp_dictoffset && __pyx_type_4dnet_fw.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_fw.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_fw, (PyObject *)&__pyx_type_4dnet_fw) < 0) __PYX_ERR(0, 1245, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_fw) < 0) __PYX_ERR(0, 1245, __pyx_L1_error) - __pyx_ptype_4dnet_fw = &__pyx_type_4dnet_fw; - if (PyType_Ready(&__pyx_type_4dnet_rand) < 0) __PYX_ERR(0, 1322, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_rand.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_rand.tp_dictoffset && __pyx_type_4dnet_rand.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_rand.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_rand, (PyObject *)&__pyx_type_4dnet_rand) < 0) __PYX_ERR(0, 1322, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_rand) < 0) __PYX_ERR(0, 1322, __pyx_L1_error) - __pyx_ptype_4dnet_rand = &__pyx_type_4dnet_rand; - if (PyType_Ready(&__pyx_type_4dnet___rand_xrange) < 0) __PYX_ERR(0, 1404, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet___rand_xrange.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet___rand_xrange.tp_dictoffset && __pyx_type_4dnet___rand_xrange.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet___rand_xrange.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_rand_xrange, (PyObject *)&__pyx_type_4dnet___rand_xrange) < 0) __PYX_ERR(0, 1404, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet___rand_xrange) < 0) __PYX_ERR(0, 1404, __pyx_L1_error) - __pyx_ptype_4dnet___rand_xrange = &__pyx_type_4dnet___rand_xrange; - if (PyType_Ready(&__pyx_type_4dnet_tun) < 0) __PYX_ERR(0, 1488, __pyx_L1_error) - #if PY_VERSION_HEX < 0x030800B1 - __pyx_type_4dnet_tun.tp_print = 0; - #endif - if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type_4dnet_tun.tp_dictoffset && __pyx_type_4dnet_tun.tp_getattro == PyObject_GenericGetAttr)) { - __pyx_type_4dnet_tun.tp_getattro = __Pyx_PyObject_GenericGetAttr; - } - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_tun, (PyObject *)&__pyx_type_4dnet_tun) < 0) __PYX_ERR(0, 1488, __pyx_L1_error) - if (__Pyx_setup_reduce((PyObject*)&__pyx_type_4dnet_tun) < 0) __PYX_ERR(0, 1488, __pyx_L1_error) - __pyx_ptype_4dnet_tun = &__pyx_type_4dnet_tun; - __Pyx_RefNannyFinishContext(); - return 0; - __pyx_L1_error:; - __Pyx_RefNannyFinishContext(); - return -1; -} + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__82 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__82)) __PYX_ERR(1, 3, __pyx_L1_error) -static int __Pyx_modinit_type_import_code(void) { - __Pyx_RefNannyDeclarations - __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); - /*--- Type import code ---*/ - __Pyx_RefNannyFinishContext(); - return 0; -} + /* "dnet.pyx":1111 + * raise OSError, __oserror() + * + * def add(self, addr dst, addr gw): # <<<<<<<<<<<<<< + * """Add an entry to the system routing table. + * + */ + __pyx_tuple__83 = PyTuple_Pack(4, __pyx_n_s_self, __pyx_n_s_dst, __pyx_n_s_gw, __pyx_n_s_entry); if (unlikely(!__pyx_tuple__83)) __PYX_ERR(0, 1111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__83); + __Pyx_GIVEREF(__pyx_tuple__83); + __pyx_codeobj__84 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 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_dnet_pyx, __pyx_n_s_add, 1111, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__84)) __PYX_ERR(0, 1111, __pyx_L1_error) -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; -} + /* "dnet.pyx":1124 + * raise OSError, __oserror() + * + * def delete(self, addr dst): # <<<<<<<<<<<<<< + * """Delete an entry from the system routing table. + * + */ + __pyx_tuple__85 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_dst, __pyx_n_s_entry); if (unlikely(!__pyx_tuple__85)) __PYX_ERR(0, 1124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__85); + __Pyx_GIVEREF(__pyx_tuple__85); + __pyx_codeobj__86 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 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_dnet_pyx, __pyx_n_s_delete, 1124, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__86)) __PYX_ERR(0, 1124, __pyx_L1_error) -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; -} + /* "dnet.pyx":1135 + * raise OSError, __oserror() + * + * def get(self, addr dst): # <<<<<<<<<<<<<< + * """Return the hardware address for a given protocol address + * in the system routing table. + */ + __pyx_codeobj__87 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 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_dnet_pyx, __pyx_n_s_get, 1135, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__87)) __PYX_ERR(0, 1135, __pyx_L1_error) + /* "dnet.pyx":1148 + * return None + * + * def loop(self, callback, arg=None): # <<<<<<<<<<<<<< + * """Iterate over the system routing table, invoking a user callback + * with each entry, returning the status of the callback routine. + */ + __pyx_codeobj__88 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_loop, 1148, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__88)) __PYX_ERR(0, 1148, __pyx_L1_error) -#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 + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.route cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_codeobj__89 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__89)) __PYX_ERR(1, 1, __pyx_L1_error) + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.route cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.route cannot be converted to a Python object for pickling" + */ + __pyx_codeobj__90 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__90)) __PYX_ERR(1, 3, __pyx_L1_error) -#if PY_MAJOR_VERSION < 3 -__Pyx_PyMODINIT_FUNC initdnet(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC initdnet(void) -#else -__Pyx_PyMODINIT_FUNC PyInit_dnet(void) CYTHON_SMALL_CODE; /*proto*/ -__Pyx_PyMODINIT_FUNC PyInit_dnet(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; -} + /* "dnet.pyx":1257 + * raise OSError, __oserror() + * + * def add(self, d): # <<<<<<<<<<<<<< + * """Add a firewall rule specified as a dict. + * + */ + __pyx_tuple__91 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_d, __pyx_n_s_rule); if (unlikely(!__pyx_tuple__91)) __PYX_ERR(0, 1257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__91); + __Pyx_GIVEREF(__pyx_tuple__91); + __pyx_codeobj__92 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 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_dnet_pyx, __pyx_n_s_add, 1257, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__92)) __PYX_ERR(0, 1257, __pyx_L1_error) + /* "dnet.pyx":1276 + * raise OSError, __oserror() + * + * def delete(self, d): # <<<<<<<<<<<<<< + * """Delete a firewall rule specified as a dict.""" + * cdef fw_rule rule + */ + __pyx_codeobj__93 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 3, 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_dnet_pyx, __pyx_n_s_delete, 1276, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__93)) __PYX_ERR(0, 1276, __pyx_L1_error) -static CYTHON_SMALL_CODE int __pyx_pymod_exec_dnet(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 'dnet' 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_dnet(void)", 0); - if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 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(0, 1, __pyx_L1_error) - __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) - __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) - #ifdef __Pyx_CyFunction_USED - if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_FusedFunction_USED - if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Coroutine_USED - if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_Generator_USED - if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_AsyncGen_USED - if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - #ifdef __Pyx_StopAsyncIteration_USED - if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - /*--- Library function declarations ---*/ - /*--- Threads initialization code ---*/ - #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS - PyEval_InitThreads(); - #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("dnet", __pyx_methods, __pyx_k_dumb_networking_library_This_mod, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); - #else - __pyx_m = PyModule_Create(&__pyx_moduledef); - #endif - if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) - #endif - __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_d); - __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_b); - __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) - Py_INCREF(__pyx_cython_runtime); - if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error); - /*--- Initialize various global constants etc. ---*/ - if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 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(0, 1, __pyx_L1_error) - #endif - if (__pyx_module_is_main_dnet) { - if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - } - #if PY_MAJOR_VERSION >= 3 - { - PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) - if (!PyDict_GetItemString(modules, "dnet")) { - if (unlikely(PyDict_SetItemString(modules, "dnet", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error) - } - } - #endif - /*--- Builtin init code ---*/ - if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) - /*--- Constants init code ---*/ - if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 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(0, 1, __pyx_L1_error) - (void)__Pyx_modinit_type_import_code(); - (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(0, 1, __pyx_L1_error) - #endif - - /* "dnet.pyx":15 - * """ + /* "dnet.pyx":1284 + * raise OSError, __oserror() * - * __author__ = 'Oliver Falk ' # <<<<<<<<<<<<<< - * __copyright__ = 'Copyright (c) 2023 Oliver Falk' - * __license__ = 'BSD' + * def loop(self, callback, arg=None): # <<<<<<<<<<<<<< + * """Iterate over the local firewall ruleset, invoking a user callback + * with each entry, returning the status of the callback routine. */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_author, __pyx_kp_u_Oliver_Falk_oliver_linux_kernel) < 0) __PYX_ERR(0, 15, __pyx_L1_error) + __pyx_codeobj__94 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 4, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__59, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_loop, 1284, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__94)) __PYX_ERR(0, 1284, __pyx_L1_error) - /* "dnet.pyx":16 - * - * __author__ = 'Oliver Falk ' - * __copyright__ = 'Copyright (c) 2023 Oliver Falk' # <<<<<<<<<<<<<< - * __license__ = 'BSD' - * __url__ = 'https://github.com/ofalk/libdnet' + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_copyright, __pyx_kp_u_Copyright_c_2023_Oliver_Falk) < 0) __PYX_ERR(0, 16, __pyx_L1_error) + __pyx_codeobj__95 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__95)) __PYX_ERR(1, 1, __pyx_L1_error) - /* "dnet.pyx":17 - * __author__ = 'Oliver Falk ' - * __copyright__ = 'Copyright (c) 2023 Oliver Falk' - * __license__ = 'BSD' # <<<<<<<<<<<<<< - * __url__ = 'https://github.com/ofalk/libdnet' - * __version__ = '1.16.2' + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_license, __pyx_n_u_BSD) < 0) __PYX_ERR(0, 17, __pyx_L1_error) + __pyx_codeobj__96 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__96)) __PYX_ERR(1, 3, __pyx_L1_error) - /* "dnet.pyx":18 - * __copyright__ = 'Copyright (c) 2023 Oliver Falk' - * __license__ = 'BSD' - * __url__ = 'https://github.com/ofalk/libdnet' # <<<<<<<<<<<<<< - * __version__ = '1.16.2' + /* "dnet.pyx":1337 + * raise OSError, __oserror() + * + * def get(self, len): # <<<<<<<<<<<<<< + * """Return a string of random bytes. * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_url, __pyx_kp_u_https_github_com_ofalk_libdnet) < 0) __PYX_ERR(0, 18, __pyx_L1_error) + __pyx_tuple__97 = PyTuple_Pack(5, __pyx_n_s_self, __pyx_n_s_len, __pyx_n_s_buf, __pyx_n_s_p, __pyx_n_s_s); if (unlikely(!__pyx_tuple__97)) __PYX_ERR(0, 1337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__97); + __Pyx_GIVEREF(__pyx_tuple__97); + __pyx_codeobj__98 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__97, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_get, 1337, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__98)) __PYX_ERR(0, 1337, __pyx_L1_error) - /* "dnet.pyx":19 - * __license__ = 'BSD' - * __url__ = 'https://github.com/ofalk/libdnet' - * __version__ = '1.16.2' # <<<<<<<<<<<<<< + /* "dnet.pyx":1354 + * return s * + * def set(self, buf): # <<<<<<<<<<<<<< + * """Initialize the PRNG from a known seed. * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_kp_u_1_16_2) < 0) __PYX_ERR(0, 19, __pyx_L1_error) + __pyx_tuple__99 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_buf); if (unlikely(!__pyx_tuple__99)) __PYX_ERR(0, 1354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__99); + __Pyx_GIVEREF(__pyx_tuple__99); + __pyx_codeobj__100 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__99, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_set, 1354, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__100)) __PYX_ERR(0, 1354, __pyx_L1_error) - /* "dnet.pyx":54 - * return strerror(errno) + /* "dnet.pyx":1362 + * rand_set(self.rand, buf, PyBytes_Size(buf)) * - * def __iter_append(entry, l): # <<<<<<<<<<<<<< - * l.append(entry) + * def add(self, buf): # <<<<<<<<<<<<<< + * """Add additional entropy into the PRNG mix. * */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4dnet_1__iter_append, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_iter_append, __pyx_t_1) < 0) __PYX_ERR(0, 54, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_codeobj__101 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__99, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_add, 1362, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__101)) __PYX_ERR(0, 1362, __pyx_L1_error) - /* "dnet.pyx":77 - * eth_addr_t dst, eth_addr_t src, int etype) + /* "dnet.pyx":1370 + * rand_add(self.rand, buf, PyBytes_Size(buf)) * - * ETH_ADDR_LEN = 6 # <<<<<<<<<<<<<< - * ETH_ADDR_BITS = 48 - * ETH_TYPE_LEN = 2 + * def uint8(self): # <<<<<<<<<<<<<< + * """Return a random 8-bit integer.""" + * return rand_uint8(self.rand) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_ADDR_LEN, __pyx_int_6) < 0) __PYX_ERR(0, 77, __pyx_L1_error) + __pyx_codeobj__102 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_uint8, 1370, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__102)) __PYX_ERR(0, 1370, __pyx_L1_error) - /* "dnet.pyx":78 + /* "dnet.pyx":1374 + * return rand_uint8(self.rand) * - * ETH_ADDR_LEN = 6 - * ETH_ADDR_BITS = 48 # <<<<<<<<<<<<<< - * ETH_TYPE_LEN = 2 - * ETH_CRC_LEN = 4 + * def uint16(self): # <<<<<<<<<<<<<< + * """Return a random 16-bit integer.""" + * return rand_uint16(self.rand) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_ADDR_BITS, __pyx_int_48) < 0) __PYX_ERR(0, 78, __pyx_L1_error) + __pyx_codeobj__103 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_uint16, 1374, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__103)) __PYX_ERR(0, 1374, __pyx_L1_error) - /* "dnet.pyx":79 - * ETH_ADDR_LEN = 6 - * ETH_ADDR_BITS = 48 - * ETH_TYPE_LEN = 2 # <<<<<<<<<<<<<< - * ETH_CRC_LEN = 4 - * ETH_HDR_LEN = 14 + /* "dnet.pyx":1378 + * return rand_uint16(self.rand) + * + * def uint32(self): # <<<<<<<<<<<<<< + * """Return a random 32-bit integer.""" + * return rand_uint32(self.rand) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_LEN, __pyx_int_2) < 0) __PYX_ERR(0, 79, __pyx_L1_error) + __pyx_codeobj__104 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_uint32, 1378, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__104)) __PYX_ERR(0, 1378, __pyx_L1_error) - /* "dnet.pyx":80 - * ETH_ADDR_BITS = 48 - * ETH_TYPE_LEN = 2 - * ETH_CRC_LEN = 4 # <<<<<<<<<<<<<< - * ETH_HDR_LEN = 14 + /* "dnet.pyx":1382 + * return rand_uint32(self.rand) + * + * def xrange(self, start, stop=None): # <<<<<<<<<<<<<< + * """xrange([start,] stop) -> xrange object * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_CRC_LEN, __pyx_int_4) < 0) __PYX_ERR(0, 80, __pyx_L1_error) + __pyx_tuple__105 = PyTuple_Pack(3, __pyx_n_s_self, __pyx_n_s_start, __pyx_n_s_stop); if (unlikely(!__pyx_tuple__105)) __PYX_ERR(0, 1382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__105); + __Pyx_GIVEREF(__pyx_tuple__105); + __pyx_codeobj__106 = (PyObject*)__Pyx_PyCode_New(3, 0, 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_dnet_pyx, __pyx_n_s_xrange, 1382, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__106)) __PYX_ERR(0, 1382, __pyx_L1_error) - /* "dnet.pyx":81 - * ETH_TYPE_LEN = 2 - * ETH_CRC_LEN = 4 - * ETH_HDR_LEN = 14 # <<<<<<<<<<<<<< - * - * ETH_LEN_MIN = 64 # /[inserted by cython to avoid comment start]* minimum frame length with CRC *[inserted by cython to avoid comment closer]/ + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_HDR_LEN, __pyx_int_14) < 0) __PYX_ERR(0, 81, __pyx_L1_error) + __pyx_codeobj__107 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__107)) __PYX_ERR(1, 1, __pyx_L1_error) - /* "dnet.pyx":83 - * ETH_HDR_LEN = 14 - * - * ETH_LEN_MIN = 64 # /[inserted by cython to avoid comment start]* minimum frame length with CRC *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_LEN_MAX = 1518 # /[inserted by cython to avoid comment start]* maximum frame length with CRC *[inserted by cython to avoid comment closer]/ - * + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_LEN_MIN, __pyx_int_64) < 0) __PYX_ERR(0, 83, __pyx_L1_error) + __pyx_codeobj__108 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__108)) __PYX_ERR(1, 3, __pyx_L1_error) - /* "dnet.pyx":84 - * - * ETH_LEN_MIN = 64 # /[inserted by cython to avoid comment start]* minimum frame length with CRC *[inserted by cython to avoid comment closer]/ - * ETH_LEN_MAX = 1518 # /[inserted by cython to avoid comment start]* maximum frame length with CRC *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * - * ETH_MTU = (ETH_LEN_MAX - ETH_HDR_LEN - ETH_CRC_LEN) + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_LEN_MAX, __pyx_int_1518) < 0) __PYX_ERR(0, 84, __pyx_L1_error) + __pyx_codeobj__109 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__109)) __PYX_ERR(1, 1, __pyx_L1_error) - /* "dnet.pyx":86 - * ETH_LEN_MAX = 1518 # /[inserted by cython to avoid comment start]* maximum frame length with CRC *[inserted by cython to avoid comment closer]/ - * - * ETH_MTU = (ETH_LEN_MAX - ETH_HDR_LEN - ETH_CRC_LEN) # <<<<<<<<<<<<<< - * ETH_MIN = (ETH_LEN_MIN - ETH_HDR_LEN - ETH_CRC_LEN) - * + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ETH_LEN_MAX); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ETH_HDR_LEN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Subtract(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __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; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ETH_CRC_LEN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyNumber_Subtract(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 86, __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_MTU, __pyx_t_1) < 0) __PYX_ERR(0, 86, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_codeobj__110 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__110)) __PYX_ERR(1, 3, __pyx_L1_error) - /* "dnet.pyx":87 - * - * ETH_MTU = (ETH_LEN_MAX - ETH_HDR_LEN - ETH_CRC_LEN) - * ETH_MIN = (ETH_LEN_MIN - ETH_HDR_LEN - ETH_CRC_LEN) # <<<<<<<<<<<<<< + /* "dnet.pyx":1518 + * return tun_fileno(self.tun) * - * ETH_TYPE_PUP = 0x0200 # /[inserted by cython to avoid comment start]* PUP protocol *[inserted by cython to avoid comment closer]/ + * def fileno(self): # <<<<<<<<<<<<<< + * """Return file descriptor for tunnel handle.""" + * return tun_fileno(self.tun) */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ETH_LEN_MIN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ETH_HDR_LEN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Subtract(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __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; - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ETH_CRC_LEN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_1 = PyNumber_Subtract(__pyx_t_3, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_MIN, __pyx_t_1) < 0) __PYX_ERR(0, 87, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_codeobj__111 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_fileno, 1518, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__111)) __PYX_ERR(0, 1518, __pyx_L1_error) - /* "dnet.pyx":89 - * ETH_MIN = (ETH_LEN_MIN - ETH_HDR_LEN - ETH_CRC_LEN) + /* "dnet.pyx":1522 + * return tun_fileno(self.tun) * - * ETH_TYPE_PUP = 0x0200 # /[inserted by cython to avoid comment start]* PUP protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ + * def send(self, pkt): # <<<<<<<<<<<<<< + * """Send an IP packet, returning the number of bytes sent + * or -1 on failure. */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_PUP, __pyx_int_512) < 0) __PYX_ERR(0, 89, __pyx_L1_error) + __pyx_codeobj__112 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__21, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_send, 1522, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__112)) __PYX_ERR(0, 1522, __pyx_L1_error) - /* "dnet.pyx":90 + /* "dnet.pyx":1531 + * return tun_send(self.tun, pkt, PyBytes_Size(pkt)) * - * ETH_TYPE_PUP = 0x0200 # /[inserted by cython to avoid comment start]* PUP protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ + * def recv(self): # <<<<<<<<<<<<<< + * """Return the next packet delivered to the tunnel interface.""" + * cdef int n */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_IP, __pyx_int_2048) < 0) __PYX_ERR(0, 90, __pyx_L1_error) + __pyx_tuple__113 = PyTuple_Pack(2, __pyx_n_s_self, __pyx_n_s_n); if (unlikely(!__pyx_tuple__113)) __PYX_ERR(0, 1531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__113); + __Pyx_GIVEREF(__pyx_tuple__113); + __pyx_codeobj__114 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 2, 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_dnet_pyx, __pyx_n_s_recv, 1531, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__114)) __PYX_ERR(0, 1531, __pyx_L1_error) - /* "dnet.pyx":91 - * ETH_TYPE_PUP = 0x0200 # /[inserted by cython to avoid comment start]* PUP protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":1539 + * return PyBytes_FromStringAndSize(self.buf, n) + * + * def close(self): # <<<<<<<<<<<<<< + * self.tun = tun_close(self.tun) + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_ARP, __pyx_int_2054) < 0) __PYX_ERR(0, 91, __pyx_L1_error) + __pyx_codeobj__115 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_dnet_pyx, __pyx_n_s_close, 1539, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__115)) __PYX_ERR(0, 1539, __pyx_L1_error) - /* "dnet.pyx":92 - * ETH_TYPE_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_REVARP, __pyx_int_32821) < 0) __PYX_ERR(0, 92, __pyx_L1_error) - - /* "dnet.pyx":93 - * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_8021Q, __pyx_int_33024) < 0) __PYX_ERR(0, 93, __pyx_L1_error) - - /* "dnet.pyx":94 - * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_IPV6, __pyx_int_34525) < 0) __PYX_ERR(0, 94, __pyx_L1_error) - - /* "dnet.pyx":95 - * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_MPLS, __pyx_int_34887) < 0) __PYX_ERR(0, 95, __pyx_L1_error) - - /* "dnet.pyx":96 - * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_PPPOE = 0x8864 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Session Stage *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_MPLS_MCAST, __pyx_int_34888) < 0) __PYX_ERR(0, 96, __pyx_L1_error) - - /* "dnet.pyx":97 - * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_PPPOE = 0x8864 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Session Stage *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_LOOPBACK = 0x9000 # /[inserted by cython to avoid comment start]* used to test interfaces *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_PPPOEDISC, __pyx_int_34915) < 0) __PYX_ERR(0, 97, __pyx_L1_error) - - /* "dnet.pyx":98 - * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_PPPOE = 0x8864 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Session Stage *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ETH_TYPE_LOOPBACK = 0x9000 # /[inserted by cython to avoid comment start]* used to test interfaces *[inserted by cython to avoid comment closer]/ - * - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_PPPOE, __pyx_int_34916) < 0) __PYX_ERR(0, 98, __pyx_L1_error) - - /* "dnet.pyx":99 - * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_PPPOE = 0x8864 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Session Stage *[inserted by cython to avoid comment closer]/ - * ETH_TYPE_LOOPBACK = 0x9000 # /[inserted by cython to avoid comment start]* used to test interfaces *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * - * ETH_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00", 6) - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_LOOPBACK, __pyx_int_36864) < 0) __PYX_ERR(0, 99, __pyx_L1_error) + __pyx_codeobj__116 = (PyObject*)__Pyx_PyCode_New(1, 0, 0, 1, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__12, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_reduce_cython, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__116)) __PYX_ERR(1, 1, __pyx_L1_error) - /* "dnet.pyx":101 - * ETH_TYPE_LOOPBACK = 0x9000 # /[inserted by cython to avoid comment start]* used to test interfaces *[inserted by cython to avoid comment closer]/ - * - * ETH_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00", 6) # <<<<<<<<<<<<<< - * ETH_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff\xff\xff", 6) - * + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" */ - __pyx_t_1 = PyBytes_FromStringAndSize(((char *)"\000\000\000\000\000\000"), 6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_ADDR_UNSPEC, __pyx_t_1) < 0) __PYX_ERR(0, 101, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_codeobj__117 = (PyObject*)__Pyx_PyCode_New(2, 0, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__14, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_setstate_cython, 3, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__117)) __PYX_ERR(1, 3, __pyx_L1_error) - /* "dnet.pyx":102 - * - * ETH_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00", 6) - * ETH_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff\xff\xff", 6) # <<<<<<<<<<<<<< - * - * cdef class eth: + /* "(tree fragment)":1 + * def __pyx_unpickle___addr_ip4_iter(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result */ - __pyx_t_1 = PyBytes_FromStringAndSize(((char *)"\377\377\377\377\377\377"), 6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_ADDR_BROADCAST, __pyx_t_1) < 0) __PYX_ERR(0, 102, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_tuple__118 = 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__118)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__118); + __Pyx_GIVEREF(__pyx_tuple__118); + __pyx_codeobj__119 = (PyObject*)__Pyx_PyCode_New(3, 0, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__118, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle___addr_ip4_iter, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__119)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ - /* "dnet.pyx":149 - * eth_close(self.eth) - * - * def eth_ntoa(buf): # <<<<<<<<<<<<<< - * """Convert an Ethernet MAC address from 6-byte packed binary string to - * a printable string ('00:de:ad:be:ef:00').""" - */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4dnet_3eth_ntoa, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_eth_ntoa, __pyx_t_1) < 0) __PYX_ERR(0, 149, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static CYTHON_SMALL_CODE int __Pyx_InitConstants(void) { + if (__Pyx_CreateStringTabAndInitStrings() < 0) __PYX_ERR(0, 1, __pyx_L1_error); + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2 = PyInt_FromLong(2); if (unlikely(!__pyx_int_2)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_3 = PyInt_FromLong(3); if (unlikely(!__pyx_int_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_4 = PyInt_FromLong(4); if (unlikely(!__pyx_int_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_5 = PyInt_FromLong(5); if (unlikely(!__pyx_int_5)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_6 = PyInt_FromLong(6); if (unlikely(!__pyx_int_6)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_7 = PyInt_FromLong(7); if (unlikely(!__pyx_int_7)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_8 = PyInt_FromLong(8); if (unlikely(!__pyx_int_8)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_9 = PyInt_FromLong(9); if (unlikely(!__pyx_int_9)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_10 = PyInt_FromLong(10); if (unlikely(!__pyx_int_10)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_11 = PyInt_FromLong(11); if (unlikely(!__pyx_int_11)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_12 = PyInt_FromLong(12); if (unlikely(!__pyx_int_12)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_13 = PyInt_FromLong(13); if (unlikely(!__pyx_int_13)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_14 = PyInt_FromLong(14); if (unlikely(!__pyx_int_14)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_15 = PyInt_FromLong(15); if (unlikely(!__pyx_int_15)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_16 = PyInt_FromLong(16); if (unlikely(!__pyx_int_16)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_17 = PyInt_FromLong(17); if (unlikely(!__pyx_int_17)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_18 = PyInt_FromLong(18); if (unlikely(!__pyx_int_18)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_19 = PyInt_FromLong(19); if (unlikely(!__pyx_int_19)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_20 = PyInt_FromLong(20); if (unlikely(!__pyx_int_20)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_21 = PyInt_FromLong(21); if (unlikely(!__pyx_int_21)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_22 = PyInt_FromLong(22); if (unlikely(!__pyx_int_22)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_23 = PyInt_FromLong(23); if (unlikely(!__pyx_int_23)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_24 = PyInt_FromLong(24); if (unlikely(!__pyx_int_24)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_26 = PyInt_FromLong(26); if (unlikely(!__pyx_int_26)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_27 = PyInt_FromLong(27); if (unlikely(!__pyx_int_27)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_32 = PyInt_FromLong(32); if (unlikely(!__pyx_int_32)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_40 = PyInt_FromLong(40); if (unlikely(!__pyx_int_40)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_41 = PyInt_FromLong(41); if (unlikely(!__pyx_int_41)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_47 = PyInt_FromLong(47); if (unlikely(!__pyx_int_47)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_48 = PyInt_FromLong(48); if (unlikely(!__pyx_int_48)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_50 = PyInt_FromLong(50); if (unlikely(!__pyx_int_50)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_51 = PyInt_FromLong(51); if (unlikely(!__pyx_int_51)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_53 = PyInt_FromLong(53); if (unlikely(!__pyx_int_53)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_58 = PyInt_FromLong(58); if (unlikely(!__pyx_int_58)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_64 = PyInt_FromLong(64); if (unlikely(!__pyx_int_64)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_128 = PyInt_FromLong(128); if (unlikely(!__pyx_int_128)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_255 = PyInt_FromLong(255); if (unlikely(!__pyx_int_255)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_512 = PyInt_FromLong(512); if (unlikely(!__pyx_int_512)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1024 = PyInt_FromLong(1024); if (unlikely(!__pyx_int_1024)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1280 = PyInt_FromLong(1280); if (unlikely(!__pyx_int_1280)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1500 = PyInt_FromLong(1500); if (unlikely(!__pyx_int_1500)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1518 = PyInt_FromLong(1518); if (unlikely(!__pyx_int_1518)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2048 = PyInt_FromLong(2048); if (unlikely(!__pyx_int_2048)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_2054 = PyInt_FromLong(2054); if (unlikely(!__pyx_int_2054)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_8191 = PyInt_FromLong(8191); if (unlikely(!__pyx_int_8191)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_8192 = PyInt_FromLong(8192); if (unlikely(!__pyx_int_8192)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_16384 = PyInt_FromLong(16384L); if (unlikely(!__pyx_int_16384)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_32768 = PyInt_FromLong(32768L); if (unlikely(!__pyx_int_32768)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_32821 = PyInt_FromLong(32821L); if (unlikely(!__pyx_int_32821)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_33024 = PyInt_FromLong(33024L); if (unlikely(!__pyx_int_33024)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_34525 = PyInt_FromLong(34525L); if (unlikely(!__pyx_int_34525)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_34887 = PyInt_FromLong(34887L); if (unlikely(!__pyx_int_34887)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_34888 = PyInt_FromLong(34888L); if (unlikely(!__pyx_int_34888)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_34915 = PyInt_FromLong(34915L); if (unlikely(!__pyx_int_34915)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_34916 = PyInt_FromLong(34916L); if (unlikely(!__pyx_int_34916)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_36864 = PyInt_FromLong(36864L); if (unlikely(!__pyx_int_36864)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_65535 = PyInt_FromLong(65535L); if (unlikely(!__pyx_int_65535)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_112194662 = PyInt_FromLong(112194662L); if (unlikely(!__pyx_int_112194662)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_113314003 = PyInt_FromLong(113314003L); if (unlikely(!__pyx_int_113314003)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_218787872 = PyInt_FromLong(218787872L); if (unlikely(!__pyx_int_218787872)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_globals ### */ - /* "dnet.pyx":156 - * return __eth_ntoa(&ea) - * - * def eth_aton(buf): # <<<<<<<<<<<<<< - * """Convert an Ethernet MAC address from a printable string to a - * packed binary string ('\\x00\\xde\\xad\\xbe\\xef\\x00').""" - */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4dnet_5eth_aton, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_eth_aton, __pyx_t_1) < 0) __PYX_ERR(0, 156, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void) { + return 0; +} +/* #### Code section: init_module ### */ - /* "dnet.pyx":164 - * return PyBytes_FromStringAndSize(ea.data, 6) - * - * def eth_pack_hdr(dst=ETH_ADDR_BROADCAST, src=ETH_ADDR_BROADCAST, # <<<<<<<<<<<<<< - * etype=ETH_TYPE_IP): - * """Return a packed binary string representing an Ethernet header. - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ETH_ADDR_BROADCAST); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_k__3 = __pyx_t_1; - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ETH_ADDR_BROADCAST); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_k__4 = __pyx_t_1; - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; +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*/ - /* "dnet.pyx":165 - * - * def eth_pack_hdr(dst=ETH_ADDR_BROADCAST, src=ETH_ADDR_BROADCAST, - * etype=ETH_TYPE_IP): # <<<<<<<<<<<<<< - * """Return a packed binary string representing an Ethernet header. - * - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_ETH_TYPE_IP); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 165, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __pyx_k__5 = __pyx_t_1; - __Pyx_GIVEREF(__pyx_t_1); - __pyx_t_1 = 0; +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "dnet.pyx":164 - * return PyBytes_FromStringAndSize(ea.data, 6) - * - * def eth_pack_hdr(dst=ETH_ADDR_BROADCAST, src=ETH_ADDR_BROADCAST, # <<<<<<<<<<<<<< - * etype=ETH_TYPE_IP): - * """Return a packed binary string representing an Ethernet header. - */ - __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_4dnet_7eth_pack_hdr, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_eth_pack_hdr, __pyx_t_1) < 0) __PYX_ERR(0, 164, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 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; +} - /* "dnet.pyx":201 - * int off, int ttl, int p, ip_addr_t s, ip_addr_t d) - * - * IP_ADDR_LEN = 4 # /[inserted by cython to avoid comment start]* IP address length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_ADDR_BITS = 32 # /[inserted by cython to avoid comment start]* IP address bits *[inserted by cython to avoid comment closer]/ - * - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_LEN, __pyx_int_4) < 0) __PYX_ERR(0, 201, __pyx_L1_error) +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; +} - /* "dnet.pyx":202 - * - * IP_ADDR_LEN = 4 # /[inserted by cython to avoid comment start]* IP address length *[inserted by cython to avoid comment closer]/ - * IP_ADDR_BITS = 32 # /[inserted by cython to avoid comment start]* IP address bits *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * - * IP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base IP header length *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_BITS, __pyx_int_32) < 0) __PYX_ERR(0, 202, __pyx_L1_error) +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 CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_eth = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_eth_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_eth)) __PYX_ERR(0, 104, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_eth_spec, __pyx_ptype_4dnet_eth) < 0) __PYX_ERR(0, 104, __pyx_L1_error) + #else + __pyx_ptype_4dnet_eth = &__pyx_type_4dnet_eth; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_eth) < 0) __PYX_ERR(0, 104, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_eth->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_eth->tp_dictoffset && __pyx_ptype_4dnet_eth->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_eth->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_eth, (PyObject *) __pyx_ptype_4dnet_eth) < 0) __PYX_ERR(0, 104, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_eth) < 0) __PYX_ERR(0, 104, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_ip = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_ip_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_ip)) __PYX_ERR(0, 242, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_ip_spec, __pyx_ptype_4dnet_ip) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + #else + __pyx_ptype_4dnet_ip = &__pyx_type_4dnet_ip; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_ip) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_ip->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_ip->tp_dictoffset && __pyx_ptype_4dnet_ip->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_ip->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_ip, (PyObject *) __pyx_ptype_4dnet_ip) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_ip) < 0) __PYX_ERR(0, 242, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_addr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_addr_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_addr)) __PYX_ERR(0, 438, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_addr_spec, __pyx_ptype_4dnet_addr) < 0) __PYX_ERR(0, 438, __pyx_L1_error) + #else + __pyx_ptype_4dnet_addr = &__pyx_type_4dnet_addr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_addr) < 0) __PYX_ERR(0, 438, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_addr->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_addr->tp_dictoffset && __pyx_ptype_4dnet_addr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_addr->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_addr, (PyObject *) __pyx_ptype_4dnet_addr) < 0) __PYX_ERR(0, 438, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_addr) < 0) __PYX_ERR(0, 438, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet___addr_ip4_iter = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet___addr_ip4_iter_spec, NULL); if (unlikely(!__pyx_ptype_4dnet___addr_ip4_iter)) __PYX_ERR(0, 635, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet___addr_ip4_iter_spec, __pyx_ptype_4dnet___addr_ip4_iter) < 0) __PYX_ERR(0, 635, __pyx_L1_error) + #else + __pyx_ptype_4dnet___addr_ip4_iter = &__pyx_type_4dnet___addr_ip4_iter; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet___addr_ip4_iter) < 0) __PYX_ERR(0, 635, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet___addr_ip4_iter->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet___addr_ip4_iter->tp_dictoffset && __pyx_ptype_4dnet___addr_ip4_iter->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet___addr_ip4_iter->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_addr_ip4_iter, (PyObject *) __pyx_ptype_4dnet___addr_ip4_iter) < 0) __PYX_ERR(0, 635, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet___addr_ip4_iter) < 0) __PYX_ERR(0, 635, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_arp = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_arp_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_arp)) __PYX_ERR(0, 700, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_arp_spec, __pyx_ptype_4dnet_arp) < 0) __PYX_ERR(0, 700, __pyx_L1_error) + #else + __pyx_ptype_4dnet_arp = &__pyx_type_4dnet_arp; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_arp) < 0) __PYX_ERR(0, 700, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_arp->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_arp->tp_dictoffset && __pyx_ptype_4dnet_arp->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_arp->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_arp, (PyObject *) __pyx_ptype_4dnet_arp) < 0) __PYX_ERR(0, 700, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_arp) < 0) __PYX_ERR(0, 700, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_intf = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_intf_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_intf)) __PYX_ERR(0, 980, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_intf_spec, __pyx_ptype_4dnet_intf) < 0) __PYX_ERR(0, 980, __pyx_L1_error) + #else + __pyx_ptype_4dnet_intf = &__pyx_type_4dnet_intf; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_intf) < 0) __PYX_ERR(0, 980, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_intf->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_intf->tp_dictoffset && __pyx_ptype_4dnet_intf->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_intf->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_intf, (PyObject *) __pyx_ptype_4dnet_intf) < 0) __PYX_ERR(0, 980, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_intf) < 0) __PYX_ERR(0, 980, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_route = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_route_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_route)) __PYX_ERR(0, 1099, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_route_spec, __pyx_ptype_4dnet_route) < 0) __PYX_ERR(0, 1099, __pyx_L1_error) + #else + __pyx_ptype_4dnet_route = &__pyx_type_4dnet_route; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_route) < 0) __PYX_ERR(0, 1099, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_route->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_route->tp_dictoffset && __pyx_ptype_4dnet_route->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_route->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_route, (PyObject *) __pyx_ptype_4dnet_route) < 0) __PYX_ERR(0, 1099, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_route) < 0) __PYX_ERR(0, 1099, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_fw = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_fw_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_fw)) __PYX_ERR(0, 1245, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_fw_spec, __pyx_ptype_4dnet_fw) < 0) __PYX_ERR(0, 1245, __pyx_L1_error) + #else + __pyx_ptype_4dnet_fw = &__pyx_type_4dnet_fw; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_fw) < 0) __PYX_ERR(0, 1245, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_fw->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_fw->tp_dictoffset && __pyx_ptype_4dnet_fw->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_fw->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_fw, (PyObject *) __pyx_ptype_4dnet_fw) < 0) __PYX_ERR(0, 1245, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_fw) < 0) __PYX_ERR(0, 1245, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_rand = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_rand_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_rand)) __PYX_ERR(0, 1322, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_rand_spec, __pyx_ptype_4dnet_rand) < 0) __PYX_ERR(0, 1322, __pyx_L1_error) + #else + __pyx_ptype_4dnet_rand = &__pyx_type_4dnet_rand; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_rand) < 0) __PYX_ERR(0, 1322, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_rand->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_rand->tp_dictoffset && __pyx_ptype_4dnet_rand->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_rand->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_rand, (PyObject *) __pyx_ptype_4dnet_rand) < 0) __PYX_ERR(0, 1322, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_rand) < 0) __PYX_ERR(0, 1322, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet___rand_xrange = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet___rand_xrange_spec, NULL); if (unlikely(!__pyx_ptype_4dnet___rand_xrange)) __PYX_ERR(0, 1404, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet___rand_xrange_spec, __pyx_ptype_4dnet___rand_xrange) < 0) __PYX_ERR(0, 1404, __pyx_L1_error) + #else + __pyx_ptype_4dnet___rand_xrange = &__pyx_type_4dnet___rand_xrange; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet___rand_xrange) < 0) __PYX_ERR(0, 1404, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet___rand_xrange->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet___rand_xrange->tp_dictoffset && __pyx_ptype_4dnet___rand_xrange->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet___rand_xrange->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_rand_xrange, (PyObject *) __pyx_ptype_4dnet___rand_xrange) < 0) __PYX_ERR(0, 1404, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet___rand_xrange) < 0) __PYX_ERR(0, 1404, __pyx_L1_error) + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_ptype_4dnet_tun = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4dnet_tun_spec, NULL); if (unlikely(!__pyx_ptype_4dnet_tun)) __PYX_ERR(0, 1488, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4dnet_tun_spec, __pyx_ptype_4dnet_tun) < 0) __PYX_ERR(0, 1488, __pyx_L1_error) + #else + __pyx_ptype_4dnet_tun = &__pyx_type_4dnet_tun; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_ptype_4dnet_tun) < 0) __PYX_ERR(0, 1488, __pyx_L1_error) + #endif + #if PY_MAJOR_VERSION < 3 + __pyx_ptype_4dnet_tun->tp_print = 0; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_ptype_4dnet_tun->tp_dictoffset && __pyx_ptype_4dnet_tun->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_ptype_4dnet_tun->tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_tun, (PyObject *) __pyx_ptype_4dnet_tun) < 0) __PYX_ERR(0, 1488, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_setup_reduce((PyObject *) __pyx_ptype_4dnet_tun) < 0) __PYX_ERR(0, 1488, __pyx_L1_error) + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} - /* "dnet.pyx":204 - * IP_ADDR_BITS = 32 # /[inserted by cython to avoid comment start]* IP address bits *[inserted by cython to avoid comment closer]/ - * - * IP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base IP header length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_OPT_LEN = 2 # /[inserted by cython to avoid comment start]* base IP option length *[inserted by cython to avoid comment closer]/ - * IP_OPT_LEN_MAX =40 - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_HDR_LEN, __pyx_int_20) < 0) __PYX_ERR(0, 204, __pyx_L1_error) +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} - /* "dnet.pyx":205 - * - * IP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base IP header length *[inserted by cython to avoid comment closer]/ - * IP_OPT_LEN = 2 # /[inserted by cython to avoid comment start]* base IP option length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_OPT_LEN_MAX =40 - * IP_HDR_LEN_MAX =(IP_HDR_LEN + IP_OPT_LEN_MAX) - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_OPT_LEN, __pyx_int_2) < 0) __PYX_ERR(0, 205, __pyx_L1_error) +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; +} - /* "dnet.pyx":206 - * IP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base IP header length *[inserted by cython to avoid comment closer]/ - * IP_OPT_LEN = 2 # /[inserted by cython to avoid comment start]* base IP option length *[inserted by cython to avoid comment closer]/ - * IP_OPT_LEN_MAX =40 # <<<<<<<<<<<<<< - * IP_HDR_LEN_MAX =(IP_HDR_LEN + IP_OPT_LEN_MAX) - * - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_OPT_LEN_MAX, __pyx_int_40) < 0) __PYX_ERR(0, 206, __pyx_L1_error) +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; +} - /* "dnet.pyx":207 - * IP_OPT_LEN = 2 # /[inserted by cython to avoid comment start]* base IP option length *[inserted by cython to avoid comment closer]/ - * IP_OPT_LEN_MAX =40 - * IP_HDR_LEN_MAX =(IP_HDR_LEN + IP_OPT_LEN_MAX) # <<<<<<<<<<<<<< - * - * IP_LEN_MAX = 65535 - */ - __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_n_s_IP_HDR_LEN); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_1); - __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_IP_OPT_LEN_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_2); - __pyx_t_3 = PyNumber_Add(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __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; - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_HDR_LEN_MAX, __pyx_t_3) < 0) __PYX_ERR(0, 207, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dnet.pyx":209 - * IP_HDR_LEN_MAX =(IP_HDR_LEN + IP_OPT_LEN_MAX) - * - * IP_LEN_MAX = 65535 # <<<<<<<<<<<<<< - * IP_LEN_MIN = IP_HDR_LEN - * - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_LEN_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 209, __pyx_L1_error) +#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_dnet(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_dnet}, + {0, NULL} +}; +#endif - /* "dnet.pyx":210 - * - * IP_LEN_MAX = 65535 - * IP_LEN_MIN = IP_HDR_LEN # <<<<<<<<<<<<<< - * - * IP_TOS_DEFAULT =0x00 # /[inserted by cython to avoid comment start]* default *[inserted by cython to avoid comment closer]/ - */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_HDR_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_LEN_MIN, __pyx_t_3) < 0) __PYX_ERR(0, 210, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "dnet", + __pyx_k_dumb_networking_library_This_mod, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #elif CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstate), /* 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 + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif +#endif - /* "dnet.pyx":212 - * IP_LEN_MIN = IP_HDR_LEN - * - * IP_TOS_DEFAULT =0x00 # /[inserted by cython to avoid comment start]* default *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * - * IP_RF = 0x8000 # /[inserted by cython to avoid comment start]* reserved *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_TOS_DEFAULT, __pyx_int_0) < 0) __PYX_ERR(0, 212, __pyx_L1_error) +#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 - /* "dnet.pyx":214 - * IP_TOS_DEFAULT =0x00 # /[inserted by cython to avoid comment start]* default *[inserted by cython to avoid comment closer]/ - * - * IP_RF = 0x8000 # /[inserted by cython to avoid comment start]* reserved *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_DF = 0x4000 # /[inserted by cython to avoid comment start]* don't fragment *[inserted by cython to avoid comment closer]/ - * IP_MF = 0x2000 # /[inserted by cython to avoid comment start]* more fragments (not last frag) *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_RF, __pyx_int_32768) < 0) __PYX_ERR(0, 214, __pyx_L1_error) - /* "dnet.pyx":215 - * - * IP_RF = 0x8000 # /[inserted by cython to avoid comment start]* reserved *[inserted by cython to avoid comment closer]/ - * IP_DF = 0x4000 # /[inserted by cython to avoid comment start]* don't fragment *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_MF = 0x2000 # /[inserted by cython to avoid comment start]* more fragments (not last frag) *[inserted by cython to avoid comment closer]/ - * IP_OFFMASK = 0x1fff # /[inserted by cython to avoid comment start]* mask for fragment offset *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_DF, __pyx_int_16384) < 0) __PYX_ERR(0, 215, __pyx_L1_error) +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initdnet(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initdnet(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_dnet(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_dnet(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; +} +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *module, const char* from_name, const char* to_name, int allow_none) +#else +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) +#endif +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { +#if CYTHON_COMPILING_IN_LIMITED_API + result = PyModule_AddObject(module, to_name, value); +#else + result = PyDict_SetItemString(moddict, to_name, value); +#endif + } + 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, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + 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; +#if CYTHON_COMPILING_IN_LIMITED_API + moddict = module; +#else + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; +#endif + 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; +} - /* "dnet.pyx":216 - * IP_RF = 0x8000 # /[inserted by cython to avoid comment start]* reserved *[inserted by cython to avoid comment closer]/ - * IP_DF = 0x4000 # /[inserted by cython to avoid comment start]* don't fragment *[inserted by cython to avoid comment closer]/ - * IP_MF = 0x2000 # /[inserted by cython to avoid comment start]* more fragments (not last frag) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_OFFMASK = 0x1fff # /[inserted by cython to avoid comment start]* mask for fragment offset *[inserted by cython to avoid comment closer]/ + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_dnet(PyObject *__pyx_pyinit_module) +#endif +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + 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_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'dnet' 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 + /*--- 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("dnet", __pyx_methods, __pyx_k_dumb_networking_library_This_mod, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #elif CYTHON_USE_MODULE_STATE + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + { + int add_module_result = PyState_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "dnet" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = PyModule_Create(&__pyx_moduledef); + if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #endif + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_d); + __pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_cython_runtime = __Pyx_PyImport_AddModuleRef((const char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #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_dnet(void)", 0); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < 0) __PYX_ERR(0, 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(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init(__pyx_m) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 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(0, 1, __pyx_L1_error) + #endif + if (__pyx_module_is_main_dnet) { + if (PyObject_SetAttr(__pyx_m, __pyx_n_s_name_2, __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + } + #if PY_MAJOR_VERSION >= 3 + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "dnet")) { + if (unlikely((PyDict_SetItemString(modules, "dnet", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #endif + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 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(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_type_import_code(); + (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(0, 1, __pyx_L1_error) + #endif + + /* "dnet.pyx":15 + * """ * + * __author__ = 'Oliver Falk ' # <<<<<<<<<<<<<< + * __copyright__ = 'Copyright (c) 2023-2024 Oliver Falk' + * __license__ = 'BSD' */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_MF, __pyx_int_8192) < 0) __PYX_ERR(0, 216, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_author, __pyx_kp_u_Oliver_Falk_oliver_linux_kernel) < 0) __PYX_ERR(0, 15, __pyx_L1_error) - /* "dnet.pyx":217 - * IP_DF = 0x4000 # /[inserted by cython to avoid comment start]* don't fragment *[inserted by cython to avoid comment closer]/ - * IP_MF = 0x2000 # /[inserted by cython to avoid comment start]* more fragments (not last frag) *[inserted by cython to avoid comment closer]/ - * IP_OFFMASK = 0x1fff # /[inserted by cython to avoid comment start]* mask for fragment offset *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + /* "dnet.pyx":16 * - * IP_TTL_DEFAULT =64 # /[inserted by cython to avoid comment start]* default ttl, RFC 1122, RFC 1340 *[inserted by cython to avoid comment closer]/ + * __author__ = 'Oliver Falk ' + * __copyright__ = 'Copyright (c) 2023-2024 Oliver Falk' # <<<<<<<<<<<<<< + * __license__ = 'BSD' + * __url__ = 'https://github.com/ofalk/libdnet' */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_OFFMASK, __pyx_int_8191) < 0) __PYX_ERR(0, 217, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_copyright, __pyx_kp_u_Copyright_c_2023_2024_Oliver_Fal) < 0) __PYX_ERR(0, 16, __pyx_L1_error) - /* "dnet.pyx":219 - * IP_OFFMASK = 0x1fff # /[inserted by cython to avoid comment start]* mask for fragment offset *[inserted by cython to avoid comment closer]/ - * - * IP_TTL_DEFAULT =64 # /[inserted by cython to avoid comment start]* default ttl, RFC 1122, RFC 1340 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_TTL_MAX = 255 # /[inserted by cython to avoid comment start]* maximum ttl *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":17 + * __author__ = 'Oliver Falk ' + * __copyright__ = 'Copyright (c) 2023-2024 Oliver Falk' + * __license__ = 'BSD' # <<<<<<<<<<<<<< + * __url__ = 'https://github.com/ofalk/libdnet' + * __version__ = '1.18.0' + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_license, __pyx_n_u_BSD) < 0) __PYX_ERR(0, 17, __pyx_L1_error) + + /* "dnet.pyx":18 + * __copyright__ = 'Copyright (c) 2023-2024 Oliver Falk' + * __license__ = 'BSD' + * __url__ = 'https://github.com/ofalk/libdnet' # <<<<<<<<<<<<<< + * __version__ = '1.18.0' * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_TTL_DEFAULT, __pyx_int_64) < 0) __PYX_ERR(0, 219, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_url, __pyx_kp_u_https_github_com_ofalk_libdnet) < 0) __PYX_ERR(0, 18, __pyx_L1_error) - /* "dnet.pyx":220 + /* "dnet.pyx":19 + * __license__ = 'BSD' + * __url__ = 'https://github.com/ofalk/libdnet' + * __version__ = '1.18.0' # <<<<<<<<<<<<<< * - * IP_TTL_DEFAULT =64 # /[inserted by cython to avoid comment start]* default ttl, RFC 1122, RFC 1340 *[inserted by cython to avoid comment closer]/ - * IP_TTL_MAX = 255 # /[inserted by cython to avoid comment start]* maximum ttl *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< * - * IP_PROTO_IP = 0 # /[inserted by cython to avoid comment start]* dummy for IP *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_TTL_MAX, __pyx_int_255) < 0) __PYX_ERR(0, 220, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_version, __pyx_kp_u_1_18_0) < 0) __PYX_ERR(0, 19, __pyx_L1_error) - /* "dnet.pyx":222 - * IP_TTL_MAX = 255 # /[inserted by cython to avoid comment start]* maximum ttl *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":54 + * return strerror(errno) + * + * def __iter_append(entry, l): # <<<<<<<<<<<<<< + * l.append(entry) * - * IP_PROTO_IP = 0 # /[inserted by cython to avoid comment start]* dummy for IP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_ICMP = 1 # /[inserted by cython to avoid comment start]* ICMP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_IP, __pyx_int_0) < 0) __PYX_ERR(0, 222, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_1__iter_append, 0, __pyx_n_s_iter_append, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__5)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_iter_append, __pyx_t_2) < 0) __PYX_ERR(0, 54, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":223 + /* "dnet.pyx":77 + * eth_addr_t dst, eth_addr_t src, int etype) * - * IP_PROTO_IP = 0 # /[inserted by cython to avoid comment start]* dummy for IP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_ICMP = 1 # /[inserted by cython to avoid comment start]* ICMP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ + * ETH_ADDR_LEN = 6 # <<<<<<<<<<<<<< + * ETH_ADDR_BITS = 48 + * ETH_TYPE_LEN = 2 */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_ICMP, __pyx_int_1) < 0) __PYX_ERR(0, 223, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_ADDR_LEN, __pyx_int_6) < 0) __PYX_ERR(0, 77, __pyx_L1_error) - /* "dnet.pyx":224 - * IP_PROTO_IP = 0 # /[inserted by cython to avoid comment start]* dummy for IP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_ICMP = 1 # /[inserted by cython to avoid comment start]* ICMP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_IGMP, __pyx_int_2) < 0) __PYX_ERR(0, 224, __pyx_L1_error) - - /* "dnet.pyx":225 - * IP_PROTO_ICMP = 1 # /[inserted by cython to avoid comment start]* ICMP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_TCP, __pyx_int_6) < 0) __PYX_ERR(0, 225, __pyx_L1_error) - - /* "dnet.pyx":226 - * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ - * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_UDP, __pyx_int_17) < 0) __PYX_ERR(0, 226, __pyx_L1_error) - - /* "dnet.pyx":227 - * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ - * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_IPV6, __pyx_int_41) < 0) __PYX_ERR(0, 227, __pyx_L1_error) - - /* "dnet.pyx":228 - * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ - * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ - * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ - * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_GRE, __pyx_int_47) < 0) __PYX_ERR(0, 228, __pyx_L1_error) - - /* "dnet.pyx":229 - * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ - * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ - * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ - * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_ESP, __pyx_int_50) < 0) __PYX_ERR(0, 229, __pyx_L1_error) - - /* "dnet.pyx":230 - * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ - * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ - * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ - * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":78 + * + * ETH_ADDR_LEN = 6 + * ETH_ADDR_BITS = 48 # <<<<<<<<<<<<<< + * ETH_TYPE_LEN = 2 + * ETH_CRC_LEN = 4 */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_AH, __pyx_int_51) < 0) __PYX_ERR(0, 230, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_ADDR_BITS, __pyx_int_48) < 0) __PYX_ERR(0, 78, __pyx_L1_error) - /* "dnet.pyx":231 - * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ - * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ - * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ - * IP_PROTO_RESERVED = IP_PROTO_RAW # /[inserted by cython to avoid comment start]* Reserved *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":79 + * ETH_ADDR_LEN = 6 + * ETH_ADDR_BITS = 48 + * ETH_TYPE_LEN = 2 # <<<<<<<<<<<<<< + * ETH_CRC_LEN = 4 + * ETH_HDR_LEN = 14 */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_ICMPV6, __pyx_int_58) < 0) __PYX_ERR(0, 231, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_LEN, __pyx_int_2) < 0) __PYX_ERR(0, 79, __pyx_L1_error) - /* "dnet.pyx":232 - * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ - * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ - * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_RESERVED = IP_PROTO_RAW # /[inserted by cython to avoid comment start]* Reserved *[inserted by cython to avoid comment closer]/ - * IP_PROTO_MAX = 255 + /* "dnet.pyx":80 + * ETH_ADDR_BITS = 48 + * ETH_TYPE_LEN = 2 + * ETH_CRC_LEN = 4 # <<<<<<<<<<<<<< + * ETH_HDR_LEN = 14 + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_RAW, __pyx_int_255) < 0) __PYX_ERR(0, 232, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_CRC_LEN, __pyx_int_4) < 0) __PYX_ERR(0, 80, __pyx_L1_error) - /* "dnet.pyx":233 - * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ - * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ - * IP_PROTO_RESERVED = IP_PROTO_RAW # /[inserted by cython to avoid comment start]* Reserved *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP_PROTO_MAX = 255 + /* "dnet.pyx":81 + * ETH_TYPE_LEN = 2 + * ETH_CRC_LEN = 4 + * ETH_HDR_LEN = 14 # <<<<<<<<<<<<<< * + * ETH_LEN_MIN = 64 # /[inserted by cython to avoid comment start]* minimum frame length with CRC *[inserted by cython to avoid comment closer]/ */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_PROTO_RAW); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 233, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_RESERVED, __pyx_t_3) < 0) __PYX_ERR(0, 233, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_HDR_LEN, __pyx_int_14) < 0) __PYX_ERR(0, 81, __pyx_L1_error) - /* "dnet.pyx":234 - * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ - * IP_PROTO_RESERVED = IP_PROTO_RAW # /[inserted by cython to avoid comment start]* Reserved *[inserted by cython to avoid comment closer]/ - * IP_PROTO_MAX = 255 # <<<<<<<<<<<<<< + /* "dnet.pyx":83 + * ETH_HDR_LEN = 14 + * + * ETH_LEN_MIN = 64 # /[inserted by cython to avoid comment start]* minimum frame length with CRC *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_LEN_MAX = 1518 # /[inserted by cython to avoid comment start]* maximum frame length with CRC *[inserted by cython to avoid comment closer]/ * - * IP_ADDR_ANY = PyBytes_FromStringAndSize("\x00\x00\x00\x00", 4) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_MAX, __pyx_int_255) < 0) __PYX_ERR(0, 234, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_LEN_MIN, __pyx_int_64) < 0) __PYX_ERR(0, 83, __pyx_L1_error) - /* "dnet.pyx":236 - * IP_PROTO_MAX = 255 + /* "dnet.pyx":84 * - * IP_ADDR_ANY = PyBytes_FromStringAndSize("\x00\x00\x00\x00", 4) # <<<<<<<<<<<<<< - * IP_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff", 4) - * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) + * ETH_LEN_MIN = 64 # /[inserted by cython to avoid comment start]* minimum frame length with CRC *[inserted by cython to avoid comment closer]/ + * ETH_LEN_MAX = 1518 # /[inserted by cython to avoid comment start]* maximum frame length with CRC *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * ETH_MTU = (ETH_LEN_MAX - ETH_HDR_LEN - ETH_CRC_LEN) */ - __pyx_t_3 = PyBytes_FromStringAndSize(((char *)"\000\000\000\000"), 4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_ANY, __pyx_t_3) < 0) __PYX_ERR(0, 236, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_LEN_MAX, __pyx_int_1518) < 0) __PYX_ERR(0, 84, __pyx_L1_error) - /* "dnet.pyx":237 + /* "dnet.pyx":86 + * ETH_LEN_MAX = 1518 # /[inserted by cython to avoid comment start]* maximum frame length with CRC *[inserted by cython to avoid comment closer]/ + * + * ETH_MTU = (ETH_LEN_MAX - ETH_HDR_LEN - ETH_CRC_LEN) # <<<<<<<<<<<<<< + * ETH_MIN = (ETH_LEN_MIN - ETH_HDR_LEN - ETH_CRC_LEN) * - * IP_ADDR_ANY = PyBytes_FromStringAndSize("\x00\x00\x00\x00", 4) - * IP_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff", 4) # <<<<<<<<<<<<<< - * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) - * IP_ADDR_MCAST_ALL = PyBytes_FromStringAndSize("\xe0\x00\x00\x01", 4) */ - __pyx_t_3 = PyBytes_FromStringAndSize(((char *)"\377\377\377\377"), 4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ETH_LEN_MAX); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_HDR_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_BROADCAST, __pyx_t_3) < 0) __PYX_ERR(0, 237, __pyx_L1_error) + __pyx_t_4 = PyNumber_Subtract(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "dnet.pyx":238 - * IP_ADDR_ANY = PyBytes_FromStringAndSize("\x00\x00\x00\x00", 4) - * IP_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff", 4) - * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) # <<<<<<<<<<<<<< - * IP_ADDR_MCAST_ALL = PyBytes_FromStringAndSize("\xe0\x00\x00\x01", 4) - * IP_ADDR_MCAST_LOCAL = PyBytes_FromStringAndSize("\xe0\x00\x00\xff", 4) - */ - __pyx_t_3 = PyBytes_FromStringAndSize(((char *)"\000\000\001"), 4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_CRC_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 86, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_LOOPBACK, __pyx_t_3) < 0) __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_MTU, __pyx_t_2) < 0) __PYX_ERR(0, 86, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":239 - * IP_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff", 4) - * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) - * IP_ADDR_MCAST_ALL = PyBytes_FromStringAndSize("\xe0\x00\x00\x01", 4) # <<<<<<<<<<<<<< - * IP_ADDR_MCAST_LOCAL = PyBytes_FromStringAndSize("\xe0\x00\x00\xff", 4) + /* "dnet.pyx":87 * - */ - __pyx_t_3 = PyBytes_FromStringAndSize(((char *)"\340\000\000\001"), 4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 239, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_MCAST_ALL, __pyx_t_3) < 0) __PYX_ERR(0, 239, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "dnet.pyx":240 - * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) - * IP_ADDR_MCAST_ALL = PyBytes_FromStringAndSize("\xe0\x00\x00\x01", 4) - * IP_ADDR_MCAST_LOCAL = PyBytes_FromStringAndSize("\xe0\x00\x00\xff", 4) # <<<<<<<<<<<<<< + * ETH_MTU = (ETH_LEN_MAX - ETH_HDR_LEN - ETH_CRC_LEN) + * ETH_MIN = (ETH_LEN_MIN - ETH_HDR_LEN - ETH_CRC_LEN) # <<<<<<<<<<<<<< * - * cdef class ip: + * ETH_TYPE_PUP = 0x0200 # /[inserted by cython to avoid comment start]* PUP protocol *[inserted by cython to avoid comment closer]/ */ - __pyx_t_3 = PyBytes_FromStringAndSize(((char *)"\340\000\000\377"), 4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_ETH_LEN_MIN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_HDR_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_MCAST_LOCAL, __pyx_t_3) < 0) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_t_4 = PyNumber_Subtract(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "dnet.pyx":267 - * ip_close(self.ip) - * - * def ip_ntoa(buf): # <<<<<<<<<<<<<< - * """Convert an IP address from a 4-byte packed binary string or - * integer to a printable string ('10.0.0.1').""" - */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_9ip_ntoa, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_CRC_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_ntoa, __pyx_t_3) < 0) __PYX_ERR(0, 267, __pyx_L1_error) + __pyx_t_2 = PyNumber_Subtract(__pyx_t_4, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_MIN, __pyx_t_2) < 0) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":280 - * return __ip_ntoa(&ia) + /* "dnet.pyx":89 + * ETH_MIN = (ETH_LEN_MIN - ETH_HDR_LEN - ETH_CRC_LEN) * - * def ip_aton(buf): # <<<<<<<<<<<<<< - * """Convert an IP address from a printable string to a - * packed binary string ('\\x0a\\x00\\x00\\x01').""" + * ETH_TYPE_PUP = 0x0200 # /[inserted by cython to avoid comment start]* PUP protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_11ip_aton, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 280, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_aton, __pyx_t_3) < 0) __PYX_ERR(0, 280, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_PUP, __pyx_int_512) < 0) __PYX_ERR(0, 89, __pyx_L1_error) - /* "dnet.pyx":288 - * return PyBytes_FromStringAndSize(&ia, 4) + /* "dnet.pyx":90 * - * def ip_checksum(pkt): # <<<<<<<<<<<<<< - * """Return packed binary string representing an IP packet - * with the IP and transport-layer checksums set. + * ETH_TYPE_PUP = 0x0200 # /[inserted by cython to avoid comment start]* PUP protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_13ip_checksum, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 288, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_checksum, __pyx_t_3) < 0) __PYX_ERR(0, 288, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_IP, __pyx_int_2048) < 0) __PYX_ERR(0, 90, __pyx_L1_error) - /* "dnet.pyx":311 - * raise TypeError - * - * def ip_cksum_add(buf, int sum): # <<<<<<<<<<<<<< - * cdef char *p - * cdef int n + /* "dnet.pyx":91 + * ETH_TYPE_PUP = 0x0200 # /[inserted by cython to avoid comment start]* PUP protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_15ip_cksum_add, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 311, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_cksum_add, __pyx_t_3) < 0) __PYX_ERR(0, 311, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_ARP, __pyx_int_2054) < 0) __PYX_ERR(0, 91, __pyx_L1_error) - /* "dnet.pyx":319 - * raise TypeError - * - * def ip_cksum_carry(int sum): # <<<<<<<<<<<<<< - * return __ip_cksum_carry(sum) - * + /* "dnet.pyx":92 + * ETH_TYPE_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_17ip_cksum_carry, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 319, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_cksum_carry, __pyx_t_3) < 0) __PYX_ERR(0, 319, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_REVARP, __pyx_int_32821) < 0) __PYX_ERR(0, 92, __pyx_L1_error) - /* "dnet.pyx":322 - * return __ip_cksum_carry(sum) - * - * def ip_pack_hdr(tos=IP_TOS_DEFAULT, len=IP_HDR_LEN, id=0, off=0, # <<<<<<<<<<<<<< - * ttl=IP_TTL_DEFAULT, p=IP_PROTO_IP, - * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): + /* "dnet.pyx":93 + * ETH_TYPE_ARP = 0x0806 # /[inserted by cython to avoid comment start]* address resolution protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_TOS_DEFAULT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__8 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_HDR_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__9 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_8021Q, __pyx_int_33024) < 0) __PYX_ERR(0, 93, __pyx_L1_error) - /* "dnet.pyx":323 - * - * def ip_pack_hdr(tos=IP_TOS_DEFAULT, len=IP_HDR_LEN, id=0, off=0, - * ttl=IP_TTL_DEFAULT, p=IP_PROTO_IP, # <<<<<<<<<<<<<< - * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): - * """Return a packed binary string representing an IP header. + /* "dnet.pyx":94 + * ETH_TYPE_REVARP=0x8035 # /[inserted by cython to avoid comment start]* reverse addr resolution protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_TTL_DEFAULT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__10 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_PROTO_IP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__11 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_IPV6, __pyx_int_34525) < 0) __PYX_ERR(0, 94, __pyx_L1_error) - /* "dnet.pyx":324 - * def ip_pack_hdr(tos=IP_TOS_DEFAULT, len=IP_HDR_LEN, id=0, off=0, - * ttl=IP_TTL_DEFAULT, p=IP_PROTO_IP, - * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): # <<<<<<<<<<<<<< - * """Return a packed binary string representing an IP header. - * + /* "dnet.pyx":95 + * ETH_TYPE_8021Q =0x8100 # /[inserted by cython to avoid comment start]* IEEE 802.1Q VLAN tagging *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_ADDR_ANY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__12 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_ADDR_ANY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__13 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_MPLS, __pyx_int_34887) < 0) __PYX_ERR(0, 95, __pyx_L1_error) - /* "dnet.pyx":322 - * return __ip_cksum_carry(sum) - * - * def ip_pack_hdr(tos=IP_TOS_DEFAULT, len=IP_HDR_LEN, id=0, off=0, # <<<<<<<<<<<<<< - * ttl=IP_TTL_DEFAULT, p=IP_PROTO_IP, - * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): + /* "dnet.pyx":96 + * ETH_TYPE_IPV6 = 0x86DD # /[inserted by cython to avoid comment start]* IPv6 protocol *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_PPPOE = 0x8864 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Session Stage *[inserted by cython to avoid comment closer]/ */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_19ip_pack_hdr, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_pack_hdr, __pyx_t_3) < 0) __PYX_ERR(0, 322, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_MPLS_MCAST, __pyx_int_34888) < 0) __PYX_ERR(0, 96, __pyx_L1_error) - /* "dnet.pyx":357 - * int nxt, int hlim, ip6_addr_t s, ip6_addr_t d) - * - * IP6_ADDR_LEN = 16 # <<<<<<<<<<<<<< - * IP6_ADDR_BITS = 128 - * + /* "dnet.pyx":97 + * ETH_TYPE_MPLS = 0x8847 # /[inserted by cython to avoid comment start]* MPLS *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_PPPOE = 0x8864 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Session Stage *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_LOOPBACK = 0x9000 # /[inserted by cython to avoid comment start]* used to test interfaces *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_ADDR_LEN, __pyx_int_16) < 0) __PYX_ERR(0, 357, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_PPPOEDISC, __pyx_int_34915) < 0) __PYX_ERR(0, 97, __pyx_L1_error) - /* "dnet.pyx":358 - * - * IP6_ADDR_LEN = 16 - * IP6_ADDR_BITS = 128 # <<<<<<<<<<<<<< + /* "dnet.pyx":98 + * ETH_TYPE_MPLS_MCAST = 0x8848 # /[inserted by cython to avoid comment start]* MPLS Multicast *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_PPPOE = 0x8864 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Session Stage *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_TYPE_LOOPBACK = 0x9000 # /[inserted by cython to avoid comment start]* used to test interfaces *[inserted by cython to avoid comment closer]/ * - * IP6_HDR_LEN = 40 # /[inserted by cython to avoid comment start]* IPv6 header length *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_ADDR_BITS, __pyx_int_128) < 0) __PYX_ERR(0, 358, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_PPPOE, __pyx_int_34916) < 0) __PYX_ERR(0, 98, __pyx_L1_error) - /* "dnet.pyx":360 - * IP6_ADDR_BITS = 128 + /* "dnet.pyx":99 + * ETH_TYPE_PPPOEDISC = 0x8863 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Discovery Stage *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_PPPOE = 0x8864 # /[inserted by cython to avoid comment start]* PPP Over Ethernet Session Stage *[inserted by cython to avoid comment closer]/ + * ETH_TYPE_LOOPBACK = 0x9000 # /[inserted by cython to avoid comment start]* used to test interfaces *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< * - * IP6_HDR_LEN = 40 # /[inserted by cython to avoid comment start]* IPv6 header length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * IP6_LEN_MIN = IP6_HDR_LEN - * IP6_LEN_MAX = 65535 # /[inserted by cython to avoid comment start]* non-jumbo payload *[inserted by cython to avoid comment closer]/ + * ETH_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00", 6) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_HDR_LEN, __pyx_int_40) < 0) __PYX_ERR(0, 360, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_TYPE_LOOPBACK, __pyx_int_36864) < 0) __PYX_ERR(0, 99, __pyx_L1_error) - /* "dnet.pyx":361 - * - * IP6_HDR_LEN = 40 # /[inserted by cython to avoid comment start]* IPv6 header length *[inserted by cython to avoid comment closer]/ - * IP6_LEN_MIN = IP6_HDR_LEN # <<<<<<<<<<<<<< - * IP6_LEN_MAX = 65535 # /[inserted by cython to avoid comment start]* non-jumbo payload *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":101 + * ETH_TYPE_LOOPBACK = 0x9000 # /[inserted by cython to avoid comment start]* used to test interfaces *[inserted by cython to avoid comment closer]/ * - */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP6_HDR_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 361, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_LEN_MIN, __pyx_t_3) < 0) __PYX_ERR(0, 361, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; - - /* "dnet.pyx":362 - * IP6_HDR_LEN = 40 # /[inserted by cython to avoid comment start]* IPv6 header length *[inserted by cython to avoid comment closer]/ - * IP6_LEN_MIN = IP6_HDR_LEN - * IP6_LEN_MAX = 65535 # /[inserted by cython to avoid comment start]* non-jumbo payload *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00", 6) # <<<<<<<<<<<<<< + * ETH_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff\xff\xff", 6) * - * IP6_MTU_MIN = 1280 # /[inserted by cython to avoid comment start]* minimum MTU (1024 + 256) *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_LEN_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 362, __pyx_L1_error) + __pyx_t_2 = PyBytes_FromStringAndSize(((char *)"\000\000\000\000\000\000"), 6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_ADDR_UNSPEC, __pyx_t_2) < 0) __PYX_ERR(0, 101, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":364 - * IP6_LEN_MAX = 65535 # /[inserted by cython to avoid comment start]* non-jumbo payload *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":102 * - * IP6_MTU_MIN = 1280 # /[inserted by cython to avoid comment start]* minimum MTU (1024 + 256) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ETH_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00", 6) + * ETH_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff\xff\xff", 6) # <<<<<<<<<<<<<< * - * IP6_HLIM_DEFAULT=64 + * cdef class eth: */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_MTU_MIN, __pyx_int_1280) < 0) __PYX_ERR(0, 364, __pyx_L1_error) + __pyx_t_2 = PyBytes_FromStringAndSize(((char *)"\377\377\377\377\377\377"), 6); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ETH_ADDR_BROADCAST, __pyx_t_2) < 0) __PYX_ERR(0, 102, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":366 - * IP6_MTU_MIN = 1280 # /[inserted by cython to avoid comment start]* minimum MTU (1024 + 256) *[inserted by cython to avoid comment closer]/ - * - * IP6_HLIM_DEFAULT=64 # <<<<<<<<<<<<<< - * IP6_HLIM_MAX = 255 + /* "dnet.pyx":116 + * raise OSError, __oserror() * + * def get(self): # <<<<<<<<<<<<<< + * """Return the MAC address associated with the device as a + * binary string.""" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_HLIM_DEFAULT, __pyx_int_64) < 0) __PYX_ERR(0, 366, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3eth_3get, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_eth_get, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__7)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_eth, __pyx_n_s_get, __pyx_t_2) < 0) __PYX_ERR(0, 116, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_4dnet_eth); - /* "dnet.pyx":367 - * - * IP6_HLIM_DEFAULT=64 - * IP6_HLIM_MAX = 255 # <<<<<<<<<<<<<< + /* "dnet.pyx":124 + * return PyBytes_FromStringAndSize(ea.data, 6) * - * IP6_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16) + * def set(self, value): # <<<<<<<<<<<<<< + * """Set the MAC address for the device, returning 0 on success, + * -1 on failure. */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_HLIM_MAX, __pyx_int_255) < 0) __PYX_ERR(0, 367, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3eth_5set, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_eth_set, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_eth, __pyx_n_s_set, __pyx_t_2) < 0) __PYX_ERR(0, 124, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_4dnet_eth); - /* "dnet.pyx":369 - * IP6_HLIM_MAX = 255 - * - * IP6_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16) # <<<<<<<<<<<<<< - * IP6_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", 16) + /* "dnet.pyx":136 + * raise OSError, __oserror() * + * def send(self, frame): # <<<<<<<<<<<<<< + * """Send an Ethernet frame, returning the number of bytes sent + * or -1 on failure. */ - __pyx_t_3 = PyBytes_FromStringAndSize(((char *)"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"), 16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 369, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_ADDR_UNSPEC, __pyx_t_3) < 0) __PYX_ERR(0, 369, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3eth_7send, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_eth_send, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__11)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_eth, __pyx_n_s_send, __pyx_t_2) < 0) __PYX_ERR(0, 136, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + PyType_Modified(__pyx_ptype_4dnet_eth); - /* "dnet.pyx":370 - * - * IP6_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16) - * IP6_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", 16) # <<<<<<<<<<<<<< - * - * def ip6_ntoa(buf): + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): */ - __pyx_t_3 = PyBytes_FromStringAndSize(((char *)"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001"), 16); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 370, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_ADDR_LOOPBACK, __pyx_t_3) < 0) __PYX_ERR(0, 370, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3eth_11__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_eth___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__13)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_2) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":372 - * IP6_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", 16) - * - * def ip6_ntoa(buf): # <<<<<<<<<<<<<< - * """Convert an IPv6 address from a 16-byte packed binary string to a - * printable string ('10.0.0.1').""" + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.eth cannot be converted to a Python object for pickling" */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_21ip6_ntoa, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 372, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip6_ntoa, __pyx_t_3) < 0) __PYX_ERR(0, 372, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3eth_13__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_eth___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__15)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_2) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":379 - * return __ip6_ntoa(&ia) + /* "dnet.pyx":149 + * eth_close(self.eth) * - * def ip6_aton(buf): # <<<<<<<<<<<<<< - * """Convert an IPv6 address from a printable string to a - * packed binary string ('\\x0a\\x00\\x00\\x01').""" + * def eth_ntoa(buf): # <<<<<<<<<<<<<< + * """Convert an Ethernet MAC address from 6-byte packed binary string to + * a printable string ('00:de:ad:be:ef:00').""" */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_23ip6_aton, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 379, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip6_aton, __pyx_t_3) < 0) __PYX_ERR(0, 379, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3eth_ntoa, 0, __pyx_n_s_eth_ntoa, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__17)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_eth_ntoa, __pyx_t_2) < 0) __PYX_ERR(0, 149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":387 - * return PyBytes_FromStringAndSize(&ia, 16) + /* "dnet.pyx":156 + * return __eth_ntoa(&ea) * - * def ip6_checksum(buf): # <<<<<<<<<<<<<< - * """Return a packed binary string representing an IPv6 packet - * with the IPv6 and transport-layer checksums set. + * def eth_aton(buf): # <<<<<<<<<<<<<< + * """Convert an Ethernet MAC address from a printable string to a + * packed binary string ('\\x00\\xde\\xad\\xbe\\xef\\x00').""" */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_25ip6_checksum, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 387, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip6_checksum, __pyx_t_3) < 0) __PYX_ERR(0, 387, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_5eth_aton, 0, __pyx_n_s_eth_aton, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__18)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_eth_aton, __pyx_t_2) < 0) __PYX_ERR(0, 156, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":397 - * return buf + /* "dnet.pyx":164 + * return PyBytes_FromStringAndSize(ea.data, 6) * - * def ip6_pack_hdr(fc=0, fl=0, plen=0, nxt=IP_PROTO_IPV6, hlim=IP6_HLIM_DEFAULT, # <<<<<<<<<<<<<< - * src=IP6_ADDR_UNSPEC, dst=IP6_ADDR_UNSPEC): - * """Return a packed binary string representing an IPv6 header. + * def eth_pack_hdr(dst=ETH_ADDR_BROADCAST, src=ETH_ADDR_BROADCAST, # <<<<<<<<<<<<<< + * etype=ETH_TYPE_IP): + * """Return a packed binary string representing an Ethernet header. */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_PROTO_IPV6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error) + __pyx_t_2 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_7eth_pack_hdr, 0, __pyx_n_s_eth_pack_hdr, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__20)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_2, sizeof(__pyx_defaults), 3)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_ADDR_BROADCAST); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_k__14 = __pyx_t_3; + __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_2)->__pyx_arg_dst = __pyx_t_3; __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP6_HLIM_DEFAULT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_ADDR_BROADCAST); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 164, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_k__15 = __pyx_t_3; + __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_2)->__pyx_arg_src = __pyx_t_3; __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dnet.pyx":398 + /* "dnet.pyx":165 * - * def ip6_pack_hdr(fc=0, fl=0, plen=0, nxt=IP_PROTO_IPV6, hlim=IP6_HLIM_DEFAULT, - * src=IP6_ADDR_UNSPEC, dst=IP6_ADDR_UNSPEC): # <<<<<<<<<<<<<< - * """Return a packed binary string representing an IPv6 header. + * def eth_pack_hdr(dst=ETH_ADDR_BROADCAST, src=ETH_ADDR_BROADCAST, + * etype=ETH_TYPE_IP): # <<<<<<<<<<<<<< + * """Return a packed binary string representing an Ethernet header. * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP6_ADDR_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 398, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__16 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP6_ADDR_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_TYPE_IP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 165, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_k__17 = __pyx_t_3; + __Pyx_CyFunction_Defaults(__pyx_defaults, __pyx_t_2)->__pyx_arg_etype = __pyx_t_3; __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_2, __pyx_pf_4dnet_38__defaults__); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_eth_pack_hdr, __pyx_t_2) < 0) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; - /* "dnet.pyx":397 - * return buf + /* "dnet.pyx":201 + * int off, int ttl, int p, ip_addr_t s, ip_addr_t d) + * + * IP_ADDR_LEN = 4 # /[inserted by cython to avoid comment start]* IP address length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_ADDR_BITS = 32 # /[inserted by cython to avoid comment start]* IP address bits *[inserted by cython to avoid comment closer]/ * - * def ip6_pack_hdr(fc=0, fl=0, plen=0, nxt=IP_PROTO_IPV6, hlim=IP6_HLIM_DEFAULT, # <<<<<<<<<<<<<< - * src=IP6_ADDR_UNSPEC, dst=IP6_ADDR_UNSPEC): - * """Return a packed binary string representing an IPv6 header. */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_27ip6_pack_hdr, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip6_pack_hdr, __pyx_t_3) < 0) __PYX_ERR(0, 397, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_LEN, __pyx_int_4) < 0) __PYX_ERR(0, 201, __pyx_L1_error) - /* "dnet.pyx":433 - * int addr_aton(char *src, addr_t *dst) + /* "dnet.pyx":202 * - * ADDR_TYPE_NONE = 0 # <<<<<<<<<<<<<< - * ADDR_TYPE_ETH = 1 - * ADDR_TYPE_IP = 2 + * IP_ADDR_LEN = 4 # /[inserted by cython to avoid comment start]* IP address length *[inserted by cython to avoid comment closer]/ + * IP_ADDR_BITS = 32 # /[inserted by cython to avoid comment start]* IP address bits *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * IP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base IP header length *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADDR_TYPE_NONE, __pyx_int_0) < 0) __PYX_ERR(0, 433, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_BITS, __pyx_int_32) < 0) __PYX_ERR(0, 202, __pyx_L1_error) - /* "dnet.pyx":434 + /* "dnet.pyx":204 + * IP_ADDR_BITS = 32 # /[inserted by cython to avoid comment start]* IP address bits *[inserted by cython to avoid comment closer]/ * - * ADDR_TYPE_NONE = 0 - * ADDR_TYPE_ETH = 1 # <<<<<<<<<<<<<< - * ADDR_TYPE_IP = 2 - * ADDR_TYPE_IP6 = 3 + * IP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base IP header length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_OPT_LEN = 2 # /[inserted by cython to avoid comment start]* base IP option length *[inserted by cython to avoid comment closer]/ + * IP_OPT_LEN_MAX =40 */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADDR_TYPE_ETH, __pyx_int_1) < 0) __PYX_ERR(0, 434, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_HDR_LEN, __pyx_int_20) < 0) __PYX_ERR(0, 204, __pyx_L1_error) - /* "dnet.pyx":435 - * ADDR_TYPE_NONE = 0 - * ADDR_TYPE_ETH = 1 - * ADDR_TYPE_IP = 2 # <<<<<<<<<<<<<< - * ADDR_TYPE_IP6 = 3 + /* "dnet.pyx":205 * + * IP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base IP header length *[inserted by cython to avoid comment closer]/ + * IP_OPT_LEN = 2 # /[inserted by cython to avoid comment start]* base IP option length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_OPT_LEN_MAX =40 + * IP_HDR_LEN_MAX =(IP_HDR_LEN + IP_OPT_LEN_MAX) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADDR_TYPE_IP, __pyx_int_2) < 0) __PYX_ERR(0, 435, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_OPT_LEN, __pyx_int_2) < 0) __PYX_ERR(0, 205, __pyx_L1_error) - /* "dnet.pyx":436 - * ADDR_TYPE_ETH = 1 - * ADDR_TYPE_IP = 2 - * ADDR_TYPE_IP6 = 3 # <<<<<<<<<<<<<< + /* "dnet.pyx":206 + * IP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base IP header length *[inserted by cython to avoid comment closer]/ + * IP_OPT_LEN = 2 # /[inserted by cython to avoid comment start]* base IP option length *[inserted by cython to avoid comment closer]/ + * IP_OPT_LEN_MAX =40 # <<<<<<<<<<<<<< + * IP_HDR_LEN_MAX =(IP_HDR_LEN + IP_OPT_LEN_MAX) * - * cdef class addr: */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADDR_TYPE_IP6, __pyx_int_3) < 0) __PYX_ERR(0, 436, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_OPT_LEN_MAX, __pyx_int_40) < 0) __PYX_ERR(0, 206, __pyx_L1_error) - /* "dnet.pyx":446 - * cdef addr_t _addr + /* "dnet.pyx":207 + * IP_OPT_LEN = 2 # /[inserted by cython to avoid comment start]* base IP option length *[inserted by cython to avoid comment closer]/ + * IP_OPT_LEN_MAX =40 + * IP_HDR_LEN_MAX =(IP_HDR_LEN + IP_OPT_LEN_MAX) # <<<<<<<<<<<<<< * - * def __init__(self, addrtxt=None, addrtype=ADDR_TYPE_NONE): # <<<<<<<<<<<<<< - * if addrtxt != None and addr_aton(addrtxt, &self._addr) < 0: - * if PyBytes_Size(addrtxt) == 4: + * IP_LEN_MAX = 65535 */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ADDR_TYPE_NONE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_n_s_IP_HDR_LEN); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_OPT_LEN_MAX); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 207, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_k__18 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; + __pyx_t_4 = PyNumber_Add(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_HDR_LEN_MAX, __pyx_t_4) < 0) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":677 - * eth_addr_t dha, ip_addr_t dpa) + /* "dnet.pyx":209 + * IP_HDR_LEN_MAX =(IP_HDR_LEN + IP_OPT_LEN_MAX) * - * ARP_HDR_LEN = 8 # /[inserted by cython to avoid comment start]* base ARP header length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ARP_ETHIP_LEN = 20 # /[inserted by cython to avoid comment start]* base ARP message length *[inserted by cython to avoid comment closer]/ + * IP_LEN_MAX = 65535 # <<<<<<<<<<<<<< + * IP_LEN_MIN = IP_HDR_LEN * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_HDR_LEN, __pyx_int_8) < 0) __PYX_ERR(0, 677, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_LEN_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 209, __pyx_L1_error) - /* "dnet.pyx":678 + /* "dnet.pyx":210 * - * ARP_HDR_LEN = 8 # /[inserted by cython to avoid comment start]* base ARP header length *[inserted by cython to avoid comment closer]/ - * ARP_ETHIP_LEN = 20 # /[inserted by cython to avoid comment start]* base ARP message length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_LEN_MAX = 65535 + * IP_LEN_MIN = IP_HDR_LEN # <<<<<<<<<<<<<< * - * ARP_HRD_ETH = 0x0001 # /[inserted by cython to avoid comment start]* ethernet hardware *[inserted by cython to avoid comment closer]/ + * IP_TOS_DEFAULT =0x00 # /[inserted by cython to avoid comment start]* default *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_ETHIP_LEN, __pyx_int_20) < 0) __PYX_ERR(0, 678, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_IP_HDR_LEN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_LEN_MIN, __pyx_t_4) < 0) __PYX_ERR(0, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":680 - * ARP_ETHIP_LEN = 20 # /[inserted by cython to avoid comment start]* base ARP message length *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":212 + * IP_LEN_MIN = IP_HDR_LEN * - * ARP_HRD_ETH = 0x0001 # /[inserted by cython to avoid comment start]* ethernet hardware *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ARP_HRD_IEEE802=0x0006 # /[inserted by cython to avoid comment start]* IEEE 802 hardware *[inserted by cython to avoid comment closer]/ + * IP_TOS_DEFAULT =0x00 # /[inserted by cython to avoid comment start]* default *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< * + * IP_RF = 0x8000 # /[inserted by cython to avoid comment start]* reserved *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_HRD_ETH, __pyx_int_1) < 0) __PYX_ERR(0, 680, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_TOS_DEFAULT, __pyx_int_0) < 0) __PYX_ERR(0, 212, __pyx_L1_error) - /* "dnet.pyx":681 - * - * ARP_HRD_ETH = 0x0001 # /[inserted by cython to avoid comment start]* ethernet hardware *[inserted by cython to avoid comment closer]/ - * ARP_HRD_IEEE802=0x0006 # /[inserted by cython to avoid comment start]* IEEE 802 hardware *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + /* "dnet.pyx":214 + * IP_TOS_DEFAULT =0x00 # /[inserted by cython to avoid comment start]* default *[inserted by cython to avoid comment closer]/ * - * ARP_PRO_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ + * IP_RF = 0x8000 # /[inserted by cython to avoid comment start]* reserved *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_DF = 0x4000 # /[inserted by cython to avoid comment start]* don't fragment *[inserted by cython to avoid comment closer]/ + * IP_MF = 0x2000 # /[inserted by cython to avoid comment start]* more fragments (not last frag) *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_HRD_IEEE802, __pyx_int_6) < 0) __PYX_ERR(0, 681, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_RF, __pyx_int_32768) < 0) __PYX_ERR(0, 214, __pyx_L1_error) - /* "dnet.pyx":683 - * ARP_HRD_IEEE802=0x0006 # /[inserted by cython to avoid comment start]* IEEE 802 hardware *[inserted by cython to avoid comment closer]/ - * - * ARP_PRO_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + /* "dnet.pyx":215 * - * ARP_OP_REQUEST = 1 # /[inserted by cython to avoid comment start]* request to resolve ha given pa *[inserted by cython to avoid comment closer]/ + * IP_RF = 0x8000 # /[inserted by cython to avoid comment start]* reserved *[inserted by cython to avoid comment closer]/ + * IP_DF = 0x4000 # /[inserted by cython to avoid comment start]* don't fragment *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_MF = 0x2000 # /[inserted by cython to avoid comment start]* more fragments (not last frag) *[inserted by cython to avoid comment closer]/ + * IP_OFFMASK = 0x1fff # /[inserted by cython to avoid comment start]* mask for fragment offset *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_PRO_IP, __pyx_int_2048) < 0) __PYX_ERR(0, 683, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_DF, __pyx_int_16384) < 0) __PYX_ERR(0, 215, __pyx_L1_error) - /* "dnet.pyx":685 - * ARP_PRO_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":216 + * IP_RF = 0x8000 # /[inserted by cython to avoid comment start]* reserved *[inserted by cython to avoid comment closer]/ + * IP_DF = 0x4000 # /[inserted by cython to avoid comment start]* don't fragment *[inserted by cython to avoid comment closer]/ + * IP_MF = 0x2000 # /[inserted by cython to avoid comment start]* more fragments (not last frag) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_OFFMASK = 0x1fff # /[inserted by cython to avoid comment start]* mask for fragment offset *[inserted by cython to avoid comment closer]/ * - * ARP_OP_REQUEST = 1 # /[inserted by cython to avoid comment start]* request to resolve ha given pa *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ARP_OP_REPLY = 2 # /[inserted by cython to avoid comment start]* response giving hardware address *[inserted by cython to avoid comment closer]/ - * ARP_OP_REVREQUEST = 3 # /[inserted by cython to avoid comment start]* request to resolve pa given ha *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_OP_REQUEST, __pyx_int_1) < 0) __PYX_ERR(0, 685, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_MF, __pyx_int_8192) < 0) __PYX_ERR(0, 216, __pyx_L1_error) - /* "dnet.pyx":686 + /* "dnet.pyx":217 + * IP_DF = 0x4000 # /[inserted by cython to avoid comment start]* don't fragment *[inserted by cython to avoid comment closer]/ + * IP_MF = 0x2000 # /[inserted by cython to avoid comment start]* more fragments (not last frag) *[inserted by cython to avoid comment closer]/ + * IP_OFFMASK = 0x1fff # /[inserted by cython to avoid comment start]* mask for fragment offset *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< * - * ARP_OP_REQUEST = 1 # /[inserted by cython to avoid comment start]* request to resolve ha given pa *[inserted by cython to avoid comment closer]/ - * ARP_OP_REPLY = 2 # /[inserted by cython to avoid comment start]* response giving hardware address *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ARP_OP_REVREQUEST = 3 # /[inserted by cython to avoid comment start]* request to resolve pa given ha *[inserted by cython to avoid comment closer]/ - * ARP_OP_REVREPLY = 4 # /[inserted by cython to avoid comment start]* response giving protocol address *[inserted by cython to avoid comment closer]/ + * IP_TTL_DEFAULT =64 # /[inserted by cython to avoid comment start]* default ttl, RFC 1122, RFC 1340 *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_OP_REPLY, __pyx_int_2) < 0) __PYX_ERR(0, 686, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_OFFMASK, __pyx_int_8191) < 0) __PYX_ERR(0, 217, __pyx_L1_error) - /* "dnet.pyx":687 - * ARP_OP_REQUEST = 1 # /[inserted by cython to avoid comment start]* request to resolve ha given pa *[inserted by cython to avoid comment closer]/ - * ARP_OP_REPLY = 2 # /[inserted by cython to avoid comment start]* response giving hardware address *[inserted by cython to avoid comment closer]/ - * ARP_OP_REVREQUEST = 3 # /[inserted by cython to avoid comment start]* request to resolve pa given ha *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * ARP_OP_REVREPLY = 4 # /[inserted by cython to avoid comment start]* response giving protocol address *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":219 + * IP_OFFMASK = 0x1fff # /[inserted by cython to avoid comment start]* mask for fragment offset *[inserted by cython to avoid comment closer]/ * - */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_OP_REVREQUEST, __pyx_int_3) < 0) __PYX_ERR(0, 687, __pyx_L1_error) - - /* "dnet.pyx":688 - * ARP_OP_REPLY = 2 # /[inserted by cython to avoid comment start]* response giving hardware address *[inserted by cython to avoid comment closer]/ - * ARP_OP_REVREQUEST = 3 # /[inserted by cython to avoid comment start]* request to resolve pa given ha *[inserted by cython to avoid comment closer]/ - * ARP_OP_REVREPLY = 4 # /[inserted by cython to avoid comment start]* response giving protocol address *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_TTL_DEFAULT =64 # /[inserted by cython to avoid comment start]* default ttl, RFC 1122, RFC 1340 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_TTL_MAX = 255 # /[inserted by cython to avoid comment start]* maximum ttl *[inserted by cython to avoid comment closer]/ * - * cdef int __arp_callback(arp_entry *entry, void *arg) except -1: */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_OP_REVREPLY, __pyx_int_4) < 0) __PYX_ERR(0, 688, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_TTL_DEFAULT, __pyx_int_64) < 0) __PYX_ERR(0, 219, __pyx_L1_error) - /* "dnet.pyx":771 - * arp_close(self.arp) + /* "dnet.pyx":220 * - * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, # <<<<<<<<<<<<<< - * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, - * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): - */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ARP_OP_REQUEST); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 771, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__23 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - - /* "dnet.pyx":772 + * IP_TTL_DEFAULT =64 # /[inserted by cython to avoid comment start]* default ttl, RFC 1122, RFC 1340 *[inserted by cython to avoid comment closer]/ + * IP_TTL_MAX = 255 # /[inserted by cython to avoid comment start]* maximum ttl *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< * - * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, - * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, # <<<<<<<<<<<<<< - * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): - * """Return a packed binary string representing an Ethernet/IP ARP message. + * IP_PROTO_IP = 0 # /[inserted by cython to avoid comment start]* dummy for IP *[inserted by cython to avoid comment closer]/ */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_ADDR_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 772, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__24 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_ADDR_ANY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 772, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__25 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_TTL_MAX, __pyx_int_255) < 0) __PYX_ERR(0, 220, __pyx_L1_error) - /* "dnet.pyx":773 - * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, - * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, - * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): # <<<<<<<<<<<<<< - * """Return a packed binary string representing an Ethernet/IP ARP message. + /* "dnet.pyx":222 + * IP_TTL_MAX = 255 # /[inserted by cython to avoid comment start]* maximum ttl *[inserted by cython to avoid comment closer]/ * + * IP_PROTO_IP = 0 # /[inserted by cython to avoid comment start]* dummy for IP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_ICMP = 1 # /[inserted by cython to avoid comment start]* ICMP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_ADDR_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 773, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__26 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_ADDR_ANY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 773, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__27 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_IP, __pyx_int_0) < 0) __PYX_ERR(0, 222, __pyx_L1_error) - /* "dnet.pyx":771 - * arp_close(self.arp) + /* "dnet.pyx":223 * - * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, # <<<<<<<<<<<<<< - * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, - * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): + * IP_PROTO_IP = 0 # /[inserted by cython to avoid comment start]* dummy for IP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_ICMP = 1 # /[inserted by cython to avoid comment start]* ICMP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_29arp_pack_hdr_ethip, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 771, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_arp_pack_hdr_ethip, __pyx_t_3) < 0) __PYX_ERR(0, 771, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_ICMP, __pyx_int_1) < 0) __PYX_ERR(0, 223, __pyx_L1_error) - /* "dnet.pyx":799 - * void __icmp_pack_hdr "icmp_pack_hdr" (char *hdr, int type, int code) - * - * def icmp_pack_hdr(itype, code): # <<<<<<<<<<<<<< - * """Return a packed binary string representing an ICMP header. - * + /* "dnet.pyx":224 + * IP_PROTO_IP = 0 # /[inserted by cython to avoid comment start]* dummy for IP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_ICMP = 1 # /[inserted by cython to avoid comment start]* ICMP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_31icmp_pack_hdr, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 799, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_icmp_pack_hdr, __pyx_t_3) < 0) __PYX_ERR(0, 799, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_IGMP, __pyx_int_2) < 0) __PYX_ERR(0, 224, __pyx_L1_error) - /* "dnet.pyx":817 - * int sport, int dport, unsigned long seq, unsigned long ack, int flags, int win, int urp) - * - * TCP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base TCP header length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * - * TH_FIN = 0x01 # /[inserted by cython to avoid comment start]* end of data *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":225 + * IP_PROTO_ICMP = 1 # /[inserted by cython to avoid comment start]* ICMP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_HDR_LEN, __pyx_int_20) < 0) __PYX_ERR(0, 817, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_TCP, __pyx_int_6) < 0) __PYX_ERR(0, 225, __pyx_L1_error) - /* "dnet.pyx":819 - * TCP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base TCP header length *[inserted by cython to avoid comment closer]/ - * - * TH_FIN = 0x01 # /[inserted by cython to avoid comment start]* end of data *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TH_SYN = 0x02 # /[inserted by cython to avoid comment start]* synchronize sequence numbers *[inserted by cython to avoid comment closer]/ - * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":226 + * IP_PROTO_IGMP = 2 # /[inserted by cython to avoid comment start]* IGMP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ + * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_FIN, __pyx_int_1) < 0) __PYX_ERR(0, 819, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_UDP, __pyx_int_17) < 0) __PYX_ERR(0, 226, __pyx_L1_error) - /* "dnet.pyx":820 - * - * TH_FIN = 0x01 # /[inserted by cython to avoid comment start]* end of data *[inserted by cython to avoid comment closer]/ - * TH_SYN = 0x02 # /[inserted by cython to avoid comment start]* synchronize sequence numbers *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ - * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":227 + * IP_PROTO_TCP = 6 # /[inserted by cython to avoid comment start]* TCP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ + * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_SYN, __pyx_int_2) < 0) __PYX_ERR(0, 820, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_IPV6, __pyx_int_41) < 0) __PYX_ERR(0, 227, __pyx_L1_error) - /* "dnet.pyx":821 - * TH_FIN = 0x01 # /[inserted by cython to avoid comment start]* end of data *[inserted by cython to avoid comment closer]/ - * TH_SYN = 0x02 # /[inserted by cython to avoid comment start]* synchronize sequence numbers *[inserted by cython to avoid comment closer]/ - * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ - * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":228 + * IP_PROTO_UDP = 17 # /[inserted by cython to avoid comment start]* UDP *[inserted by cython to avoid comment closer]/ + * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ + * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ + * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_RST, __pyx_int_4) < 0) __PYX_ERR(0, 821, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_GRE, __pyx_int_47) < 0) __PYX_ERR(0, 228, __pyx_L1_error) - /* "dnet.pyx":822 - * TH_SYN = 0x02 # /[inserted by cython to avoid comment start]* synchronize sequence numbers *[inserted by cython to avoid comment closer]/ - * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ - * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ - * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":229 + * IP_PROTO_IPV6 = 41 # /[inserted by cython to avoid comment start]* IPv6 *[inserted by cython to avoid comment closer]/ + * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ + * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ + * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_PUSH, __pyx_int_8) < 0) __PYX_ERR(0, 822, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_ESP, __pyx_int_50) < 0) __PYX_ERR(0, 229, __pyx_L1_error) - /* "dnet.pyx":823 - * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ - * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ - * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ - * TH_ECE = 0x40 # /[inserted by cython to avoid comment start]* ECN echo, RFC 3168 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":230 + * IP_PROTO_GRE = 47 # /[inserted by cython to avoid comment start]* General Routing Encap *[inserted by cython to avoid comment closer]/ + * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ + * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ + * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_ACK, __pyx_int_16) < 0) __PYX_ERR(0, 823, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_AH, __pyx_int_51) < 0) __PYX_ERR(0, 230, __pyx_L1_error) - /* "dnet.pyx":824 - * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ - * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ - * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TH_ECE = 0x40 # /[inserted by cython to avoid comment start]* ECN echo, RFC 3168 *[inserted by cython to avoid comment closer]/ - * TH_CWR = 0x80 # /[inserted by cython to avoid comment start]* congestion window reduced *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":231 + * IP_PROTO_ESP = 50 # /[inserted by cython to avoid comment start]* Encap Security Payload *[inserted by cython to avoid comment closer]/ + * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ + * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ + * IP_PROTO_RESERVED = IP_PROTO_RAW # /[inserted by cython to avoid comment start]* Reserved *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_URG, __pyx_int_32) < 0) __PYX_ERR(0, 824, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_ICMPV6, __pyx_int_58) < 0) __PYX_ERR(0, 231, __pyx_L1_error) - /* "dnet.pyx":825 - * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ - * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ - * TH_ECE = 0x40 # /[inserted by cython to avoid comment start]* ECN echo, RFC 3168 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TH_CWR = 0x80 # /[inserted by cython to avoid comment start]* congestion window reduced *[inserted by cython to avoid comment closer]/ - * + /* "dnet.pyx":232 + * IP_PROTO_AH = 51 # /[inserted by cython to avoid comment start]* Authentication Header *[inserted by cython to avoid comment closer]/ + * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ + * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_RESERVED = IP_PROTO_RAW # /[inserted by cython to avoid comment start]* Reserved *[inserted by cython to avoid comment closer]/ + * IP_PROTO_MAX = 255 */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_ECE, __pyx_int_64) < 0) __PYX_ERR(0, 825, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_RAW, __pyx_int_255) < 0) __PYX_ERR(0, 232, __pyx_L1_error) - /* "dnet.pyx":826 - * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ - * TH_ECE = 0x40 # /[inserted by cython to avoid comment start]* ECN echo, RFC 3168 *[inserted by cython to avoid comment closer]/ - * TH_CWR = 0x80 # /[inserted by cython to avoid comment start]* congestion window reduced *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + /* "dnet.pyx":233 + * IP_PROTO_ICMPV6 = 58 # /[inserted by cython to avoid comment start]* ICMP for IPv6 *[inserted by cython to avoid comment closer]/ + * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ + * IP_PROTO_RESERVED = IP_PROTO_RAW # /[inserted by cython to avoid comment start]* Reserved *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP_PROTO_MAX = 255 * - * TCP_PORT_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum port *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_CWR, __pyx_int_128) < 0) __PYX_ERR(0, 826, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_IP_PROTO_RAW); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_RESERVED, __pyx_t_4) < 0) __PYX_ERR(0, 233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":828 - * TH_CWR = 0x80 # /[inserted by cython to avoid comment start]* congestion window reduced *[inserted by cython to avoid comment closer]/ - * - * TCP_PORT_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum port *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_WIN_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum (unscaled) window *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":234 + * IP_PROTO_RAW = 255 # /[inserted by cython to avoid comment start]* Raw IP packets *[inserted by cython to avoid comment closer]/ + * IP_PROTO_RESERVED = IP_PROTO_RAW # /[inserted by cython to avoid comment start]* Reserved *[inserted by cython to avoid comment closer]/ + * IP_PROTO_MAX = 255 # <<<<<<<<<<<<<< * + * IP_ADDR_ANY = PyBytes_FromStringAndSize("\x00\x00\x00\x00", 4) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_PORT_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 828, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_PROTO_MAX, __pyx_int_255) < 0) __PYX_ERR(0, 234, __pyx_L1_error) - /* "dnet.pyx":829 - * - * TCP_PORT_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum port *[inserted by cython to avoid comment closer]/ - * TCP_WIN_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum (unscaled) window *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + /* "dnet.pyx":236 + * IP_PROTO_MAX = 255 * - * TCP_OPT_EOL = 0 # /[inserted by cython to avoid comment start]* end of option list *[inserted by cython to avoid comment closer]/ + * IP_ADDR_ANY = PyBytes_FromStringAndSize("\x00\x00\x00\x00", 4) # <<<<<<<<<<<<<< + * IP_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff", 4) + * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_WIN_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 829, __pyx_L1_error) + __pyx_t_4 = PyBytes_FromStringAndSize(((char *)"\000\000\000\000"), 4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_ANY, __pyx_t_4) < 0) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":831 - * TCP_WIN_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum (unscaled) window *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":237 * - * TCP_OPT_EOL = 0 # /[inserted by cython to avoid comment start]* end of option list *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_NOP = 1 # /[inserted by cython to avoid comment start]* no operation *[inserted by cython to avoid comment closer]/ - * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ + * IP_ADDR_ANY = PyBytes_FromStringAndSize("\x00\x00\x00\x00", 4) + * IP_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff", 4) # <<<<<<<<<<<<<< + * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) + * IP_ADDR_MCAST_ALL = PyBytes_FromStringAndSize("\xe0\x00\x00\x01", 4) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_EOL, __pyx_int_0) < 0) __PYX_ERR(0, 831, __pyx_L1_error) + __pyx_t_4 = PyBytes_FromStringAndSize(((char *)"\377\377\377\377"), 4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_BROADCAST, __pyx_t_4) < 0) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":832 - * - * TCP_OPT_EOL = 0 # /[inserted by cython to avoid comment start]* end of option list *[inserted by cython to avoid comment closer]/ - * TCP_OPT_NOP = 1 # /[inserted by cython to avoid comment start]* no operation *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ - * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":238 + * IP_ADDR_ANY = PyBytes_FromStringAndSize("\x00\x00\x00\x00", 4) + * IP_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff", 4) + * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) # <<<<<<<<<<<<<< + * IP_ADDR_MCAST_ALL = PyBytes_FromStringAndSize("\xe0\x00\x00\x01", 4) + * IP_ADDR_MCAST_LOCAL = PyBytes_FromStringAndSize("\xe0\x00\x00\xff", 4) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_NOP, __pyx_int_1) < 0) __PYX_ERR(0, 832, __pyx_L1_error) + __pyx_t_4 = PyBytes_FromStringAndSize(((char *)"\000\000\001"), 4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_LOOPBACK, __pyx_t_4) < 0) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":833 - * TCP_OPT_EOL = 0 # /[inserted by cython to avoid comment start]* end of option list *[inserted by cython to avoid comment closer]/ - * TCP_OPT_NOP = 1 # /[inserted by cython to avoid comment start]* no operation *[inserted by cython to avoid comment closer]/ - * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":239 + * IP_ADDR_BROADCAST = PyBytes_FromStringAndSize("\xff\xff\xff\xff", 4) + * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) + * IP_ADDR_MCAST_ALL = PyBytes_FromStringAndSize("\xe0\x00\x00\x01", 4) # <<<<<<<<<<<<<< + * IP_ADDR_MCAST_LOCAL = PyBytes_FromStringAndSize("\xe0\x00\x00\xff", 4) + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_MSS, __pyx_int_2) < 0) __PYX_ERR(0, 833, __pyx_L1_error) + __pyx_t_4 = PyBytes_FromStringAndSize(((char *)"\340\000\000\001"), 4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_MCAST_ALL, __pyx_t_4) < 0) __PYX_ERR(0, 239, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":834 - * TCP_OPT_NOP = 1 # /[inserted by cython to avoid comment start]* no operation *[inserted by cython to avoid comment closer]/ - * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ - * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":240 + * IP_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x7f\x00\x00\x01", 4) + * IP_ADDR_MCAST_ALL = PyBytes_FromStringAndSize("\xe0\x00\x00\x01", 4) + * IP_ADDR_MCAST_LOCAL = PyBytes_FromStringAndSize("\xe0\x00\x00\xff", 4) # <<<<<<<<<<<<<< + * + * cdef class ip: */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_WSCALE, __pyx_int_3) < 0) __PYX_ERR(0, 834, __pyx_L1_error) + __pyx_t_4 = PyBytes_FromStringAndSize(((char *)"\340\000\000\377"), 4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP_ADDR_MCAST_LOCAL, __pyx_t_4) < 0) __PYX_ERR(0, 240, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":835 - * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ - * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":254 + * raise OSError, __oserror() + * + * def send(self, pkt): # <<<<<<<<<<<<<< + * """Send an IP packet, returning the number of bytes sent + * or -1 on failure. */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SACKOK, __pyx_int_4) < 0) __PYX_ERR(0, 835, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_2ip_3send, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ip_send, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__22)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_ip, __pyx_n_s_send, __pyx_t_4) < 0) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_ip); - /* "dnet.pyx":836 - * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SACK, __pyx_int_5) < 0) __PYX_ERR(0, 836, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_2ip_7__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ip___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__23)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":837 - * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.ip cannot be converted to a Python object for pickling" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_ECHO, __pyx_int_6) < 0) __PYX_ERR(0, 837, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_2ip_9__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_ip___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__24)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":838 - * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":267 + * ip_close(self.ip) + * + * def ip_ntoa(buf): # <<<<<<<<<<<<<< + * """Convert an IP address from a 4-byte packed binary string or + * integer to a printable string ('10.0.0.1').""" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_ECHOREPLY, __pyx_int_7) < 0) __PYX_ERR(0, 838, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_9ip_ntoa, 0, __pyx_n_s_ip_ntoa, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__26)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_ntoa, __pyx_t_4) < 0) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":839 - * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":280 + * return __ip_ntoa(&ia) + * + * def ip_aton(buf): # <<<<<<<<<<<<<< + * """Convert an IP address from a printable string to a + * packed binary string ('\\x0a\\x00\\x00\\x01').""" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_TIMESTAMP, __pyx_int_8) < 0) __PYX_ERR(0, 839, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_11ip_aton, 0, __pyx_n_s_ip_aton, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__28)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_aton, __pyx_t_4) < 0) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":840 - * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":288 + * return PyBytes_FromStringAndSize(&ia, 4) + * + * def ip_checksum(pkt): # <<<<<<<<<<<<<< + * """Return packed binary string representing an IP packet + * with the IP and transport-layer checksums set. */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_POCONN, __pyx_int_9) < 0) __PYX_ERR(0, 840, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_13ip_checksum, 0, __pyx_n_s_ip_checksum, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__30)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_checksum, __pyx_t_4) < 0) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":841 - * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":311 + * raise TypeError + * + * def ip_cksum_add(buf, int sum): # <<<<<<<<<<<<<< + * cdef char *p + * cdef int n */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_POSVC, __pyx_int_10) < 0) __PYX_ERR(0, 841, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_15ip_cksum_add, 0, __pyx_n_s_ip_cksum_add, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__32)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 311, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_cksum_add, __pyx_t_4) < 0) __PYX_ERR(0, 311, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":842 - * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":319 + * raise TypeError + * + * def ip_cksum_carry(int sum): # <<<<<<<<<<<<<< + * return __ip_cksum_carry(sum) + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_CC, __pyx_int_11) < 0) __PYX_ERR(0, 842, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_17ip_cksum_carry, 0, __pyx_n_s_ip_cksum_carry, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__34)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_cksum_carry, __pyx_t_4) < 0) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":843 - * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":322 + * return __ip_cksum_carry(sum) + * + * def ip_pack_hdr(tos=IP_TOS_DEFAULT, len=IP_HDR_LEN, id=0, off=0, # <<<<<<<<<<<<<< + * ttl=IP_TTL_DEFAULT, p=IP_PROTO_IP, + * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_CCNEW, __pyx_int_12) < 0) __PYX_ERR(0, 843, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_19ip_pack_hdr, 0, __pyx_n_s_ip_pack_hdr, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__36)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, sizeof(__pyx_defaults1), 6)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_TOS_DEFAULT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_t_4)->__pyx_arg_tos = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_HDR_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_t_4)->__pyx_arg_len = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; - /* "dnet.pyx":844 - * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":323 + * + * def ip_pack_hdr(tos=IP_TOS_DEFAULT, len=IP_HDR_LEN, id=0, off=0, + * ttl=IP_TTL_DEFAULT, p=IP_PROTO_IP, # <<<<<<<<<<<<<< + * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): + * """Return a packed binary string representing an IP header. */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_CCECHO, __pyx_int_13) < 0) __PYX_ERR(0, 844, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_TTL_DEFAULT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_t_4)->__pyx_arg_ttl = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_PROTO_IP); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 323, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_t_4)->__pyx_arg_p = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; - /* "dnet.pyx":845 - * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":324 + * def ip_pack_hdr(tos=IP_TOS_DEFAULT, len=IP_HDR_LEN, id=0, off=0, + * ttl=IP_TTL_DEFAULT, p=IP_PROTO_IP, + * src=IP_ADDR_ANY, dst=IP_ADDR_ANY): # <<<<<<<<<<<<<< + * """Return a packed binary string representing an IP header. + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_ALTSUM, __pyx_int_14) < 0) __PYX_ERR(0, 845, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_ADDR_ANY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_t_4)->__pyx_arg_src = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_ADDR_ANY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults1, __pyx_t_4)->__pyx_arg_dst = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_4dnet_40__defaults__); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip_pack_hdr, __pyx_t_4) < 0) __PYX_ERR(0, 322, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":846 - * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ - * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":357 + * int nxt, int hlim, ip6_addr_t s, ip6_addr_t d) + * + * IP6_ADDR_LEN = 16 # <<<<<<<<<<<<<< + * IP6_ADDR_BITS = 128 + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_ALTSUMDATA, __pyx_int_15) < 0) __PYX_ERR(0, 846, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_ADDR_LEN, __pyx_int_16) < 0) __PYX_ERR(0, 357, __pyx_L1_error) - /* "dnet.pyx":847 - * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":358 + * + * IP6_ADDR_LEN = 16 + * IP6_ADDR_BITS = 128 # <<<<<<<<<<<<<< + * + * IP6_HDR_LEN = 40 # /[inserted by cython to avoid comment start]* IPv6 header length *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SKEETER, __pyx_int_16) < 0) __PYX_ERR(0, 847, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_ADDR_BITS, __pyx_int_128) < 0) __PYX_ERR(0, 358, __pyx_L1_error) - /* "dnet.pyx":848 - * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ - * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ - * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":360 + * IP6_ADDR_BITS = 128 + * + * IP6_HDR_LEN = 40 # /[inserted by cython to avoid comment start]* IPv6 header length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * IP6_LEN_MIN = IP6_HDR_LEN + * IP6_LEN_MAX = 65535 # /[inserted by cython to avoid comment start]* non-jumbo payload *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_BUBBA, __pyx_int_17) < 0) __PYX_ERR(0, 848, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_HDR_LEN, __pyx_int_40) < 0) __PYX_ERR(0, 360, __pyx_L1_error) - /* "dnet.pyx":849 - * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ - * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":361 + * + * IP6_HDR_LEN = 40 # /[inserted by cython to avoid comment start]* IPv6 header length *[inserted by cython to avoid comment closer]/ + * IP6_LEN_MIN = IP6_HDR_LEN # <<<<<<<<<<<<<< + * IP6_LEN_MAX = 65535 # /[inserted by cython to avoid comment start]* non-jumbo payload *[inserted by cython to avoid comment closer]/ + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_TRAILSUM, __pyx_int_18) < 0) __PYX_ERR(0, 849, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_IP6_HDR_LEN); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_LEN_MIN, __pyx_t_4) < 0) __PYX_ERR(0, 361, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":850 - * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ - * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":362 + * IP6_HDR_LEN = 40 # /[inserted by cython to avoid comment start]* IPv6 header length *[inserted by cython to avoid comment closer]/ + * IP6_LEN_MIN = IP6_HDR_LEN + * IP6_LEN_MAX = 65535 # /[inserted by cython to avoid comment start]* non-jumbo payload *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * IP6_MTU_MIN = 1280 # /[inserted by cython to avoid comment start]* minimum MTU (1024 + 256) *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_MD5, __pyx_int_19) < 0) __PYX_ERR(0, 850, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_LEN_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 362, __pyx_L1_error) - /* "dnet.pyx":851 - * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ - * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ - * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":364 + * IP6_LEN_MAX = 65535 # /[inserted by cython to avoid comment start]* non-jumbo payload *[inserted by cython to avoid comment closer]/ + * + * IP6_MTU_MIN = 1280 # /[inserted by cython to avoid comment start]* minimum MTU (1024 + 256) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * IP6_HLIM_DEFAULT=64 */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SCPS, __pyx_int_20) < 0) __PYX_ERR(0, 851, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_MTU_MIN, __pyx_int_1280) < 0) __PYX_ERR(0, 364, __pyx_L1_error) - /* "dnet.pyx":852 - * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":366 + * IP6_MTU_MIN = 1280 # /[inserted by cython to avoid comment start]* minimum MTU (1024 + 256) *[inserted by cython to avoid comment closer]/ + * + * IP6_HLIM_DEFAULT=64 # <<<<<<<<<<<<<< + * IP6_HLIM_MAX = 255 + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SNACK, __pyx_int_21) < 0) __PYX_ERR(0, 852, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_HLIM_DEFAULT, __pyx_int_64) < 0) __PYX_ERR(0, 366, __pyx_L1_error) - /* "dnet.pyx":853 - * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ - * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":367 + * + * IP6_HLIM_DEFAULT=64 + * IP6_HLIM_MAX = 255 # <<<<<<<<<<<<<< + * + * IP6_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_REC, __pyx_int_22) < 0) __PYX_ERR(0, 853, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_HLIM_MAX, __pyx_int_255) < 0) __PYX_ERR(0, 367, __pyx_L1_error) - /* "dnet.pyx":854 - * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ - * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TCPCOMP = 26 # /[inserted by cython to avoid comment start]* TCP compression filter *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":369 + * IP6_HLIM_MAX = 255 + * + * IP6_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16) # <<<<<<<<<<<<<< + * IP6_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", 16) + * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_CORRUPT, __pyx_int_23) < 0) __PYX_ERR(0, 854, __pyx_L1_error) + __pyx_t_4 = PyBytes_FromStringAndSize(((char *)"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000"), 16); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_ADDR_UNSPEC, __pyx_t_4) < 0) __PYX_ERR(0, 369, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":855 - * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ - * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_TCPCOMP = 26 # /[inserted by cython to avoid comment start]* TCP compression filter *[inserted by cython to avoid comment closer]/ - * TCP_OPT_MAX = 27 + /* "dnet.pyx":370 + * + * IP6_ADDR_UNSPEC = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16) + * IP6_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", 16) # <<<<<<<<<<<<<< + * + * def ip6_ntoa(buf): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SNAP, __pyx_int_24) < 0) __PYX_ERR(0, 855, __pyx_L1_error) + __pyx_t_4 = PyBytes_FromStringAndSize(((char *)"\000\000\000\000\000\000\000\000\000\000\000\000\000\000\000\001"), 16); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_IP6_ADDR_LOOPBACK, __pyx_t_4) < 0) __PYX_ERR(0, 370, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":856 - * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ - * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TCPCOMP = 26 # /[inserted by cython to avoid comment start]* TCP compression filter *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * TCP_OPT_MAX = 27 + /* "dnet.pyx":372 + * IP6_ADDR_LOOPBACK = PyBytes_FromStringAndSize("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01", 16) * + * def ip6_ntoa(buf): # <<<<<<<<<<<<<< + * """Convert an IPv6 address from a 16-byte packed binary string to a + * printable string ('10.0.0.1').""" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_TCPCOMP, __pyx_int_26) < 0) __PYX_ERR(0, 856, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_21ip6_ntoa, 0, __pyx_n_s_ip6_ntoa, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__37)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 372, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip6_ntoa, __pyx_t_4) < 0) __PYX_ERR(0, 372, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":857 - * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ - * TCP_OPT_TCPCOMP = 26 # /[inserted by cython to avoid comment start]* TCP compression filter *[inserted by cython to avoid comment closer]/ - * TCP_OPT_MAX = 27 # <<<<<<<<<<<<<< + /* "dnet.pyx":379 + * return __ip6_ntoa(&ia) * - * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, + * def ip6_aton(buf): # <<<<<<<<<<<<<< + * """Convert an IPv6 address from a printable string to a + * packed binary string ('\\x0a\\x00\\x00\\x01').""" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_MAX, __pyx_int_27) < 0) __PYX_ERR(0, 857, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_23ip6_aton, 0, __pyx_n_s_ip6_aton, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__38)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip6_aton, __pyx_t_4) < 0) __PYX_ERR(0, 379, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":859 - * TCP_OPT_MAX = 27 + /* "dnet.pyx":387 + * return PyBytes_FromStringAndSize(&ia, 16) * - * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, # <<<<<<<<<<<<<< - * win=TCP_WIN_MAX, urp=0): - * """Return a packed binary string representing a TCP header. + * def ip6_checksum(buf): # <<<<<<<<<<<<<< + * """Return a packed binary string representing an IPv6 packet + * with the IPv6 and transport-layer checksums set. */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_TH_SYN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 859, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_25ip6_checksum, 0, __pyx_n_s_ip6_checksum, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__40)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip6_checksum, __pyx_t_4) < 0) __PYX_ERR(0, 387, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":397 + * return buf + * + * def ip6_pack_hdr(fc=0, fl=0, plen=0, nxt=IP_PROTO_IPV6, hlim=IP6_HLIM_DEFAULT, # <<<<<<<<<<<<<< + * src=IP6_ADDR_UNSPEC, dst=IP6_ADDR_UNSPEC): + * """Return a packed binary string representing an IPv6 header. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_27ip6_pack_hdr, 0, __pyx_n_s_ip6_pack_hdr, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__42)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, sizeof(__pyx_defaults2), 4)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_PROTO_IPV6); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_k__28 = __pyx_t_3; + __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_t_4)->__pyx_arg_nxt = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP6_HLIM_DEFAULT); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_t_4)->__pyx_arg_hlim = __pyx_t_3; __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; - /* "dnet.pyx":860 + /* "dnet.pyx":398 * - * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, - * win=TCP_WIN_MAX, urp=0): # <<<<<<<<<<<<<< - * """Return a packed binary string representing a TCP header. + * def ip6_pack_hdr(fc=0, fl=0, plen=0, nxt=IP_PROTO_IPV6, hlim=IP6_HLIM_DEFAULT, + * src=IP6_ADDR_UNSPEC, dst=IP6_ADDR_UNSPEC): # <<<<<<<<<<<<<< + * """Return a packed binary string representing an IPv6 header. * */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_TCP_WIN_MAX); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 860, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP6_ADDR_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 398, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_t_4)->__pyx_arg_src = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP6_ADDR_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 398, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - __pyx_k__29 = __pyx_t_3; + __Pyx_CyFunction_Defaults(__pyx_defaults2, __pyx_t_4)->__pyx_arg_dst = __pyx_t_3; __Pyx_GIVEREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_4dnet_42__defaults__); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ip6_pack_hdr, __pyx_t_4) < 0) __PYX_ERR(0, 397, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":859 - * TCP_OPT_MAX = 27 + /* "dnet.pyx":433 + * int addr_aton(char *src, addr_t *dst) * - * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, # <<<<<<<<<<<<<< - * win=TCP_WIN_MAX, urp=0): - * """Return a packed binary string representing a TCP header. + * ADDR_TYPE_NONE = 0 # <<<<<<<<<<<<<< + * ADDR_TYPE_ETH = 1 + * ADDR_TYPE_IP = 2 */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_33tcp_pack_hdr, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 859, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_tcp_pack_hdr, __pyx_t_3) < 0) __PYX_ERR(0, 859, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADDR_TYPE_NONE, __pyx_int_0) < 0) __PYX_ERR(0, 433, __pyx_L1_error) - /* "dnet.pyx":882 - * void __udp_pack_hdr "udp_pack_hdr" (char *hdr, int sport, int dport, int ulen) - * - * UDP_HDR_LEN = 8 # <<<<<<<<<<<<<< - * UDP_PORT_MAX = 65535 + /* "dnet.pyx":434 * + * ADDR_TYPE_NONE = 0 + * ADDR_TYPE_ETH = 1 # <<<<<<<<<<<<<< + * ADDR_TYPE_IP = 2 + * ADDR_TYPE_IP6 = 3 */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_UDP_HDR_LEN, __pyx_int_8) < 0) __PYX_ERR(0, 882, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADDR_TYPE_ETH, __pyx_int_1) < 0) __PYX_ERR(0, 434, __pyx_L1_error) - /* "dnet.pyx":883 - * - * UDP_HDR_LEN = 8 - * UDP_PORT_MAX = 65535 # <<<<<<<<<<<<<< + /* "dnet.pyx":435 + * ADDR_TYPE_NONE = 0 + * ADDR_TYPE_ETH = 1 + * ADDR_TYPE_IP = 2 # <<<<<<<<<<<<<< + * ADDR_TYPE_IP6 = 3 * - * def udp_pack_hdr(sport, dport, ulen=UDP_HDR_LEN): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_UDP_PORT_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 883, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADDR_TYPE_IP, __pyx_int_2) < 0) __PYX_ERR(0, 435, __pyx_L1_error) - /* "dnet.pyx":885 - * UDP_PORT_MAX = 65535 - * - * def udp_pack_hdr(sport, dport, ulen=UDP_HDR_LEN): # <<<<<<<<<<<<<< - * """Return a packed binary string representing a UDP header. + /* "dnet.pyx":436 + * ADDR_TYPE_ETH = 1 + * ADDR_TYPE_IP = 2 + * ADDR_TYPE_IP6 = 3 # <<<<<<<<<<<<<< * + * cdef class addr: */ - __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_UDP_HDR_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 885, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - __pyx_k__30 = __pyx_t_3; - __Pyx_GIVEREF(__pyx_t_3); - __pyx_t_3 = 0; - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_35udp_pack_hdr, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 885, __pyx_L1_error) - __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_udp_pack_hdr, __pyx_t_3) < 0) __PYX_ERR(0, 885, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ADDR_TYPE_IP6, __pyx_int_3) < 0) __PYX_ERR(0, 436, __pyx_L1_error) - /* "dnet.pyx":924 - * intf_t *intf_close(intf_t *intf) + /* "dnet.pyx":446 + * cdef addr_t _addr * - * INTF_TYPE_OTHER = 1 # /[inserted by cython to avoid comment start]* other *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * INTF_TYPE_ETH = 6 # /[inserted by cython to avoid comment start]* Ethernet *[inserted by cython to avoid comment closer]/ - * INTF_TYPE_LOOPBACK = 24 # /[inserted by cython to avoid comment start]* software loopback *[inserted by cython to avoid comment closer]/ + * def __init__(self, addrtxt=None, addrtype=ADDR_TYPE_NONE): # <<<<<<<<<<<<<< + * if addrtxt != None and addr_aton(addrtxt, &self._addr) < 0: + * if PyBytes_Size(addrtxt) == 4: */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_TYPE_OTHER, __pyx_int_1) < 0) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_ADDR_TYPE_NONE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 446, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_k_ = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; - /* "dnet.pyx":925 + /* "dnet.pyx":531 + * self._addr.addr_bits = IP6_ADDR_BITS * - * INTF_TYPE_OTHER = 1 # /[inserted by cython to avoid comment start]* other *[inserted by cython to avoid comment closer]/ - * INTF_TYPE_ETH = 6 # /[inserted by cython to avoid comment start]* Ethernet *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * INTF_TYPE_LOOPBACK = 24 # /[inserted by cython to avoid comment start]* software loopback *[inserted by cython to avoid comment closer]/ - * INTF_TYPE_TUN = 53 # /[inserted by cython to avoid comment start]* proprietary virtual/internal *[inserted by cython to avoid comment closer]/ + * def bcast(self): # <<<<<<<<<<<<<< + * """Return an addr object for our broadcast address.""" + * bcast = addr() */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_TYPE_ETH, __pyx_int_6) < 0) __PYX_ERR(0, 925, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4addr_3bcast, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_addr_bcast, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__44)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_addr, __pyx_n_s_bcast, __pyx_t_4) < 0) __PYX_ERR(0, 531, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_addr); - /* "dnet.pyx":926 - * INTF_TYPE_OTHER = 1 # /[inserted by cython to avoid comment start]* other *[inserted by cython to avoid comment closer]/ - * INTF_TYPE_ETH = 6 # /[inserted by cython to avoid comment start]* Ethernet *[inserted by cython to avoid comment closer]/ - * INTF_TYPE_LOOPBACK = 24 # /[inserted by cython to avoid comment start]* software loopback *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * INTF_TYPE_TUN = 53 # /[inserted by cython to avoid comment start]* proprietary virtual/internal *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":537 + * return bcast * + * def net(self): # <<<<<<<<<<<<<< + * """Return an addr object for our network address.""" + * net = addr() */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_TYPE_LOOPBACK, __pyx_int_24) < 0) __PYX_ERR(0, 926, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4addr_5net, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_addr_net, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__46)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_addr, __pyx_n_s_net, __pyx_t_4) < 0) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_addr); - /* "dnet.pyx":927 - * INTF_TYPE_ETH = 6 # /[inserted by cython to avoid comment start]* Ethernet *[inserted by cython to avoid comment closer]/ - * INTF_TYPE_LOOPBACK = 24 # /[inserted by cython to avoid comment start]* software loopback *[inserted by cython to avoid comment closer]/ - * INTF_TYPE_TUN = 53 # /[inserted by cython to avoid comment start]* proprietary virtual/internal *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + /* "dnet.pyx":555 + * return z * - * INTF_FLAG_UP = 0x01 # /[inserted by cython to avoid comment start]* enable interface *[inserted by cython to avoid comment closer]/ + * def __copy__(self): # <<<<<<<<<<<<<< + * a = addr() + * (a)._addr = self._addr */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_TYPE_TUN, __pyx_int_53) < 0) __PYX_ERR(0, 927, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4addr_9__copy__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_addr___copy, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__48)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_addr, __pyx_n_s_copy, __pyx_t_4) < 0) __PYX_ERR(0, 555, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_addr); - /* "dnet.pyx":929 - * INTF_TYPE_TUN = 53 # /[inserted by cython to avoid comment start]* proprietary virtual/internal *[inserted by cython to avoid comment closer]/ - * - * INTF_FLAG_UP = 0x01 # /[inserted by cython to avoid comment start]* enable interface *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * INTF_FLAG_LOOPBACK = 0x02 # /[inserted by cython to avoid comment start]* is a loopback net (r/o) *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_UP, __pyx_int_1) < 0) __PYX_ERR(0, 929, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4addr_35__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_addr___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__49)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":930 - * - * INTF_FLAG_UP = 0x01 # /[inserted by cython to avoid comment start]* enable interface *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_LOOPBACK = 0x02 # /[inserted by cython to avoid comment start]* is a loopback net (r/o) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "Pickling of struct members such as self._addr must be explicitly requested with @auto_pickle(True)" */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_LOOPBACK, __pyx_int_2) < 0) __PYX_ERR(0, 930, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4addr_37__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_addr___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__50)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - /* "dnet.pyx":931 - * INTF_FLAG_UP = 0x01 # /[inserted by cython to avoid comment start]* enable interface *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_LOOPBACK = 0x02 # /[inserted by cython to avoid comment start]* is a loopback net (r/o) *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_BROADCAST = 0x10 # /[inserted by cython to avoid comment start]* supports broadcast (r/o) *[inserted by cython to avoid comment closer]/ + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_POINTOPOINT, __pyx_int_4) < 0) __PYX_ERR(0, 931, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_15__addr_ip4_iter_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_addr_ip4_iter___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__52)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet___addr_ip4_iter, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet___addr_ip4_iter); - /* "dnet.pyx":932 - * INTF_FLAG_LOOPBACK = 0x02 # /[inserted by cython to avoid comment start]* is a loopback net (r/o) *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * INTF_FLAG_BROADCAST = 0x10 # /[inserted by cython to avoid comment start]* supports broadcast (r/o) *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_MULTICAST = 0x20 # /[inserted by cython to avoid comment start]* supports multicast (r/o) *[inserted by cython to avoid comment closer]/ + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle___addr_ip4_iter, (type(self), 0x6aff466, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle___addr_ip4_iter__set_state(self, __pyx_state) */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_NOARP, __pyx_int_8) < 0) __PYX_ERR(0, 932, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_15__addr_ip4_iter_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_addr_ip4_iter___setstate_cytho, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__53)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet___addr_ip4_iter, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet___addr_ip4_iter); - /* "dnet.pyx":933 - * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_BROADCAST = 0x10 # /[inserted by cython to avoid comment start]* supports broadcast (r/o) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< - * INTF_FLAG_MULTICAST = 0x20 # /[inserted by cython to avoid comment start]* supports multicast (r/o) *[inserted by cython to avoid comment closer]/ + /* "dnet.pyx":677 + * eth_addr_t dha, ip_addr_t dpa) + * + * ARP_HDR_LEN = 8 # /[inserted by cython to avoid comment start]* base ARP header length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ARP_ETHIP_LEN = 20 # /[inserted by cython to avoid comment start]* base ARP message length *[inserted by cython to avoid comment closer]/ * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_BROADCAST, __pyx_int_16) < 0) __PYX_ERR(0, 933, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_HDR_LEN, __pyx_int_8) < 0) __PYX_ERR(0, 677, __pyx_L1_error) - /* "dnet.pyx":934 - * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_BROADCAST = 0x10 # /[inserted by cython to avoid comment start]* supports broadcast (r/o) *[inserted by cython to avoid comment closer]/ - * INTF_FLAG_MULTICAST = 0x20 # /[inserted by cython to avoid comment start]* supports multicast (r/o) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + /* "dnet.pyx":678 * - * cdef object ifent_to_dict(intf_entry *entry): + * ARP_HDR_LEN = 8 # /[inserted by cython to avoid comment start]* base ARP header length *[inserted by cython to avoid comment closer]/ + * ARP_ETHIP_LEN = 20 # /[inserted by cython to avoid comment start]* base ARP message length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * ARP_HRD_ETH = 0x0001 # /[inserted by cython to avoid comment start]* ethernet hardware *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_MULTICAST, __pyx_int_32) < 0) __PYX_ERR(0, 934, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_ETHIP_LEN, __pyx_int_20) < 0) __PYX_ERR(0, 678, __pyx_L1_error) - /* "dnet.pyx":1194 - * fw_t *fw_close(fw_t *f) + /* "dnet.pyx":680 + * ARP_ETHIP_LEN = 20 # /[inserted by cython to avoid comment start]* base ARP message length *[inserted by cython to avoid comment closer]/ * - * FW_OP_ALLOW = 1 # <<<<<<<<<<<<<< - * FW_OP_BLOCK = 2 + * ARP_HRD_ETH = 0x0001 # /[inserted by cython to avoid comment start]* ethernet hardware *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ARP_HRD_IEEE802=0x0006 # /[inserted by cython to avoid comment start]* IEEE 802 hardware *[inserted by cython to avoid comment closer]/ * */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_FW_OP_ALLOW, __pyx_int_1) < 0) __PYX_ERR(0, 1194, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_HRD_ETH, __pyx_int_1) < 0) __PYX_ERR(0, 680, __pyx_L1_error) - /* "dnet.pyx":1195 + /* "dnet.pyx":681 * - * FW_OP_ALLOW = 1 - * FW_OP_BLOCK = 2 # <<<<<<<<<<<<<< + * ARP_HRD_ETH = 0x0001 # /[inserted by cython to avoid comment start]* ethernet hardware *[inserted by cython to avoid comment closer]/ + * ARP_HRD_IEEE802=0x0006 # /[inserted by cython to avoid comment start]* IEEE 802 hardware *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< * - * FW_DIR_IN = 1 + * ARP_PRO_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_FW_OP_BLOCK, __pyx_int_2) < 0) __PYX_ERR(0, 1195, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_HRD_IEEE802, __pyx_int_6) < 0) __PYX_ERR(0, 681, __pyx_L1_error) - /* "dnet.pyx":1197 - * FW_OP_BLOCK = 2 + /* "dnet.pyx":683 + * ARP_HRD_IEEE802=0x0006 # /[inserted by cython to avoid comment start]* IEEE 802 hardware *[inserted by cython to avoid comment closer]/ * - * FW_DIR_IN = 1 # <<<<<<<<<<<<<< - * FW_DIR_OUT = 2 + * ARP_PRO_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< * + * ARP_OP_REQUEST = 1 # /[inserted by cython to avoid comment start]* request to resolve ha given pa *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_FW_DIR_IN, __pyx_int_1) < 0) __PYX_ERR(0, 1197, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_PRO_IP, __pyx_int_2048) < 0) __PYX_ERR(0, 683, __pyx_L1_error) - /* "dnet.pyx":1198 + /* "dnet.pyx":685 + * ARP_PRO_IP = 0x0800 # /[inserted by cython to avoid comment start]* IP protocol *[inserted by cython to avoid comment closer]/ * - * FW_DIR_IN = 1 - * FW_DIR_OUT = 2 # <<<<<<<<<<<<<< + * ARP_OP_REQUEST = 1 # /[inserted by cython to avoid comment start]* request to resolve ha given pa *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ARP_OP_REPLY = 2 # /[inserted by cython to avoid comment start]* response giving hardware address *[inserted by cython to avoid comment closer]/ + * ARP_OP_REVREQUEST = 3 # /[inserted by cython to avoid comment start]* request to resolve pa given ha *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_OP_REQUEST, __pyx_int_1) < 0) __PYX_ERR(0, 685, __pyx_L1_error) + + /* "dnet.pyx":686 * - * cdef object rule_to_dict(fw_rule *rule): + * ARP_OP_REQUEST = 1 # /[inserted by cython to avoid comment start]* request to resolve ha given pa *[inserted by cython to avoid comment closer]/ + * ARP_OP_REPLY = 2 # /[inserted by cython to avoid comment start]* response giving hardware address *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ARP_OP_REVREQUEST = 3 # /[inserted by cython to avoid comment start]* request to resolve pa given ha *[inserted by cython to avoid comment closer]/ + * ARP_OP_REVREPLY = 4 # /[inserted by cython to avoid comment start]* response giving protocol address *[inserted by cython to avoid comment closer]/ */ - if (PyDict_SetItem(__pyx_d, __pyx_n_s_FW_DIR_OUT, __pyx_int_2) < 0) __PYX_ERR(0, 1198, __pyx_L1_error) + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_OP_REPLY, __pyx_int_2) < 0) __PYX_ERR(0, 686, __pyx_L1_error) + + /* "dnet.pyx":687 + * ARP_OP_REQUEST = 1 # /[inserted by cython to avoid comment start]* request to resolve ha given pa *[inserted by cython to avoid comment closer]/ + * ARP_OP_REPLY = 2 # /[inserted by cython to avoid comment start]* response giving hardware address *[inserted by cython to avoid comment closer]/ + * ARP_OP_REVREQUEST = 3 # /[inserted by cython to avoid comment start]* request to resolve pa given ha *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * ARP_OP_REVREPLY = 4 # /[inserted by cython to avoid comment start]* response giving protocol address *[inserted by cython to avoid comment closer]/ + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_OP_REVREQUEST, __pyx_int_3) < 0) __PYX_ERR(0, 687, __pyx_L1_error) + + /* "dnet.pyx":688 + * ARP_OP_REPLY = 2 # /[inserted by cython to avoid comment start]* response giving hardware address *[inserted by cython to avoid comment closer]/ + * ARP_OP_REVREQUEST = 3 # /[inserted by cython to avoid comment start]* request to resolve pa given ha *[inserted by cython to avoid comment closer]/ + * ARP_OP_REVREPLY = 4 # /[inserted by cython to avoid comment start]* response giving protocol address *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * cdef int __arp_callback(arp_entry *entry, void *arg) except -1: + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_ARP_OP_REVREPLY, __pyx_int_4) < 0) __PYX_ERR(0, 688, __pyx_L1_error) + + /* "dnet.pyx":712 + * raise OSError, __oserror() + * + * def add(self, addr pa, addr ha): # <<<<<<<<<<<<<< + * """Add an entry to the system ARP table. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3arp_3add, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_arp_add, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__55)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 712, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_arp, __pyx_n_s_add, __pyx_t_4) < 0) __PYX_ERR(0, 712, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_arp); + + /* "dnet.pyx":725 + * raise OSError, __oserror() + * + * def delete(self, addr pa): # <<<<<<<<<<<<<< + * """Delete an entry from the system ARP table. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3arp_5delete, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_arp_delete, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__57)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 725, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_arp, __pyx_n_s_delete, __pyx_t_4) < 0) __PYX_ERR(0, 725, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_arp); + + /* "dnet.pyx":736 + * raise OSError, __oserror() + * + * def get(self, addr pa): # <<<<<<<<<<<<<< + * """Return the hardware address for a given protocol address + * in the system ARP table. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3arp_7get, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_arp_get, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__58)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_arp, __pyx_n_s_get, __pyx_t_4) < 0) __PYX_ERR(0, 736, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_arp); + + /* "dnet.pyx":749 + * return None + * + * def loop(self, callback, arg=None): # <<<<<<<<<<<<<< + * """Iterate over the system ARP table, invoking a user callback + * with each entry, returning the status of the callback routine. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3arp_9loop, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_arp_loop, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__60)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 749, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__61); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_arp, __pyx_n_s_loop, __pyx_t_4) < 0) __PYX_ERR(0, 749, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_arp); /* "(tree fragment)":1 - * def __pyx_unpickle___addr_ip4_iter(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< - * cdef object __pyx_PickleError - * cdef object __pyx_result + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3arp_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_arp___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__62)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.arp cannot be converted to a Python object for pickling" + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3arp_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_arp___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__63)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":771 + * arp_close(self.arp) + * + * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, # <<<<<<<<<<<<<< + * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, + * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): */ - __pyx_t_3 = PyCFunction_NewEx(&__pyx_mdef_4dnet_37__pyx_unpickle___addr_ip4_iter, NULL, __pyx_n_s_dnet); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_29arp_pack_hdr_ethip, 0, __pyx_n_s_arp_pack_hdr_ethip, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__65)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, sizeof(__pyx_defaults3), 5)) __PYX_ERR(0, 771, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ARP_OP_REQUEST); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 771, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle___addr_ip4_iter, __pyx_t_3) < 0) __PYX_ERR(1, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_t_4)->__pyx_arg_op = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; - /* "dnet.pyx":1 - * # cython: language_level=3, boundscheck=False # <<<<<<<<<<<<<< - * # - * # dnet.pyx + /* "dnet.pyx":772 + * + * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, + * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, # <<<<<<<<<<<<<< + * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): + * """Return a packed binary string representing an Ethernet/IP ARP message. */ - __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_ADDR_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 772, __pyx_L1_error) __Pyx_GOTREF(__pyx_t_3); - if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error) - __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_t_4)->__pyx_arg_sha = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_ADDR_ANY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 772, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_t_4)->__pyx_arg_spa = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; - /*--- Wrapped vars code ---*/ + /* "dnet.pyx":773 + * def arp_pack_hdr_ethip(op=ARP_OP_REQUEST, + * sha=ETH_ADDR_UNSPEC, spa=IP_ADDR_ANY, + * dha=ETH_ADDR_UNSPEC, dpa=IP_ADDR_ANY): # <<<<<<<<<<<<<< + * """Return a packed binary string representing an Ethernet/IP ARP message. + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_ETH_ADDR_UNSPEC); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_t_4)->__pyx_arg_dha = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_IP_ADDR_ANY); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults3, __pyx_t_4)->__pyx_arg_dpa = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_4dnet_44__defaults__); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_arp_pack_hdr_ethip, __pyx_t_4) < 0) __PYX_ERR(0, 771, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; - 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 dnet", __pyx_clineno, __pyx_lineno, __pyx_filename); - } - Py_CLEAR(__pyx_m); - } else if (!PyErr_Occurred()) { - PyErr_SetString(PyExc_ImportError, "init dnet"); - } - __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 -} + /* "dnet.pyx":799 + * void __icmp_pack_hdr "icmp_pack_hdr" (char *hdr, int type, int code) + * + * def icmp_pack_hdr(itype, code): # <<<<<<<<<<<<<< + * """Return a packed binary string representing an ICMP header. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_31icmp_pack_hdr, 0, __pyx_n_s_icmp_pack_hdr, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__67)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_icmp_pack_hdr, __pyx_t_4) < 0) __PYX_ERR(0, 799, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; -/* --- 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 + /* "dnet.pyx":817 + * int sport, int dport, unsigned long seq, unsigned long ack, int flags, int win, int urp) + * + * TCP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base TCP header length *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * TH_FIN = 0x01 # /[inserted by cython to avoid comment start]* end of data *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_HDR_LEN, __pyx_int_20) < 0) __PYX_ERR(0, 817, __pyx_L1_error) -/* 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); + /* "dnet.pyx":819 + * TCP_HDR_LEN = 20 # /[inserted by cython to avoid comment start]* base TCP header length *[inserted by cython to avoid comment closer]/ + * + * TH_FIN = 0x01 # /[inserted by cython to avoid comment start]* end of data *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TH_SYN = 0x02 # /[inserted by cython to avoid comment start]* synchronize sequence numbers *[inserted by cython to avoid comment closer]/ + * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_FIN, __pyx_int_1) < 0) __PYX_ERR(0, 819, __pyx_L1_error) + + /* "dnet.pyx":820 + * + * TH_FIN = 0x01 # /[inserted by cython to avoid comment start]* end of data *[inserted by cython to avoid comment closer]/ + * TH_SYN = 0x02 # /[inserted by cython to avoid comment start]* synchronize sequence numbers *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ + * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_SYN, __pyx_int_2) < 0) __PYX_ERR(0, 820, __pyx_L1_error) + + /* "dnet.pyx":821 + * TH_FIN = 0x01 # /[inserted by cython to avoid comment start]* end of data *[inserted by cython to avoid comment closer]/ + * TH_SYN = 0x02 # /[inserted by cython to avoid comment start]* synchronize sequence numbers *[inserted by cython to avoid comment closer]/ + * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ + * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_RST, __pyx_int_4) < 0) __PYX_ERR(0, 821, __pyx_L1_error) + + /* "dnet.pyx":822 + * TH_SYN = 0x02 # /[inserted by cython to avoid comment start]* synchronize sequence numbers *[inserted by cython to avoid comment closer]/ + * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ + * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ + * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_PUSH, __pyx_int_8) < 0) __PYX_ERR(0, 822, __pyx_L1_error) + + /* "dnet.pyx":823 + * TH_RST = 0x04 # /[inserted by cython to avoid comment start]* reset connection *[inserted by cython to avoid comment closer]/ + * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ + * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ + * TH_ECE = 0x40 # /[inserted by cython to avoid comment start]* ECN echo, RFC 3168 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_ACK, __pyx_int_16) < 0) __PYX_ERR(0, 823, __pyx_L1_error) + + /* "dnet.pyx":824 + * TH_PUSH = 0x08 # /[inserted by cython to avoid comment start]* push *[inserted by cython to avoid comment closer]/ + * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ + * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TH_ECE = 0x40 # /[inserted by cython to avoid comment start]* ECN echo, RFC 3168 *[inserted by cython to avoid comment closer]/ + * TH_CWR = 0x80 # /[inserted by cython to avoid comment start]* congestion window reduced *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_URG, __pyx_int_32) < 0) __PYX_ERR(0, 824, __pyx_L1_error) + + /* "dnet.pyx":825 + * TH_ACK = 0x10 # /[inserted by cython to avoid comment start]* acknowledgement number set *[inserted by cython to avoid comment closer]/ + * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ + * TH_ECE = 0x40 # /[inserted by cython to avoid comment start]* ECN echo, RFC 3168 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TH_CWR = 0x80 # /[inserted by cython to avoid comment start]* congestion window reduced *[inserted by cython to avoid comment closer]/ + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_ECE, __pyx_int_64) < 0) __PYX_ERR(0, 825, __pyx_L1_error) + + /* "dnet.pyx":826 + * TH_URG = 0x20 # /[inserted by cython to avoid comment start]* urgent pointer set *[inserted by cython to avoid comment closer]/ + * TH_ECE = 0x40 # /[inserted by cython to avoid comment start]* ECN echo, RFC 3168 *[inserted by cython to avoid comment closer]/ + * TH_CWR = 0x80 # /[inserted by cython to avoid comment start]* congestion window reduced *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * TCP_PORT_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum port *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TH_CWR, __pyx_int_128) < 0) __PYX_ERR(0, 826, __pyx_L1_error) + + /* "dnet.pyx":828 + * TH_CWR = 0x80 # /[inserted by cython to avoid comment start]* congestion window reduced *[inserted by cython to avoid comment closer]/ + * + * TCP_PORT_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum port *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_WIN_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum (unscaled) window *[inserted by cython to avoid comment closer]/ + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_PORT_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 828, __pyx_L1_error) + + /* "dnet.pyx":829 + * + * TCP_PORT_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum port *[inserted by cython to avoid comment closer]/ + * TCP_WIN_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum (unscaled) window *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * TCP_OPT_EOL = 0 # /[inserted by cython to avoid comment start]* end of option list *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_WIN_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 829, __pyx_L1_error) + + /* "dnet.pyx":831 + * TCP_WIN_MAX = 65535 # /[inserted by cython to avoid comment start]* maximum (unscaled) window *[inserted by cython to avoid comment closer]/ + * + * TCP_OPT_EOL = 0 # /[inserted by cython to avoid comment start]* end of option list *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_NOP = 1 # /[inserted by cython to avoid comment start]* no operation *[inserted by cython to avoid comment closer]/ + * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_EOL, __pyx_int_0) < 0) __PYX_ERR(0, 831, __pyx_L1_error) + + /* "dnet.pyx":832 + * + * TCP_OPT_EOL = 0 # /[inserted by cython to avoid comment start]* end of option list *[inserted by cython to avoid comment closer]/ + * TCP_OPT_NOP = 1 # /[inserted by cython to avoid comment start]* no operation *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ + * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_NOP, __pyx_int_1) < 0) __PYX_ERR(0, 832, __pyx_L1_error) + + /* "dnet.pyx":833 + * TCP_OPT_EOL = 0 # /[inserted by cython to avoid comment start]* end of option list *[inserted by cython to avoid comment closer]/ + * TCP_OPT_NOP = 1 # /[inserted by cython to avoid comment start]* no operation *[inserted by cython to avoid comment closer]/ + * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_MSS, __pyx_int_2) < 0) __PYX_ERR(0, 833, __pyx_L1_error) + + /* "dnet.pyx":834 + * TCP_OPT_NOP = 1 # /[inserted by cython to avoid comment start]* no operation *[inserted by cython to avoid comment closer]/ + * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ + * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_WSCALE, __pyx_int_3) < 0) __PYX_ERR(0, 834, __pyx_L1_error) + + /* "dnet.pyx":835 + * TCP_OPT_MSS = 2 # /[inserted by cython to avoid comment start]* maximum segment size *[inserted by cython to avoid comment closer]/ + * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SACKOK, __pyx_int_4) < 0) __PYX_ERR(0, 835, __pyx_L1_error) + + /* "dnet.pyx":836 + * TCP_OPT_WSCALE = 3 # /[inserted by cython to avoid comment start]* window scale factor, RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SACK, __pyx_int_5) < 0) __PYX_ERR(0, 836, __pyx_L1_error) + + /* "dnet.pyx":837 + * TCP_OPT_SACKOK = 4 # /[inserted by cython to avoid comment start]* SACK permitted, RFC 2018 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_ECHO, __pyx_int_6) < 0) __PYX_ERR(0, 837, __pyx_L1_error) + + /* "dnet.pyx":838 + * TCP_OPT_SACK = 5 # /[inserted by cython to avoid comment start]* SACK, RFC 2018 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_ECHOREPLY, __pyx_int_7) < 0) __PYX_ERR(0, 838, __pyx_L1_error) + + /* "dnet.pyx":839 + * TCP_OPT_ECHO = 6 # /[inserted by cython to avoid comment start]* echo (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_TIMESTAMP, __pyx_int_8) < 0) __PYX_ERR(0, 839, __pyx_L1_error) + + /* "dnet.pyx":840 + * TCP_OPT_ECHOREPLY = 7 # /[inserted by cython to avoid comment start]* echo reply (obsolete), RFC 1072 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_POCONN, __pyx_int_9) < 0) __PYX_ERR(0, 840, __pyx_L1_error) + + /* "dnet.pyx":841 + * TCP_OPT_TIMESTAMP = 8 # /[inserted by cython to avoid comment start]* timestamp, RFC 1323 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_POSVC, __pyx_int_10) < 0) __PYX_ERR(0, 841, __pyx_L1_error) + + /* "dnet.pyx":842 + * TCP_OPT_POCONN = 9 # /[inserted by cython to avoid comment start]* partial order conn, RFC 1693 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_CC, __pyx_int_11) < 0) __PYX_ERR(0, 842, __pyx_L1_error) + + /* "dnet.pyx":843 + * TCP_OPT_POSVC = 10 # /[inserted by cython to avoid comment start]* partial order service, RFC 1693 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_CCNEW, __pyx_int_12) < 0) __PYX_ERR(0, 843, __pyx_L1_error) + + /* "dnet.pyx":844 + * TCP_OPT_CC = 11 # /[inserted by cython to avoid comment start]* connection count, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_CCECHO, __pyx_int_13) < 0) __PYX_ERR(0, 844, __pyx_L1_error) + + /* "dnet.pyx":845 + * TCP_OPT_CCNEW = 12 # /[inserted by cython to avoid comment start]* CC.NEW, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_ALTSUM, __pyx_int_14) < 0) __PYX_ERR(0, 845, __pyx_L1_error) + + /* "dnet.pyx":846 + * TCP_OPT_CCECHO = 13 # /[inserted by cython to avoid comment start]* CC.ECHO, RFC 1644 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ + * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_ALTSUMDATA, __pyx_int_15) < 0) __PYX_ERR(0, 846, __pyx_L1_error) + + /* "dnet.pyx":847 + * TCP_OPT_ALTSUM = 14 # /[inserted by cython to avoid comment start]* alt checksum request, RFC 1146 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SKEETER, __pyx_int_16) < 0) __PYX_ERR(0, 847, __pyx_L1_error) + + /* "dnet.pyx":848 + * TCP_OPT_ALTSUMDATA = 15 # /[inserted by cython to avoid comment start]* alt checksum data, RFC 1146 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ + * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ + * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_BUBBA, __pyx_int_17) < 0) __PYX_ERR(0, 848, __pyx_L1_error) + + /* "dnet.pyx":849 + * TCP_OPT_SKEETER = 16 # /[inserted by cython to avoid comment start]* Skeeter *[inserted by cython to avoid comment closer]/ + * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_TRAILSUM, __pyx_int_18) < 0) __PYX_ERR(0, 849, __pyx_L1_error) + + /* "dnet.pyx":850 + * TCP_OPT_BUBBA = 17 # /[inserted by cython to avoid comment start]* Bubba *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ + * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_MD5, __pyx_int_19) < 0) __PYX_ERR(0, 850, __pyx_L1_error) + + /* "dnet.pyx":851 + * TCP_OPT_TRAILSUM = 18 # /[inserted by cython to avoid comment start]* trailer checksum *[inserted by cython to avoid comment closer]/ + * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ + * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SCPS, __pyx_int_20) < 0) __PYX_ERR(0, 851, __pyx_L1_error) + + /* "dnet.pyx":852 + * TCP_OPT_MD5 = 19 # /[inserted by cython to avoid comment start]* MD5 signature, RFC 2385 *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SNACK, __pyx_int_21) < 0) __PYX_ERR(0, 852, __pyx_L1_error) + + /* "dnet.pyx":853 + * TCP_OPT_SCPS = 20 # /[inserted by cython to avoid comment start]* SCPS capabilities *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ + * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_REC, __pyx_int_22) < 0) __PYX_ERR(0, 853, __pyx_L1_error) + + /* "dnet.pyx":854 + * TCP_OPT_SNACK = 21 # /[inserted by cython to avoid comment start]* selective negative acks *[inserted by cython to avoid comment closer]/ + * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TCPCOMP = 26 # /[inserted by cython to avoid comment start]* TCP compression filter *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_CORRUPT, __pyx_int_23) < 0) __PYX_ERR(0, 854, __pyx_L1_error) + + /* "dnet.pyx":855 + * TCP_OPT_REC = 22 # /[inserted by cython to avoid comment start]* record boundaries *[inserted by cython to avoid comment closer]/ + * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_TCPCOMP = 26 # /[inserted by cython to avoid comment start]* TCP compression filter *[inserted by cython to avoid comment closer]/ + * TCP_OPT_MAX = 27 + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_SNAP, __pyx_int_24) < 0) __PYX_ERR(0, 855, __pyx_L1_error) + + /* "dnet.pyx":856 + * TCP_OPT_CORRUPT = 23 # /[inserted by cython to avoid comment start]* corruption experienced *[inserted by cython to avoid comment closer]/ + * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TCPCOMP = 26 # /[inserted by cython to avoid comment start]* TCP compression filter *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * TCP_OPT_MAX = 27 + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_TCPCOMP, __pyx_int_26) < 0) __PYX_ERR(0, 856, __pyx_L1_error) + + /* "dnet.pyx":857 + * TCP_OPT_SNAP = 24 # /[inserted by cython to avoid comment start]* SNAP *[inserted by cython to avoid comment closer]/ + * TCP_OPT_TCPCOMP = 26 # /[inserted by cython to avoid comment start]* TCP compression filter *[inserted by cython to avoid comment closer]/ + * TCP_OPT_MAX = 27 # <<<<<<<<<<<<<< + * + * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_TCP_OPT_MAX, __pyx_int_27) < 0) __PYX_ERR(0, 857, __pyx_L1_error) + + /* "dnet.pyx":859 + * TCP_OPT_MAX = 27 + * + * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, # <<<<<<<<<<<<<< + * win=TCP_WIN_MAX, urp=0): + * """Return a packed binary string representing a TCP header. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_33tcp_pack_hdr, 0, __pyx_n_s_tcp_pack_hdr, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__69)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, sizeof(__pyx_defaults4), 2)) __PYX_ERR(0, 859, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_TH_SYN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 859, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_t_4)->__pyx_arg_flags = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + + /* "dnet.pyx":860 + * + * def tcp_pack_hdr(sport, dport, seq=1, ack=0, flags=TH_SYN, + * win=TCP_WIN_MAX, urp=0): # <<<<<<<<<<<<<< + * """Return a packed binary string representing a TCP header. + * + */ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_TCP_WIN_MAX); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 860, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults4, __pyx_t_4)->__pyx_arg_win = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_4dnet_46__defaults__); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_tcp_pack_hdr, __pyx_t_4) < 0) __PYX_ERR(0, 859, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":882 + * void __udp_pack_hdr "udp_pack_hdr" (char *hdr, int sport, int dport, int ulen) + * + * UDP_HDR_LEN = 8 # <<<<<<<<<<<<<< + * UDP_PORT_MAX = 65535 + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_UDP_HDR_LEN, __pyx_int_8) < 0) __PYX_ERR(0, 882, __pyx_L1_error) + + /* "dnet.pyx":883 + * + * UDP_HDR_LEN = 8 + * UDP_PORT_MAX = 65535 # <<<<<<<<<<<<<< + * + * def udp_pack_hdr(sport, dport, ulen=UDP_HDR_LEN): + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_UDP_PORT_MAX, __pyx_int_65535) < 0) __PYX_ERR(0, 883, __pyx_L1_error) + + /* "dnet.pyx":885 + * UDP_PORT_MAX = 65535 + * + * def udp_pack_hdr(sport, dport, ulen=UDP_HDR_LEN): # <<<<<<<<<<<<<< + * """Return a packed binary string representing a UDP header. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_35udp_pack_hdr, 0, __pyx_n_s_udp_pack_hdr, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__71)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_4, sizeof(__pyx_defaults5), 1)) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_n_s_UDP_HDR_LEN); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_CyFunction_Defaults(__pyx_defaults5, __pyx_t_4)->__pyx_arg_ulen = __pyx_t_3; + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_4, __pyx_pf_4dnet_48__defaults__); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_udp_pack_hdr, __pyx_t_4) < 0) __PYX_ERR(0, 885, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":924 + * intf_t *intf_close(intf_t *intf) + * + * INTF_TYPE_OTHER = 1 # /[inserted by cython to avoid comment start]* other *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * INTF_TYPE_ETH = 6 # /[inserted by cython to avoid comment start]* Ethernet *[inserted by cython to avoid comment closer]/ + * INTF_TYPE_LOOPBACK = 24 # /[inserted by cython to avoid comment start]* software loopback *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_TYPE_OTHER, __pyx_int_1) < 0) __PYX_ERR(0, 924, __pyx_L1_error) + + /* "dnet.pyx":925 + * + * INTF_TYPE_OTHER = 1 # /[inserted by cython to avoid comment start]* other *[inserted by cython to avoid comment closer]/ + * INTF_TYPE_ETH = 6 # /[inserted by cython to avoid comment start]* Ethernet *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * INTF_TYPE_LOOPBACK = 24 # /[inserted by cython to avoid comment start]* software loopback *[inserted by cython to avoid comment closer]/ + * INTF_TYPE_TUN = 53 # /[inserted by cython to avoid comment start]* proprietary virtual/internal *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_TYPE_ETH, __pyx_int_6) < 0) __PYX_ERR(0, 925, __pyx_L1_error) + + /* "dnet.pyx":926 + * INTF_TYPE_OTHER = 1 # /[inserted by cython to avoid comment start]* other *[inserted by cython to avoid comment closer]/ + * INTF_TYPE_ETH = 6 # /[inserted by cython to avoid comment start]* Ethernet *[inserted by cython to avoid comment closer]/ + * INTF_TYPE_LOOPBACK = 24 # /[inserted by cython to avoid comment start]* software loopback *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * INTF_TYPE_TUN = 53 # /[inserted by cython to avoid comment start]* proprietary virtual/internal *[inserted by cython to avoid comment closer]/ + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_TYPE_LOOPBACK, __pyx_int_24) < 0) __PYX_ERR(0, 926, __pyx_L1_error) + + /* "dnet.pyx":927 + * INTF_TYPE_ETH = 6 # /[inserted by cython to avoid comment start]* Ethernet *[inserted by cython to avoid comment closer]/ + * INTF_TYPE_LOOPBACK = 24 # /[inserted by cython to avoid comment start]* software loopback *[inserted by cython to avoid comment closer]/ + * INTF_TYPE_TUN = 53 # /[inserted by cython to avoid comment start]* proprietary virtual/internal *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * INTF_FLAG_UP = 0x01 # /[inserted by cython to avoid comment start]* enable interface *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_TYPE_TUN, __pyx_int_53) < 0) __PYX_ERR(0, 927, __pyx_L1_error) + + /* "dnet.pyx":929 + * INTF_TYPE_TUN = 53 # /[inserted by cython to avoid comment start]* proprietary virtual/internal *[inserted by cython to avoid comment closer]/ + * + * INTF_FLAG_UP = 0x01 # /[inserted by cython to avoid comment start]* enable interface *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * INTF_FLAG_LOOPBACK = 0x02 # /[inserted by cython to avoid comment start]* is a loopback net (r/o) *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_UP, __pyx_int_1) < 0) __PYX_ERR(0, 929, __pyx_L1_error) + + /* "dnet.pyx":930 + * + * INTF_FLAG_UP = 0x01 # /[inserted by cython to avoid comment start]* enable interface *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_LOOPBACK = 0x02 # /[inserted by cython to avoid comment start]* is a loopback net (r/o) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_LOOPBACK, __pyx_int_2) < 0) __PYX_ERR(0, 930, __pyx_L1_error) + + /* "dnet.pyx":931 + * INTF_FLAG_UP = 0x01 # /[inserted by cython to avoid comment start]* enable interface *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_LOOPBACK = 0x02 # /[inserted by cython to avoid comment start]* is a loopback net (r/o) *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_BROADCAST = 0x10 # /[inserted by cython to avoid comment start]* supports broadcast (r/o) *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_POINTOPOINT, __pyx_int_4) < 0) __PYX_ERR(0, 931, __pyx_L1_error) + + /* "dnet.pyx":932 + * INTF_FLAG_LOOPBACK = 0x02 # /[inserted by cython to avoid comment start]* is a loopback net (r/o) *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * INTF_FLAG_BROADCAST = 0x10 # /[inserted by cython to avoid comment start]* supports broadcast (r/o) *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_MULTICAST = 0x20 # /[inserted by cython to avoid comment start]* supports multicast (r/o) *[inserted by cython to avoid comment closer]/ + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_NOARP, __pyx_int_8) < 0) __PYX_ERR(0, 932, __pyx_L1_error) + + /* "dnet.pyx":933 + * INTF_FLAG_POINTOPOINT = 0x04 # /[inserted by cython to avoid comment start]* point-to-point link (r/o) *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_BROADCAST = 0x10 # /[inserted by cython to avoid comment start]* supports broadcast (r/o) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * INTF_FLAG_MULTICAST = 0x20 # /[inserted by cython to avoid comment start]* supports multicast (r/o) *[inserted by cython to avoid comment closer]/ + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_BROADCAST, __pyx_int_16) < 0) __PYX_ERR(0, 933, __pyx_L1_error) + + /* "dnet.pyx":934 + * INTF_FLAG_NOARP = 0x08 # /[inserted by cython to avoid comment start]* disable ARP *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_BROADCAST = 0x10 # /[inserted by cython to avoid comment start]* supports broadcast (r/o) *[inserted by cython to avoid comment closer]/ + * INTF_FLAG_MULTICAST = 0x20 # /[inserted by cython to avoid comment start]* supports multicast (r/o) *[inserted by cython to avoid comment closer]/ # <<<<<<<<<<<<<< + * + * cdef object ifent_to_dict(intf_entry *entry): + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_INTF_FLAG_MULTICAST, __pyx_int_32) < 0) __PYX_ERR(0, 934, __pyx_L1_error) + + /* "dnet.pyx":992 + * raise OSError, __oserror() + * + * def get(self, name): # <<<<<<<<<<<<<< + * """Return the configuration for a network interface as a dict. + * """ + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4intf_3get, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_intf_get, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__73)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 992, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_intf, __pyx_n_s_get, __pyx_t_4) < 0) __PYX_ERR(0, 992, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_intf); + + /* "dnet.pyx":1004 + * return ifent_to_dict(ifent) + * + * def get_src(self, addr src): # <<<<<<<<<<<<<< + * """Return the configuration for the interface whose primary address + * matches the specified source address. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4intf_5get_src, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_intf_get_src, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__75)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1004, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_intf, __pyx_n_s_get_src, __pyx_t_4) < 0) __PYX_ERR(0, 1004, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_intf); + + /* "dnet.pyx":1016 + * return ifent_to_dict(ifent) + * + * def get_dst(self, addr dst): # <<<<<<<<<<<<<< + * """Return the configuration for the best interface with which to + * reach the specified dst address. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4intf_7get_dst, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_intf_get_dst, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__77)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_intf, __pyx_n_s_get_dst, __pyx_t_4) < 0) __PYX_ERR(0, 1016, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_intf); + + /* "dnet.pyx":1028 + * return ifent_to_dict(ifent) + * + * def set(self, d): # <<<<<<<<<<<<<< + * """Set the configuration for an interface from a dict. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4intf_9set, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_intf_set, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__79)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_intf, __pyx_n_s_set, __pyx_t_4) < 0) __PYX_ERR(0, 1028, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_intf); + + /* "dnet.pyx":1049 + * raise OSError, __oserror() + * + * def loop(self, callback, arg=None): # <<<<<<<<<<<<<< + * """Iterate over the system interface table, invoking a user callback + * with each entry, returning the status of the callback routine. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4intf_11loop, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_intf_loop, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__80)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1049, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__61); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_intf, __pyx_n_s_loop, __pyx_t_4) < 0) __PYX_ERR(0, 1049, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_intf); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4intf_17__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_intf___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__81)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.intf cannot be converted to a Python object for pickling" + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4intf_19__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_intf___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__82)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":1111 + * raise OSError, __oserror() + * + * def add(self, addr dst, addr gw): # <<<<<<<<<<<<<< + * """Add an entry to the system routing table. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_5route_3add, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_route_add, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__84)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_route, __pyx_n_s_add, __pyx_t_4) < 0) __PYX_ERR(0, 1111, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_route); + + /* "dnet.pyx":1124 + * raise OSError, __oserror() + * + * def delete(self, addr dst): # <<<<<<<<<<<<<< + * """Delete an entry from the system routing table. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_5route_5delete, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_route_delete, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__86)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1124, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_route, __pyx_n_s_delete, __pyx_t_4) < 0) __PYX_ERR(0, 1124, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_route); + + /* "dnet.pyx":1135 + * raise OSError, __oserror() + * + * def get(self, addr dst): # <<<<<<<<<<<<<< + * """Return the hardware address for a given protocol address + * in the system routing table. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_5route_7get, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_route_get, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__87)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_route, __pyx_n_s_get, __pyx_t_4) < 0) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_route); + + /* "dnet.pyx":1148 + * return None + * + * def loop(self, callback, arg=None): # <<<<<<<<<<<<<< + * """Iterate over the system routing table, invoking a user callback + * with each entry, returning the status of the callback routine. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_5route_9loop, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_route_loop, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__88)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__61); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_route, __pyx_n_s_loop, __pyx_t_4) < 0) __PYX_ERR(0, 1148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_route); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.route cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_5route_15__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_route___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__89)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.route cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.route cannot be converted to a Python object for pickling" + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_5route_17__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_route___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__90)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":1194 + * fw_t *fw_close(fw_t *f) + * + * FW_OP_ALLOW = 1 # <<<<<<<<<<<<<< + * FW_OP_BLOCK = 2 + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FW_OP_ALLOW, __pyx_int_1) < 0) __PYX_ERR(0, 1194, __pyx_L1_error) + + /* "dnet.pyx":1195 + * + * FW_OP_ALLOW = 1 + * FW_OP_BLOCK = 2 # <<<<<<<<<<<<<< + * + * FW_DIR_IN = 1 + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FW_OP_BLOCK, __pyx_int_2) < 0) __PYX_ERR(0, 1195, __pyx_L1_error) + + /* "dnet.pyx":1197 + * FW_OP_BLOCK = 2 + * + * FW_DIR_IN = 1 # <<<<<<<<<<<<<< + * FW_DIR_OUT = 2 + * + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FW_DIR_IN, __pyx_int_1) < 0) __PYX_ERR(0, 1197, __pyx_L1_error) + + /* "dnet.pyx":1198 + * + * FW_DIR_IN = 1 + * FW_DIR_OUT = 2 # <<<<<<<<<<<<<< + * + * cdef object rule_to_dict(fw_rule *rule): + */ + if (PyDict_SetItem(__pyx_d, __pyx_n_s_FW_DIR_OUT, __pyx_int_2) < 0) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "dnet.pyx":1257 + * raise OSError, __oserror() + * + * def add(self, d): # <<<<<<<<<<<<<< + * """Add a firewall rule specified as a dict. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_2fw_3add, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_fw_add, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__92)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1257, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_fw, __pyx_n_s_add, __pyx_t_4) < 0) __PYX_ERR(0, 1257, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_fw); + + /* "dnet.pyx":1276 + * raise OSError, __oserror() + * + * def delete(self, d): # <<<<<<<<<<<<<< + * """Delete a firewall rule specified as a dict.""" + * cdef fw_rule rule + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_2fw_5delete, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_fw_delete, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__93)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_fw, __pyx_n_s_delete, __pyx_t_4) < 0) __PYX_ERR(0, 1276, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_fw); + + /* "dnet.pyx":1284 + * raise OSError, __oserror() + * + * def loop(self, callback, arg=None): # <<<<<<<<<<<<<< + * """Iterate over the local firewall ruleset, invoking a user callback + * with each entry, returning the status of the callback routine. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_2fw_7loop, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_fw_loop, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__94)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__61); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_fw, __pyx_n_s_loop, __pyx_t_4) < 0) __PYX_ERR(0, 1284, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_fw); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_2fw_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_fw___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__95)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.fw cannot be converted to a Python object for pickling" + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_2fw_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_fw___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__96)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":1337 + * raise OSError, __oserror() + * + * def get(self, len): # <<<<<<<<<<<<<< + * """Return a string of random bytes. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_3get, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_get, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__98)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1337, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_rand, __pyx_n_s_get, __pyx_t_4) < 0) __PYX_ERR(0, 1337, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_rand); + + /* "dnet.pyx":1354 + * return s + * + * def set(self, buf): # <<<<<<<<<<<<<< + * """Initialize the PRNG from a known seed. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_5set, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_set, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__100)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_rand, __pyx_n_s_set, __pyx_t_4) < 0) __PYX_ERR(0, 1354, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_rand); + + /* "dnet.pyx":1362 + * rand_set(self.rand, buf, PyBytes_Size(buf)) + * + * def add(self, buf): # <<<<<<<<<<<<<< + * """Add additional entropy into the PRNG mix. + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_7add, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_add, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__101)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_rand, __pyx_n_s_add, __pyx_t_4) < 0) __PYX_ERR(0, 1362, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_rand); + + /* "dnet.pyx":1370 + * rand_add(self.rand, buf, PyBytes_Size(buf)) + * + * def uint8(self): # <<<<<<<<<<<<<< + * """Return a random 8-bit integer.""" + * return rand_uint8(self.rand) + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_9uint8, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_uint8, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__102)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1370, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_rand, __pyx_n_s_uint8, __pyx_t_4) < 0) __PYX_ERR(0, 1370, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_rand); + + /* "dnet.pyx":1374 + * return rand_uint8(self.rand) + * + * def uint16(self): # <<<<<<<<<<<<<< + * """Return a random 16-bit integer.""" + * return rand_uint16(self.rand) + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_11uint16, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_uint16, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__103)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1374, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_rand, __pyx_n_s_uint16, __pyx_t_4) < 0) __PYX_ERR(0, 1374, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_rand); + + /* "dnet.pyx":1378 + * return rand_uint16(self.rand) + * + * def uint32(self): # <<<<<<<<<<<<<< + * """Return a random 32-bit integer.""" + * return rand_uint32(self.rand) + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_13uint32, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_uint32, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__104)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1378, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_rand, __pyx_n_s_uint32, __pyx_t_4) < 0) __PYX_ERR(0, 1378, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_rand); + + /* "dnet.pyx":1382 + * return rand_uint32(self.rand) + * + * def xrange(self, start, stop=None): # <<<<<<<<<<<<<< + * """xrange([start,] stop) -> xrange object + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_15xrange, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_xrange_2, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__106)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_tuple__61); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_rand, __pyx_n_s_xrange, __pyx_t_4) < 0) __PYX_ERR(0, 1382, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_rand); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_19__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__107)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_4rand_21__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__108)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_13__rand_xrange_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_xrange___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__109)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.rand cannot be converted to a Python object for pickling" + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_13__rand_xrange_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_rand_xrange___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__110)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":1518 + * return tun_fileno(self.tun) + * + * def fileno(self): # <<<<<<<<<<<<<< + * """Return file descriptor for tunnel handle.""" + * return tun_fileno(self.tun) + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3tun_3fileno, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_tun_fileno, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__111)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1518, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_tun, __pyx_n_s_fileno, __pyx_t_4) < 0) __PYX_ERR(0, 1518, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_tun); + + /* "dnet.pyx":1522 + * return tun_fileno(self.tun) + * + * def send(self, pkt): # <<<<<<<<<<<<<< + * """Send an IP packet, returning the number of bytes sent + * or -1 on failure. + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3tun_5send, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_tun_send, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__112)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_tun, __pyx_n_s_send, __pyx_t_4) < 0) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_tun); + + /* "dnet.pyx":1531 + * return tun_send(self.tun, pkt, PyBytes_Size(pkt)) + * + * def recv(self): # <<<<<<<<<<<<<< + * """Return the next packet delivered to the tunnel interface.""" + * cdef int n + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3tun_7recv, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_tun_recv, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__114)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_tun, __pyx_n_s_recv, __pyx_t_4) < 0) __PYX_ERR(0, 1531, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_tun); + + /* "dnet.pyx":1539 + * return PyBytes_FromStringAndSize(self.buf, n) + * + * def close(self): # <<<<<<<<<<<<<< + * self.tun = tun_close(self.tun) + * + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3tun_9close, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_tun_close, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__115)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1539, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict((PyObject *)__pyx_ptype_4dnet_tun, __pyx_n_s_close, __pyx_t_4) < 0) __PYX_ERR(0, 1539, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + PyType_Modified(__pyx_ptype_4dnet_tun); + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3tun_13__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_tun___reduce_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__116)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_reduce_cython, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "self.tun cannot be converted to a Python object for pickling" + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_3tun_15__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_n_s_tun___setstate_cython, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__117)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_setstate_cython, __pyx_t_4) < 0) __PYX_ERR(1, 3, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * def __pyx_unpickle___addr_ip4_iter(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4dnet_37__pyx_unpickle___addr_ip4_iter, 0, __pyx_n_s_pyx_unpickle___addr_ip4_iter, NULL, __pyx_n_s_dnet, __pyx_d, ((PyObject *)__pyx_codeobj__119)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle___addr_ip4_iter, __pyx_t_4) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "dnet.pyx":1 + * # cython: language_level=3, boundscheck=False # <<<<<<<<<<<<<< + * # + * # dnet.pyx + */ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_4) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + if (__pyx_m) { + if (__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init dnet", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init dnet"); + } + __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 +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- 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 + +/* 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; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + 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); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *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 +} +#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 + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#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; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + 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; +} + +/* CIntToDigits */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; +#if CYTHON_PEP393_ENABLED + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); +#else + Py_UNICODE *udata; + uval = PyUnicode_FromUnicode(NULL, ulength); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_AS_UNICODE(uval); +#endif + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp; + PyObject *repeat = PyInt_FromSsize_t(uoffset - prepend_sign); + if (unlikely(!repeat)) goto done_or_error; + tmp = PyNumber_Multiply(padding, repeat); + Py_DECREF(repeat); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyNumber_Add(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyNumber_Add(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } +#endif + return uval; +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(int)*3+2]; + char *dpos, *end = digits + sizeof(int)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + int remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (int) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (int) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (int) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_CheckExact(s))) { + PyObject *result = PyUnicode_FromEncodedObject(s, NULL, "strict"); + Py_DECREF(s); + return result; + } + #endif + return __Pyx_PyObject_FormatAndDecref(s, f); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { + PyObject *result; + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); + return result; +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + CYTHON_MAYBE_UNUSED_VAR(max_char); +#if CYTHON_PEP393_ENABLED + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); +#else + result_uval = PyUnicode_FromUnicode(NULL, result_ulength); + if (unlikely(!result_uval)) return NULL; + result_ukind = sizeof(Py_UNICODE); + kind_shift = (result_ukind == 4) ? 2 : result_ukind - 1; + result_udata = PyUnicode_AS_UNICODE(result_uval); +#endif + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); + if (unlikely(__Pyx_PyUnicode_READY(uval))) + goto bad; + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + CYTHON_UNUSED_VAR(value_count); + return PyUnicode_Join(__pyx_empty_unicode, value_tuple); +#endif +} + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + __Pyx_PyThreadState_declare + CYTHON_UNUSED_VAR(cause); + 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 PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); + #elif CYTHON_FAST_THREAD_STATE + 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); + } +#else + 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); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} +#endif + +/* TupleAndListFromArray */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + Py_INCREF(__pyx_empty_tuple); + return __pyx_empty_tuple; + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + 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_VERSION_HEX < 0x030B0000) + 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 || CYTHON_COMPILING_IN_LIMITED_API + 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 +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = PyTuple_GET_SIZE(kwnames); + for (i = 0; i < n; i++) + { + if (s == PyTuple_GET_ITEM(kwnames, i)) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + int eq = __Pyx_PyUnicode_Equals(s, PyTuple_GET_ITEM(kwnames, i), Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs = PyTuple_GET_SIZE(kwnames); + PyObject *dict; + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; i= 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 *const *kwvalues, + 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; + int kwds_is_tuple = CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds)); + while (1) { + Py_XDECREF(key); key = NULL; + Py_XDECREF(value); value = NULL; + if (kwds_is_tuple) { + Py_ssize_t size; +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(kwds); +#else + size = PyTuple_Size(kwds); + if (size < 0) goto bad; +#endif + if (pos >= size) break; +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); + if (!key) goto bad; +#elif CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kwds, pos); +#else + key = PyTuple_GetItem(kwds, pos); + if (!key) goto bad; +#endif + value = kwvalues[pos]; + pos++; + } + else + { + if (!PyDict_Next(kwds, &pos, &key, &value)) break; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + } + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; +#if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(value); + Py_DECREF(key); +#endif + key = NULL; + value = NULL; + continue; + } +#if !CYTHON_AVOID_BORROWED_REFS + Py_INCREF(key); +#endif + Py_INCREF(value); + 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; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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 = ( + #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; +#if CYTHON_AVOID_BORROWED_REFS + value = NULL; +#endif + 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; + } + } + Py_XDECREF(key); + Py_XDECREF(value); + 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: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + Py_XDECREF(key); + Py_XDECREF(value); + return -1; +} + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL && !CYTHON_VECTORCALL +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; +} +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_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) { + return NULL; + } + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) { + return NULL; + } + #endif + 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 + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + 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 + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + #if PY_MAJOR_VERSION < 3 + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + #else + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + #endif + 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 -/* 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 +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject **args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) < 0) goto bad; } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); return result; } +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject **args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + #if PY_VERSION_HEX < 0x030800B1 + #if CYTHON_FAST_PYCCALL + if (PyCFunction_Check(func)) { + if (kwargs) { + return _PyCFunction_FastCallDict(func, args, nargs, kwargs); + } else { + return _PyCFunction_FastCallKeywords(func, args, nargs, NULL); + } + } + #if PY_VERSION_HEX >= 0x030700A1 + if (!kwargs && __Pyx_IS_TYPE(func, &PyMethodDescr_Type)) { + return _PyMethodDescr_FastCallKeywords(func, args, nargs, NULL); + } + #endif + #endif + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs); + } + #endif + #endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if PY_VERSION_HEX < 0x03090000 + vectorcallfunc f = _PyVectorcall_Function(func); + #else + vectorcallfunc f = PyVectorcall_Function(func); + #endif + if (f) { + return f(func, args, (size_t)nargs, NULL); + } + #elif defined(__Pyx_CyFunction_USED) && CYTHON_BACKPORT_VECTORCALL + if (__Pyx_CyFunction_CheckExact(func)) { + __pyx_vectorcallfunc f = __Pyx_CyFunction_func_vectorcall(func); + if (f) return f(func, args, (size_t)nargs, NULL); + } + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} -/* CIntToDigits */ -static const char DIGIT_PAIRS_10[2*10*10+1] = { - "00010203040506070809" - "10111213141516171819" - "20212223242526272829" - "30313233343536373839" - "40414243444546474849" - "50515253545556575859" - "60616263646566676869" - "70717273747576777879" - "80818283848586878889" - "90919293949596979899" -}; -static const char DIGIT_PAIRS_8[2*8*8+1] = { - "0001020304050607" - "1011121314151617" - "2021222324252627" - "3031323334353637" - "4041424344454647" - "5051525354555657" - "6061626364656667" - "7071727374757677" -}; -static const char DIGITS_HEX[2*16+1] = { - "0123456789abcdef" - "0123456789ABCDEF" -}; +/* PyObjectCall2Args */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args[3] = {NULL, arg1, arg2}; + return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} -/* BuildPyUnicode */ -static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, char* chars, int clength, - int prepend_sign, char padding_char) { - PyObject *uval; - Py_ssize_t uoffset = ulength - clength; -#if CYTHON_USE_UNICODE_INTERNALS - Py_ssize_t i; -#if CYTHON_PEP393_ENABLED - void *udata; - uval = PyUnicode_New(ulength, 127); - if (unlikely(!uval)) return NULL; - udata = PyUnicode_DATA(uval); +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* 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 + __Pyx_TypeName type_name; + 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 defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#elif PY_MAJOR_VERSION >= 3 + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif #else - Py_UNICODE *udata; - uval = PyUnicode_FromUnicode(NULL, ulength); - if (unlikely(!uval)) return NULL; - udata = PyUnicode_AS_UNICODE(uval); + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr))) + #endif #endif - if (uoffset > 0) { - i = 0; - if (prepend_sign) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); - i++; + { + 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; + } } - for (; i < uoffset; i++) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + 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); } - for (i=0; i < clength; i++) { - __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + 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 (likely(descr != NULL)) { + *method = descr; + return 0; } + type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); #else - { - PyObject *sign = NULL, *padding = NULL; - uval = NULL; - if (uoffset > 0) { - prepend_sign = !!prepend_sign; - if (uoffset > prepend_sign) { - padding = PyUnicode_FromOrdinal(padding_char); - if (likely(padding) && uoffset > prepend_sign + 1) { - PyObject *tmp; - PyObject *repeat = PyInt_FromSsize_t(uoffset - prepend_sign); - if (unlikely(!repeat)) goto done_or_error; - tmp = PyNumber_Multiply(padding, repeat); - Py_DECREF(repeat); - Py_DECREF(padding); - padding = tmp; - } - if (unlikely(!padding)) goto done_or_error; - } - if (prepend_sign) { - sign = PyUnicode_FromOrdinal('-'); - if (unlikely(!sign)) goto done_or_error; - } - } - uval = PyUnicode_DecodeASCII(chars, clength, NULL); - if (likely(uval) && padding) { - PyObject *tmp = PyNumber_Add(padding, uval); - Py_DECREF(uval); - uval = tmp; + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(name)); +#endif + __Pyx_DECREF_TypeName(type_name); + 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 */ +#if !(CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2) +static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { + PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); + Py_DECREF(method); + return result; +} +#endif +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { +#if CYTHON_VECTORCALL && __PYX_LIMITED_VERSION_HEX >= 0x030C00A2 + PyObject *args[2] = {obj, arg}; + (void) __Pyx_PyObject_GetMethod; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_Call2Args; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + 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); +#endif +} + +/* append */ +static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { + if (likely(PyList_CheckExact(L))) { + if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; + } else { + PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x); + if (unlikely(!retval)) + return -1; + Py_DECREF(retval); + } + return 0; +} + +/* KeywordStringCheck */ +static int __Pyx_CheckKeywordStrings( + PyObject *kw, + 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(kw, &pos, &key, 0)) + goto invalid_keyword; + return 1; +#else + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kw))) { + Py_ssize_t kwsize; +#if CYTHON_ASSUME_SAFE_MACROS + kwsize = PyTuple_GET_SIZE(kw); +#else + kwsize = PyTuple_Size(kw); + if (kwsize < 0) return 0; +#endif + if (unlikely(kwsize == 0)) + return 1; + if (!kw_allowed) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, 0); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + goto invalid_keyword; } - if (likely(uval) && sign) { - PyObject *tmp = PyNumber_Add(sign, uval); - Py_DECREF(uval); - uval = tmp; +#if PY_VERSION_HEX < 0x03090000 + for (pos = 0; pos < kwsize; pos++) { +#if CYTHON_ASSUME_SAFE_MACROS + key = PyTuple_GET_ITEM(kw, pos); +#else + key = PyTuple_GetItem(kw, pos); + if (!key) return 0; +#endif + if (unlikely(!PyUnicode_Check(key))) + goto invalid_keyword_type; } -done_or_error: - Py_XDECREF(padding); - Py_XDECREF(sign); +#endif + return 1; + } + while (PyDict_Next(kw, &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 - return uval; +invalid_keyword: + #if PY_MAJOR_VERSION < 3 + PyErr_Format(PyExc_TypeError, + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif + return 0; } -/* CIntToPyUnicode */ -static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { - char digits[sizeof(int)*3+2]; - char *dpos, *end = digits + sizeof(int)*3+2; - const char *hex_digits = DIGITS_HEX; - Py_ssize_t length, ulength; - int prepend_sign, last_one_off; - int remaining; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wconversion" +/* 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 - const int neg_one = (int) -1, const_zero = (int) 0; -#ifdef __Pyx_HAS_GCC_DIAGNOSTIC -#pragma GCC diagnostic pop + } + 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 - const int is_unsigned = neg_one > const_zero; - if (format_char == 'X') { - hex_digits += 16; - format_char = 'x'; + +/* 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 && PY_VERSION_HEX < 0x030d0000 + 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; } - remaining = value; - last_one_off = 0; - dpos = end; - do { - int digit_pos; - switch (format_char) { - case 'o': - digit_pos = abs((int)(remaining % (8*8))); - remaining = (int) (remaining / (8*8)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); - last_one_off = (digit_pos < 8); - break; - case 'd': - digit_pos = abs((int)(remaining % (10*10))); - remaining = (int) (remaining / (10*10)); - dpos -= 2; - memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); - last_one_off = (digit_pos < 10); - break; - case 'x': - *(--dpos) = hex_digits[abs((int)(remaining % 16))]; - remaining = (int) (remaining / 16); - break; - default: - assert(0); - break; - } - } while (unlikely(remaining != 0)); - if (last_one_off) { - assert(*dpos == '0'); - dpos++; +#elif CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + return NULL; } - length = end - dpos; - ulength = length; - prepend_sign = 0; - if (!is_unsigned && value <= neg_one) { - if (padding_char == ' ' || width <= length + 1) { - *(--dpos) = '-'; - ++length; - } else { - prepend_sign = 1; - } - ++ulength; + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; } - if (width > ulength) { - ulength = width; +#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); } - if (ulength == 1) { - return PyUnicode_FromOrdinal(*dpos); +#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); } - return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); } -/* PyObjectFormatAndDecref */ -static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { - if (unlikely(!s)) return NULL; - if (likely(PyUnicode_CheckExact(s))) return s; - #if PY_MAJOR_VERSION < 3 - if (likely(PyString_CheckExact(s))) { - PyObject *result = PyUnicode_FromEncodedObject(s, NULL, "strict"); - Py_DECREF(s); - return result; - } - #endif - return __Pyx_PyObject_FormatAndDecref(s, f); +/* 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); } -static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { - PyObject *result = PyObject_Format(s, f); - Py_DECREF(s); - return result; +#endif + +/* PyObjectCallNoArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); } -/* JoinPyUnicode */ -static PyObject* __Pyx_PyUnicode_Join(PyObject* value_tuple, Py_ssize_t value_count, Py_ssize_t result_ulength, - CYTHON_UNUSED Py_UCS4 max_char) { -#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS - PyObject *result_uval; - int result_ukind; - Py_ssize_t i, char_pos; - void *result_udata; -#if CYTHON_PEP393_ENABLED - result_uval = PyUnicode_New(result_ulength, max_char); - if (unlikely(!result_uval)) return NULL; - result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; - result_udata = PyUnicode_DATA(result_uval); -#else - result_uval = PyUnicode_FromUnicode(NULL, result_ulength); - if (unlikely(!result_uval)) return NULL; - result_ukind = sizeof(Py_UNICODE); - result_udata = PyUnicode_AS_UNICODE(result_uval); -#endif - char_pos = 0; - for (i=0; i < value_count; i++) { - int ukind; - Py_ssize_t ulength; - void *udata; - PyObject *uval = PyTuple_GET_ITEM(value_tuple, i); - if (unlikely(__Pyx_PyUnicode_READY(uval))) - goto bad; - ulength = __Pyx_PyUnicode_GET_LENGTH(uval); - if (unlikely(!ulength)) - continue; - if (unlikely(char_pos + ulength < 0)) - goto overflow; - ukind = __Pyx_PyUnicode_KIND(uval); - udata = __Pyx_PyUnicode_DATA(uval); - if (!CYTHON_PEP393_ENABLED || ukind == result_ukind) { - memcpy((char *)result_udata + char_pos * result_ukind, udata, (size_t) (ulength * result_ukind)); - } else { - #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030300F0 || defined(_PyUnicode_FastCopyCharacters) - _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); - #else - Py_ssize_t j; - for (j=0; j < ulength; j++) { - Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); - __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); - } - #endif - } - char_pos += ulength; +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + 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; } - return result_uval; -overflow: - PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); -bad: - Py_DECREF(result_uval); - return NULL; + type_name = __Pyx_PyType_GetName(type); + obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")", name, type_name, obj_type_name); + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d00A1 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); #else - result_ulength++; - value_count++; - return PyUnicode_Join(__pyx_empty_unicode, value_tuple); + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyString_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); #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); +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, + expected, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; } -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; + +/* 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); } -#endif -/* RaiseException */ -#if PY_MAJOR_VERSION < 3 -static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, - CYTHON_UNUSED PyObject *cause) { +/* 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) { + PyObject* exc_type; __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; - } + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return -1; + __Pyx_PyErr_Clear(); + return 0; } - 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; + return 0; +} + +/* UnpackItemEndCheck */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } + return __Pyx_IterFinish(); +} + +/* DictGetItem */ +#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + value = PyDict_GetItemWithError(d, key); + if (unlikely(!value)) { + if (!PyErr_Occurred()) { + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } } + return NULL; } - __Pyx_PyThreadState_assign - __Pyx_ErrRestore(type, value, tb); - return; -raise_error: - Py_XDECREF(value); - Py_XDECREF(type); - Py_XDECREF(tb); - return; + Py_INCREF(value); + return value; +} +#endif + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (unlikely(!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 -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; + 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 (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 ((!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; } - 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 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 { - 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; + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (mm && mm->mp_subscript) { + PyObject *r, *key = PyInt_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); } - 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 + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); } -bad: - Py_XDECREF(owned_instance); - return; -} #endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} -/* 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"; +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *empty_list = 0; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (unlikely(!py_import)) + goto bad; + if (!from_list) { + empty_list = PyList_New(0); + if (unlikely(!empty_list)) + goto bad; + from_list = empty_list; } - if (exact) { - more_or_less = "exactly"; + #endif + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if (strchr(__Pyx_MODULE_NAME, '.') != NULL) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!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 (unlikely(!py_level)) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, __pyx_d, empty_dict, from_list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, __pyx_d, empty_dict, from_list, level); + #endif + } } - 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); +bad: + Py_XDECREF(empty_dict); + Py_XDECREF(empty_list); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + return module; } -/* 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); +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + const char* module_name_str = 0; + PyObject* module_name = 0; + PyObject* module_dot = 0; + PyObject* full_name = 0; + PyErr_Clear(); + module_name_str = PyModule_GetName(module); + if (unlikely(!module_name_str)) { goto modbad; } + module_name = PyUnicode_FromString(module_name_str); + if (unlikely(!module_name)) { goto modbad; } + module_dot = PyUnicode_Concat(module_name, __pyx_kp_u__3); + if (unlikely(!module_dot)) { goto modbad; } + full_name = PyUnicode_Concat(module_dot, name); + if (unlikely(!full_name)) { goto modbad; } + #if PY_VERSION_HEX < 0x030700A1 || (CYTHON_COMPILING_IN_PYPY && PYPY_VERSION_NUM < 0x07030400) + { + PyObject *modules = PyImport_GetModuleDict(); + if (unlikely(!modules)) + goto modbad; + value = PyObject_GetItem(modules, full_name); + } #else - "%s() got multiple values for keyword argument '%s'", func_name, - PyString_AsString(kw_name)); + value = PyImport_GetModule(full_name); + #endif + modbad: + Py_XDECREF(full_name); + Py_XDECREF(module_dot); + Py_XDECREF(module_name); + } + if (unlikely(!value)) { + 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; } -/* 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; +/* 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); +} + +/* HasAttr */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d00A1 +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 (!r) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} +#endif + +/* FixUpExtensionType */ +#if CYTHON_USE_TYPE_SPECS +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if PY_VERSION_HEX > 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); +#else + const PyType_Slot *slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + int changed = 0; +#if !(PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON) + const +#endif + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { +#if PY_VERSION_HEX < 0x030900b1 + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; } - 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 if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; } - } - } 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; +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); +#if PY_VERSION_HEX >= 0x030800b4 + type->tp_vectorcall_offset = memb->offset; +#else + type->tp_print = (printfunc) memb->offset; +#endif + changed = 1; } - 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++; +#endif +#else + if ((0)); +#endif +#if PY_VERSION_HEX <= 0x030900b1 && CYTHON_COMPILING_IN_CPYTHON + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + if (unlikely(PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr) < 0)) { + Py_DECREF(descr); + return -1; + } + Py_DECREF(descr); + changed = 1; } +#endif } - } else - goto invalid_keyword_type; - if (kwds2) { - if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; - } else { - goto invalid_keyword; + memb++; } + if (changed) + PyType_Modified(type); } +#endif 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; -} - -/* 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 -/* 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++; +/* PyObjectCallMethod0 */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; } - result = PyEval_EvalFrameEx(f,0); - ++tstate->recursion_depth; - Py_DECREF(f); - --tstate->recursion_depth; + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: 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; + +/* ValidateBasesTuple */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_MACROS + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (n < 0) return -1; #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 && + for (i = 1; i < n; i++) + { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; #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; + PyTypeObject *b; +#if PY_MAJOR_VERSION < 3 + if (PyClass_Check(b0)) + { + PyErr_Format(PyExc_TypeError, "base class '%.200s' is an old-style class", + PyString_AS_STRING(((PyClassObject*)b0)->cl_name)); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; } - 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; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !(CYTHON_USE_TYPE_SLOTS || CYTHON_COMPILING_IN_PYPY) + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif } - if (kwargs != NULL) { - Py_ssize_t pos, i; - kwtuple = PyTuple_New(2 * nk); - if (kwtuple == NULL) { - result = NULL; - goto done; + return 0; +} +#endif + +/* PyType_Ready */ +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !(CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API) || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if PY_VERSION_HEX >= 0x030700a1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) + gc = PyImport_GetModule(__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; } - 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; + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; } - 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 + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; #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); + (void)__Pyx_PyObject_CallMethod0; #endif - Py_XDECREF(kwtuple); -done: - Py_LeaveRecursiveCall(); - return result; -} + r = PyType_Ready(t); +#if PY_VERSION_HEX >= 0x03050000 && !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } #endif + return r; #endif - -/* PyObjectCall */ -#if CYTHON_COMPILING_IN_CPYTHON -static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { - PyObject *result; - ternaryfunc call = Py_TYPE(func)->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 -/* 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); +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + __Pyx_TypeName type_name = __Pyx_PyType_GetName(tp); + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, attr_name); +#else + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%.400s'", + type_name, PyString_AS_STRING(attr_name)); +#endif + __Pyx_DECREF_TypeName(type_name); + 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); } - #endif - #if CYTHON_FAST_PYCCALL - if (__Pyx_PyFastCFunction_Check(function)) { - PyObject *args[2] = {arg1, arg2}; - return __Pyx_PyCFunction_FastCall(function, args, 2); + 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 - 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; + { + 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 -/* 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"); +/* 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 result; + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); } #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; +/* SetupReduce */ +#if !CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(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 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); +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; } #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 (__Pyx_PyFastCFunction_Check(func)) { - return __Pyx_PyCFunction_FastCall(func, &arg, 1); + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } #endif + if (object_getstate != getstate) { + goto __PYX_GOOD; } } - return __Pyx__PyObject_CallOneArg(func, arg); -} +#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 -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; -} + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; #endif - -/* 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 + 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 - #ifdef __Pyx_CyFunction_USED - if (likely(PyFunction_Check(descr) || __Pyx_CyFunction_Check(descr))) - #else - if (likely(PyFunction_Check(descr))) - #endif + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; #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; + 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_GetAttrStrNoError(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); } } - 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; + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); } + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); #endif - *method = attr; - return 0; + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; } +#endif -/* 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); +/* FetchSharedCythonModule */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef((char*) __PYX_ABI_MODULE_NAME); } -/* append */ -static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) { - if (likely(PyList_CheckExact(L))) { - if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1; - } else { - PyObject* retval = __Pyx_PyObject_CallMethod1(L, __pyx_n_s_append, x); - if (unlikely(!retval)) - return -1; - Py_DECREF(retval); +/* FetchCommonType */ +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t basicsize, + Py_ssize_t expected_basicsize) { + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; } - 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 (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; } - 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; } - -/* 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); +#if !CYTHON_USE_TYPE_SPECS +static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) { + PyObject* abi_module; + const char* object_name; + PyTypeObject *cached_type = NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + object_name = strrchr(type->tp_name, '.'); + object_name = object_name ? object_name+1 : type->tp_name; + cached_type = (PyTypeObject*) PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + if (__Pyx_VerifyCachedType( + (PyObject *)cached_type, + object_name, + cached_type->tp_basicsize, + type->tp_basicsize) < 0) { + goto bad; + } + goto done; + } + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + if (PyType_Ready(type) < 0) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, (PyObject *)type) < 0) + goto bad; + Py_INCREF(type); + cached_type = type; +done: + Py_DECREF(abi_module); + return cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} #else - dictptr = _PyObject_GetDictPtr(obj); +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module, *cached_type = NULL; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) return NULL; + cached_type = PyObject_GetAttrString(abi_module, object_name); + if (cached_type) { + Py_ssize_t basicsize; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) goto bad; +#else + basicsize = likely(PyType_Check(cached_type)) ? ((PyTypeObject*) cached_type)->tp_basicsize : -1; #endif + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + basicsize, + spec->basicsize) < 0) { + goto bad; + } + goto done; } - 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); + if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad; + PyErr_Clear(); + CYTHON_UNUSED_VAR(module); + cached_type = __Pyx_PyType_FromModuleAndSpec(abi_module, spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + if (PyObject_SetAttrString(abi_module, object_name, cached_type) < 0) goto bad; +done: + Py_DECREF(abi_module); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; } #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 +/* PyVectorcallFastCallDict */ +#if CYTHON_METH_FASTCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) { - 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())) { + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i, pos; + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); 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); + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; } -#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); + kwvalues = newargs + nargs; + pos = i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (PyDict_Next(kw, &pos, &key, &value)) { + keys_are_strings &= Py_TYPE(key)->tp_flags; + Py_INCREF(key); + Py_INCREF(value); + PyTuple_SET_ITEM(kwnames, i, key); + kwvalues[i] = value; + i++; } - PyErr_Clear(); -#endif - return __Pyx_GetBuiltinName(name); + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; } - -/* 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); +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + if (likely(kw == NULL) || PyDict_GET_SIZE(kw) == 0) { + return vc(func, args, nargs, NULL); + } + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); } #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); +/* CythonFunctionShared */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; } + return 0; +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void *cfunc) { + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} #endif -#ifdef __Pyx_CyFunction_USED - if (likely(PyCFunction_Check(func) || __Pyx_CyFunction_Check(func))) +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); #else - if (likely(PyCFunction_Check(func))) + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); #endif - { - if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) { - return __Pyx_PyObject_CallMethO(func, NULL); +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) +{ + CYTHON_UNUSED_VAR(closure); + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { +#if PY_MAJOR_VERSION >= 3 + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#else + op->func_doc = PyString_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); +#endif + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; } +#endif } - return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL); + Py_INCREF(op->func_doc); + return op->func_doc; } -#endif - -/* ArgTypeTest */ -static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) { - 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; + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; } - PyErr_Format(PyExc_TypeError, - "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", - name, type->tp_name, Py_TYPE(obj)->tp_name); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_doc, value); 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; ifunc_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#elif PY_MAJOR_VERSION >= 3 + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#else + op->func_name = PyString_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; } + Py_INCREF(op->func_name); + return op->func_name; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); +#if PY_MAJOR_VERSION >= 3 + if (unlikely(value == NULL || !PyUnicode_Check(value))) +#else + if (unlikely(value == NULL || !PyString_Check(value))) #endif - for (i=0; ifunc_name, value); return 0; } -static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) { - PyObject *exc_type = tstate->curexc_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); +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_qualname); + return op->func_qualname; } -#endif - -/* GetAttr */ -static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { -#if CYTHON_USE_TYPE_SLOTS +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); #if PY_MAJOR_VERSION >= 3 - if (likely(PyUnicode_Check(n))) + if (unlikely(value == NULL || !PyUnicode_Check(value))) #else - if (likely(PyString_Check(n))) -#endif - return __Pyx_PyObject_GetAttrStr(o, n); + if (unlikely(value == NULL || !PyString_Check(value))) #endif - return PyObject_GetAttr(o, n); + { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + return 0; } - -/* 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 PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; } -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); +static int +__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL)) { + PyErr_SetString(PyExc_TypeError, + "function's dictionary may not be deleted"); + return -1; + } + if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "setting function's dictionary to a non-dict"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->func_dict, value); + return 0; } - -/* 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); +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; } - -/* 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"); +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; } - -/* 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; +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_tuple; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; } else { - return -1; + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->defaults_kwdict; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; } } + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); return 0; +} +static PyObject * +__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = op->func_annotations; + CYTHON_UNUSED_VAR(context); + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + int is_coroutine; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; +#if PY_VERSION_HEX >= 0x03050000 + if (is_coroutine) { + PyObject *module, *fromlist, *marker = __pyx_n_s_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_n_s_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + op->func_is_coroutine = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(op->func_is_coroutine)) { + return __Pyx_NewRef(op->func_is_coroutine); + } +ignore: + PyErr_Clear(); + } +#endif + op->func_is_coroutine = __Pyx_PyBool_FromLong(is_coroutine); + return __Pyx_NewRef(op->func_is_coroutine); +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0}, + {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {(char *) "_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if CYTHON_USE_TYPE_SPECS + {(char *) "__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#if CYTHON_METH_FASTCALL +#if CYTHON_BACKPORT_VECTORCALL + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else +#if !CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#endif +#endif +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + CYTHON_UNUSED_VAR(args); +#if PY_MAJOR_VERSION >= 3 + Py_INCREF(m->func_qualname); + return m->func_qualname; #else - if (unlikely(PyErr_Occurred())) { - if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) { - PyErr_Clear(); - return 0; - } else { - return -1; - } - } - return 0; + return PyString_FromString(((PyCFunctionObject*)m)->m_ml->ml_name); #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; -} - -/* DictGetItem */ -#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY -static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { - PyObject *value; - value = PyDict_GetItemWithError(d, key); - if (unlikely(!value)) { - if (!PyErr_Occurred()) { - if (unlikely(PyTuple_Check(key))) { - PyObject* args = PyTuple_Pack(1, key); - if (likely(args)) { - PyErr_SetObject(PyExc_KeyError, args); - Py_DECREF(args); - } - } else { - PyErr_SetObject(PyExc_KeyError, key); - } - } +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if PY_VERSION_HEX < 0x030500A0 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif + op->func_dict = NULL; + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults_pyobjects = 0; + op->defaults_size = 0; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); return NULL; } - Py_INCREF(value); - return value; -} #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; + return (PyObject *) op; } -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); +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif + Py_CLEAR(m->func_dict); + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API +#if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); } - 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; +#endif +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_XDECREF(pydefaults[i]); + PyObject_Free(m->defaults); + m->defaults = NULL; } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); #else - return PySequence_GetItem(o, i); + Py_VISIT(((PyCFunctionObject*)m)->m_module); #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; + Py_VISIT(m->func_dict); + Py_VISIT(m->func_name); + Py_VISIT(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + Py_VISIT(m->func_code); +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); +#endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + if (m->defaults) { + PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m); + int i; + for (i = 0; i < m->defaults_pyobjects; i++) + Py_VISIT(pydefaults[i]); } - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ +#if PY_MAJOR_VERSION >= 3 + return PyUnicode_FromFormat("", + op->func_qualname, (void *)op); #else - return PySequence_GetItem(o, i); + return PyString_FromFormat("", + PyString_AsString(op->func_qualname), (void *)op); #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; +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyObject *py_name = NULL; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void*)meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; } - } 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(); - } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_MACROS + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; } - return m->sq_item(o, i); +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, + "%.200S() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, size); + Py_DECREF(py_name); +#else + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + f->m_ml->ml_name, size); +#endif + return NULL; } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; } +#if CYTHON_COMPILING_IN_LIMITED_API + py_name = __Pyx_CyFunction_get_name((__pyx_CyFunctionObject*)func, NULL); + if (!py_name) return NULL; + PyErr_Format(PyExc_TypeError, "%.200S() takes no keyword arguments", + py_name); + Py_DECREF(py_name); #else - if (is_list || PySequence_Check(o)) { - return PySequence_GetItem(o, i); - } + PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments", + f->m_ml->ml_name); #endif - return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); + 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; +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif } - 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 +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_MACROS + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(!argc) < 0) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); +#if PY_MAJOR_VERSION > 2 + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); +#else + PyErr_SetString(PyExc_TypeError, + "unbound method needs an argument"); +#endif + return NULL; } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); } -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; + return result; } - -/* 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; +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + PyErr_Format(PyExc_TypeError, "%.200s() needs an argument", + ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(PyTuple_GET_SIZE(kwnames))) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no keyword arguments", ((PyCFunctionObject*)cyfunc)->m_ml->ml_name); + return -1; } + return ret; } - -/* 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); +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; #else - "'%.50s' object has no attribute '%.400s'", - tp->tp_name, PyString_AS_STRING(attr_name)); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #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); + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - 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; - } + if (unlikely(nargs != 0)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; } - return descr; + return def->ml_meth(self, NULL); } +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - -/* 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); + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); + if (unlikely(nargs != 1)) { + PyErr_Format(PyExc_TypeError, + "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)", + def->ml_name, nargs); + return NULL; + } + return def->ml_meth(self, args[0]); } +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #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); + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } + return ((_PyCFunctionFastWithKeywords)(void(*)(void))def->ml_meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyMethodDef* def = ((PyCFunctionObject*)cyfunc)->m_ml; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); +#if CYTHON_BACKPORT_VECTORCALL + Py_ssize_t nargs = (Py_ssize_t)nargsf; +#else + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); #endif - result = __Pyx_PyObject_GetAttrStr(obj, attr_name); - if (unlikely(!result)) { - __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + PyObject *self; + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + self = ((PyCFunctionObject*)cyfunc)->m_self; + break; + default: + return NULL; } - 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; + return ((__Pyx_PyCMethod)(void(*)(void))def->ml_meth)(self, cls, args, (size_t)nargs, kwnames); } -static int __Pyx_setup_reduce(PyObject* type_obj) { - int ret = 0; - PyObject *object_reduce = NULL; - PyObject *object_getstate = NULL; - PyObject *object_reduce_ex = NULL; - PyObject *reduce = NULL; - PyObject *reduce_ex = NULL; - PyObject *reduce_cython = NULL; - PyObject *setstate = NULL; - PyObject *setstate_cython = NULL; - PyObject *getstate = NULL; -#if CYTHON_USE_PYTYPE_LOOKUP - getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#endif +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if (defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; #else - getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); - if (!getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } +static PyTypeObject __pyx_CyFunctionType_type = { + PyVarObject_HEAD_INIT(0, 0) + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + (destructor) __Pyx_CyFunction_dealloc, +#if !CYTHON_METH_FASTCALL + 0, +#elif CYTHON_BACKPORT_VECTORCALL + (printfunc)offsetof(__pyx_CyFunctionObject, func_vectorcall), +#else + offsetof(PyCFunctionObject, vectorcall), #endif - if (getstate) { -#if CYTHON_USE_PYTYPE_LOOKUP - object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); + 0, + 0, +#if PY_MAJOR_VERSION < 3 + 0, #else - object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); - if (!object_getstate && PyErr_Occurred()) { - goto __PYX_BAD; - } + 0, #endif - if (object_getstate != getstate) { - goto __PYX_GOOD; - } - } -#if CYTHON_USE_PYTYPE_LOOKUP - object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + (reprfunc) __Pyx_CyFunction_repr, + 0, + 0, + 0, + 0, + __Pyx_CyFunction_CallAsMethod, + 0, + 0, + 0, + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if defined(_Py_TPFLAGS_HAVE_VECTORCALL) && CYTHON_METH_FASTCALL + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + 0, + (traverseproc) __Pyx_CyFunction_traverse, + (inquiry) __Pyx_CyFunction_clear, + 0, +#if PY_VERSION_HEX < 0x030500A0 + offsetof(__pyx_CyFunctionObject, func_weakreflist), #else - object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + offsetof(PyCFunctionObject, m_weakreflist), #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; + 0, + 0, + __pyx_CyFunction_methods, + __pyx_CyFunction_members, + __pyx_CyFunction_getsets, + 0, + 0, + __Pyx_PyMethod_New, + 0, + offsetof(__pyx_CyFunctionObject, func_dict), + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +#if PY_VERSION_HEX >= 0x030400a1 + 0, +#endif +#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, +#endif +#if __PYX_NEED_TP_PRINT_SLOT + 0, +#endif +#if PY_VERSION_HEX >= 0x030C0000 + 0, +#endif +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, +#endif +}; +#endif +static int __pyx_CyFunction_init(PyObject *module) { +#if CYTHON_USE_TYPE_SPECS + __pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_CyFunctionType_spec, NULL); #else - object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; + CYTHON_UNUSED_VAR(module); + __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type); #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); - } + if (unlikely(__pyx_CyFunctionType == NULL)) { + return -1; } - 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); - Py_XDECREF(object_getstate); - Py_XDECREF(getstate); -#endif - Py_XDECREF(reduce); - Py_XDECREF(reduce_ex); - Py_XDECREF(reduce_cython); - Py_XDECREF(setstate); - Py_XDECREF(setstate_cython); - return ret; + return 0; +} +static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_Malloc(size); + if (unlikely(!m->defaults)) + return PyErr_NoMemory(); + memset(m->defaults, 0, size); + m->defaults_pyobjects = pyobjects; + m->defaults_size = size; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; } /* CLineInTraceback */ #ifndef CYTHON_CLINE_IN_TRACEBACK -static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int c_line) { +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { PyObject *use_cline; PyObject *ptype, *pvalue, *ptraceback; #if CYTHON_COMPILING_IN_CPYTHON PyObject **cython_runtime_dict; #endif + CYTHON_MAYBE_UNUSED_VAR(tstate); if (unlikely(!__pyx_cython_runtime)) { return c_line; } @@ -25117,7 +36469,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int } else #endif { - PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(__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); @@ -25139,6 +36491,7 @@ static int __Pyx_CLineForTraceback(CYTHON_NCP_UNUSED PyThreadState *tstate, int #endif /* CodeObjectCache */ +#if !CYTHON_COMPILING_IN_LIMITED_API 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) { @@ -25217,17 +36570,101 @@ static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { __pyx_code_cache.count++; Py_INCREF(code_object); } +#endif /* AddTraceback */ #include "compile.h" #include "frameobject.h" #include "traceback.h" -#if PY_VERSION_HEX >= 0x030b00a6 +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API #ifndef Py_BUILD_CORE #define Py_BUILD_CORE 1 #endif #include "internal/pycore_frame.h" #endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result; + result = PyObject_Call(replace, __pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + #if __PYX_LIMITED_VERSION_HEX < 0x030780000 + { + PyObject *compiled = NULL, *result = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL; + compiled = Py_CompileString( + "out = type(code)(\n" + " code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n" + " code.co_flags, code.co_code, code.co_consts, code.co_names,\n" + " code.co_varnames, code.co_filename, co_name, co_firstlineno,\n" + " code.co_lnotab)\n", "", Py_file_input); + if (!compiled) return NULL; + result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict); + Py_DECREF(compiled); + if (!result) PyErr_Print(); + Py_DECREF(result); + result = PyDict_GetItemString(scratch_dict, "out"); + if (result) Py_INCREF(result); + return result; + } + #else + return NULL; + #endif +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + (void) __pyx_cfilenm; + (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + py_funcname = PyUnicode_FromString(funcname); + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( const char *funcname, int c_line, int py_line, const char *filename) { @@ -25262,6 +36699,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( 0, 0, 0, + 0, __pyx_empty_bytes, /*PyObject *code,*/ __pyx_empty_tuple, /*PyObject *consts,*/ __pyx_empty_tuple, /*PyObject *names,*/ @@ -25277,7 +36715,7 @@ static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( #else py_code = PyCode_NewEmpty(filename, funcname, py_line); #endif - Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + Py_XDECREF(py_funcname); return py_code; bad: Py_XDECREF(py_funcname); @@ -25324,6 +36762,7 @@ static void __Pyx_AddTraceback(const char *funcname, int c_line, Py_XDECREF(py_code); Py_XDECREF(py_frame); } +#endif /* CIntFromPyVerify */ #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ @@ -25380,8 +36819,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_long(unsigned long valu { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(unsigned long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -25398,7 +36863,7 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(unsigned long) < sizeof(long)) { + if ((sizeof(unsigned long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(unsigned long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -25412,40 +36877,45 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) { 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])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + 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 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; + 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; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -25458,109 +36928,181 @@ static CYTHON_INLINE unsigned long __Pyx_PyInt_As_unsigned_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(unsigned long) <= sizeof(unsigned long)) { + 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)) { + } 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]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + 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 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) - 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 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) - 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; + 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; + break; + } } #endif - if (sizeof(unsigned long) <= sizeof(long)) { + 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)) { + } 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 PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) 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); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (unsigned long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (unsigned long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (unsigned long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (unsigned long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(unsigned long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((unsigned long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(unsigned long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((unsigned long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((unsigned long) 1) << (sizeof(unsigned long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (unsigned long) -1; } } else { @@ -25594,7 +37136,7 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(int) < sizeof(long)) { + if ((sizeof(int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -25608,40 +37150,45 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { 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])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + 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 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; + 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; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -25654,109 +37201,181 @@ static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(int) <= sizeof(unsigned long)) { + 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)) { + } 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]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + 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 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) - 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 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) - 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; + 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; + break; + } } #endif - if (sizeof(int) <= sizeof(long)) { + 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)) { + } 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 PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) 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); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (int) -1; } } else { @@ -25790,7 +37409,7 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(unsigned int) < sizeof(long)) { + if ((sizeof(unsigned int) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(unsigned int, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -25804,40 +37423,45 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { 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 int) 0; - case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, digits[0]) - case 2: - if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT) { - return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT) { - return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + break; + case 3: + if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned 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(unsigned int) >= 4 * PyLong_SHIFT) { - return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + break; + case 4: + if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned 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(unsigned int) >= 4 * PyLong_SHIFT)) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -25850,109 +37474,181 @@ static CYTHON_INLINE unsigned int __Pyx_PyInt_As_unsigned_int(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(unsigned int) <= sizeof(unsigned long)) { + if ((sizeof(unsigned int) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned 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 (unsigned int) 0; - case -1: __PYX_VERIFY_RETURN_INT(unsigned int, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(unsigned int, digit, +digits[0]) - case -2: - if (8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { - return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(unsigned int) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { - return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + break; + case 2: + if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { - return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + break; + case -3: + if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(unsigned int) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { - return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + break; + case 3: + if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned 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(unsigned int) - 1 > 4 * PyLong_SHIFT) { - return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + break; + case -4: + if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned 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(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(unsigned int) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned 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(unsigned int) - 1 > 4 * PyLong_SHIFT) { - return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + break; + case 4: + if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned 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(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(unsigned int) <= sizeof(long)) { + if ((sizeof(unsigned int) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned int) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned 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 unsigned int val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) 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); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (unsigned int) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (unsigned int) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned int) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (unsigned int) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (unsigned int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((unsigned int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((unsigned int) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (unsigned int) -1; } } else { @@ -25986,7 +37682,7 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(long) < sizeof(long)) { + if ((sizeof(long) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -26000,40 +37696,45 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { 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])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + 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 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; + 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; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -26046,109 +37747,181 @@ static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(long) <= sizeof(unsigned long)) { + 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)) { + } 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]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + 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 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) - 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 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) - 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; + 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; + break; + } } #endif - if (sizeof(long) <= sizeof(long)) { + 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)) { + } 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 PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) 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); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (long) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (long) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (long) -1; } } else { @@ -26202,8 +37975,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -26220,7 +38019,7 @@ static CYTHON_INLINE unsigned short __Pyx_PyInt_As_unsigned_short(PyObject *x) { const int is_unsigned = neg_one > const_zero; #if PY_MAJOR_VERSION < 3 if (likely(PyInt_Check(x))) { - if (sizeof(unsigned short) < sizeof(long)) { + if ((sizeof(unsigned short) < sizeof(long))) { __PYX_VERIFY_RETURN_INT(unsigned short, long, PyInt_AS_LONG(x)) } else { long val = PyInt_AS_LONG(x); @@ -26234,40 +38033,45 @@ static CYTHON_INLINE unsigned short __Pyx_PyInt_As_unsigned_short(PyObject *x) { 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 short) 0; - case 1: __PYX_VERIFY_RETURN_INT(unsigned short, digit, digits[0]) - case 2: - if (8 * sizeof(unsigned short) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned short) >= 2 * PyLong_SHIFT) { - return (unsigned short) (((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned short, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(unsigned short) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned short) >= 2 * PyLong_SHIFT)) { + return (unsigned short) (((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + } } - } - break; - case 3: - if (8 * sizeof(unsigned short) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned short) >= 3 * PyLong_SHIFT) { - return (unsigned short) (((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + break; + case 3: + if ((8 * sizeof(unsigned short) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned short) >= 3 * PyLong_SHIFT)) { + return (unsigned short) (((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + } } - } - break; - case 4: - if (8 * sizeof(unsigned short) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, 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 short) >= 4 * PyLong_SHIFT) { - return (unsigned short) (((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + break; + case 4: + if ((8 * sizeof(unsigned short) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, 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 short) >= 4 * PyLong_SHIFT)) { + return (unsigned short) (((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0])); + } } - } - break; + break; + } } #endif -#if CYTHON_COMPILING_IN_CPYTHON +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 if (unlikely(Py_SIZE(x) < 0)) { goto raise_neg_overflow; } @@ -26280,109 +38084,181 @@ static CYTHON_INLINE unsigned short __Pyx_PyInt_As_unsigned_short(PyObject *x) { goto raise_neg_overflow; } #endif - if (sizeof(unsigned short) <= sizeof(unsigned long)) { + if ((sizeof(unsigned short) <= sizeof(unsigned long))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned short, unsigned long, PyLong_AsUnsignedLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned short) <= sizeof(unsigned PY_LONG_LONG)) { + } else if ((sizeof(unsigned short) <= sizeof(unsigned PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned short, 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 short) 0; - case -1: __PYX_VERIFY_RETURN_INT(unsigned short, sdigit, (sdigit) (-(sdigit)digits[0])) - case 1: __PYX_VERIFY_RETURN_INT(unsigned short, digit, +digits[0]) - case -2: - if (8 * sizeof(unsigned short) - 1 > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT) { - return (unsigned short) (((unsigned short)-1)*(((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned short, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(unsigned short) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned short) (((unsigned short)-1)*(((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } } - } - break; - case 2: - if (8 * sizeof(unsigned short) > 1 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT) { - return (unsigned short) ((((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + break; + case 2: + if ((8 * sizeof(unsigned short) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned short) ((((((unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } } - } - break; - case -3: - if (8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT) { - return (unsigned short) (((unsigned short)-1)*(((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + break; + case -3: + if ((8 * sizeof(unsigned short) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned short) (((unsigned short)-1)*(((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } } - } - break; - case 3: - if (8 * sizeof(unsigned short) > 2 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) - } else if (8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT) { - return (unsigned short) ((((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + break; + case 3: + if ((8 * sizeof(unsigned short) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned short) ((((((((unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } } - } - break; - case -4: - if (8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, 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 short) - 1 > 4 * PyLong_SHIFT) { - return (unsigned short) (((unsigned short)-1)*(((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + break; + case -4: + if ((8 * sizeof(unsigned short) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, 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 short) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned short) (((unsigned short)-1)*(((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } } - } - break; - case 4: - if (8 * sizeof(unsigned short) > 3 * PyLong_SHIFT) { - if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { - __PYX_VERIFY_RETURN_INT(unsigned short, 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 short) - 1 > 4 * PyLong_SHIFT) { - return (unsigned short) ((((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + break; + case 4: + if ((8 * sizeof(unsigned short) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned short, 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 short) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned short) ((((((((((unsigned short)digits[3]) << PyLong_SHIFT) | (unsigned short)digits[2]) << PyLong_SHIFT) | (unsigned short)digits[1]) << PyLong_SHIFT) | (unsigned short)digits[0]))); + } } - } - break; + break; + } } #endif - if (sizeof(unsigned short) <= sizeof(long)) { + if ((sizeof(unsigned short) <= sizeof(long))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned short, long, PyLong_AsLong(x)) #ifdef HAVE_LONG_LONG - } else if (sizeof(unsigned short) <= sizeof(PY_LONG_LONG)) { + } else if ((sizeof(unsigned short) <= sizeof(PY_LONG_LONG))) { __PYX_VERIFY_RETURN_INT_EXC(unsigned short, 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 short val; PyObject *v = __Pyx_PyNumber_IntOrLong(x); - #if PY_MAJOR_VERSION < 3 +#if PY_MAJOR_VERSION < 3 if (likely(v) && !PyLong_Check(v)) { PyObject *tmp = v; v = PyNumber_Long(tmp); Py_DECREF(tmp); } - #endif +#endif if (likely(v)) { + int ret = -1; +#if PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) 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); + ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); +#else + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + long idigit; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (unlikely(!PyLong_CheckExact(v))) { + PyObject *tmp = v; + v = PyNumber_Long(v); + assert(PyLong_CheckExact(v)); + Py_DECREF(tmp); + if (unlikely(!v)) return (unsigned short) -1; + } +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(x) == 0) + return (unsigned short) 0; + is_negative = Py_SIZE(x) < 0; +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned short) -1; + is_negative = result == 1; + } +#endif + if (is_unsigned && unlikely(is_negative)) { + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + if (unlikely(!stepval)) + return (unsigned short) -1; + } else { + stepval = __Pyx_NewRef(v); + } + val = (unsigned short) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(unsigned short) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + val |= ((unsigned short) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + if (Py_SIZE(stepval) == 0) + goto unpacking_done; + #endif + } + idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(unsigned short) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((unsigned short) idigit) << bits; + #if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030B0000 + unpacking_done: + #endif + if (!is_unsigned) { + if (unlikely(val & (((unsigned short) 1) << (sizeof(unsigned short) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); +#endif Py_DECREF(v); if (likely(!ret)) return val; } -#endif return (unsigned short) -1; } } else { @@ -26436,8 +38312,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_short(unsigned short va { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(unsigned short), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned short)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -26474,8 +38376,34 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_unsigned_int(unsigned int value) { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(unsigned int), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(unsigned int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif } } @@ -26512,16 +38440,58 @@ static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { { int one = 1; int little = (int)*(unsigned char *)&one; unsigned char *bytes = (unsigned char *)&value; +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 return _PyLong_FromByteArray(bytes, sizeof(long), little, !is_unsigned); +#else + PyObject *from_bytes, *result = NULL; + PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + arg_tuple = PyTuple_Pack(2, py_bytes, order_str); + if (!arg_tuple) goto limited_bad; + if (!is_unsigned) { + kwds = PyDict_New(); + if (!kwds) goto limited_bad; + if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad; + } + result = PyObject_Call(from_bytes, arg_tuple, kwds); + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(arg_tuple); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; +#endif + } +} + +/* FormatTypeName */ +#if CYTHON_COMPILING_IN_LIMITED_API +static __Pyx_TypeName +__Pyx_PyType_GetName(PyTypeObject* tp) +{ + PyObject *name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_n_s_name_2); + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) { + PyErr_Clear(); + Py_XDECREF(name); + name = __Pyx_NewRef(__pyx_n_s__120); } + return name; } +#endif /* FastTypeChecks */ #if CYTHON_COMPILING_IN_CPYTHON static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { while (a) { - a = a->tp_base; + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); if (a == b) return 1; } @@ -26542,6 +38512,22 @@ static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { } return __Pyx_InBases(a, b); } +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} #if PY_MAJOR_VERSION == 2 static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { PyObject *exception, *value, *tb; @@ -26566,11 +38552,11 @@ static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc } #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); + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); } - return res; } #endif static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { @@ -26618,47 +38604,78 @@ static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObj #endif /* CheckBinaryVersion */ -static int __Pyx_check_binary_version(void) { - char ctversion[5]; - int same=1, i, found_dot; - const char* rt_from_call = Py_GetVersion(); - PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); - found_dot = 0; - for (i = 0; i < 4; i++) { - if (!ctversion[i]) { - same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); - break; +static unsigned long __Pyx_get_runtime_version(void) { +#if __PYX_LIMITED_VERSION_HEX >= 0x030B00A4 + return Py_Version & ~0xFFUL; +#else + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; } - if (rt_from_call[i] != ctversion[i]) { - same = 0; + version += factor * digit; + if (rt_version[i] != '.') break; - } + digit = 0; + factor >>= 8; + ++i; } - if (!same) { - char rtversion[5] = {'\0'}; + return version; +#endif +} +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { char message[200]; - for (i=0; i<4; ++i) { - if (rt_from_call[i] == '.') { - if (found_dot) break; - found_dot = 1; - } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { - break; - } - rtversion[i] = rt_from_call[i]; - } PyOS_snprintf(message, sizeof(message), - "compiletime version %s of module '%.100s' " - "does not match runtime version %s", - ctversion, __Pyx_MODULE_NAME, rtversion); + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); return PyErr_WarnEx(NULL, message, 1); } - return 0; } /* InitStrings */ +#if PY_MAJOR_VERSION >= 3 +static int __Pyx_InitString(__Pyx_StringTabEntry t, PyObject **str) { + if (t.is_unicode | t.is_str) { + if (t.intern) { + *str = PyUnicode_InternFromString(t.s); + } else if (t.encoding) { + *str = PyUnicode_Decode(t.s, t.n - 1, t.encoding, NULL); + } else { + *str = PyUnicode_FromStringAndSize(t.s, t.n - 1); + } + } else { + *str = PyBytes_FromStringAndSize(t.s, t.n - 1); + } + if (!*str) + return -1; + if (PyObject_Hash(*str) == -1) + return -1; + return 0; +} +#endif static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { while (t->p) { - #if PY_MAJOR_VERSION < 3 + #if PY_MAJOR_VERSION >= 3 + __Pyx_InitString(*t, t->p); + #else if (t->is_unicode) { *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); } else if (t->intern) { @@ -26666,30 +38683,34 @@ static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { } 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; + #endif ++t; } return 0; } +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { - return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); } static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { Py_ssize_t ignore; @@ -26744,7 +38765,7 @@ static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ return __Pyx_PyUnicode_AsStringAndSize(o, length); } else #endif -#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) +#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) if (PyByteArray_Check(o)) { *length = PyByteArray_GET_SIZE(o); return PyByteArray_AS_STRING(o); @@ -26773,22 +38794,26 @@ static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { return retval; } static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result)); #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)) { + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } + __Pyx_DECREF_TypeName(result_type_name); return result; } #endif PyErr_Format(PyExc_TypeError, - "__%.4s__ returned non-%.4s (type %.200s)", - type_name, type_name, Py_TYPE(result)->tp_name); + "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")", + type_name, type_name, result_type_name); + __Pyx_DECREF_TypeName(result_type_name); Py_DECREF(result); return NULL; } @@ -26854,13 +38879,11 @@ static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* 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; + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); switch (size) { case 2: if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { @@ -26928,4 +38951,12 @@ static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { } +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ #endif /* Py_PYTHON_H */ diff --git a/python/dnet.pyx b/python/dnet.pyx index b2f5662..4e3604f 100644 --- a/python/dnet.pyx +++ b/python/dnet.pyx @@ -13,10 +13,10 @@ and raw IP packet and Ethernet frame transmission. """ __author__ = 'Oliver Falk ' -__copyright__ = 'Copyright (c) 2023 Oliver Falk' +__copyright__ = 'Copyright (c) 2023-2024 Oliver Falk' __license__ = 'BSD' __url__ = 'https://github.com/ofalk/libdnet' -__version__ = '1.16.2' +__version__ = '1.18.0' cdef extern from "dnet.h": diff --git a/python/setup.py.in b/python/setup.py.in index cb618ed..41ccd8f 100644 --- a/python/setup.py.in +++ b/python/setup.py.in @@ -37,5 +37,11 @@ setup(name='dnet', author='Oliver Falk', author_email='oliver@linux-kernel.at', url='https://github.com/ofalk/libdnet/', - ext_modules=cythonize(dnet,compiler_directives = {"c_string_type": "str", - "c_string_encoding":"ascii"}),) + ext_modules=cythonize( + dnet,compiler_directives = { + "c_string_type": "str", + "c_string_encoding":"ascii", + "language_level": 3 + } + ), +) diff --git a/python/test.py b/python/test.py index a9f77aa..4690bfe 100755 --- a/python/test.py +++ b/python/test.py @@ -45,7 +45,7 @@ def test_addr_net(self): def test_addr_properties(self): atxt = '1.2.3.4/24' a = dnet.addr(atxt) - assert a.type == dnet.ADDR_TYPE_IP and a.bits == 24 + assert a.addrtype == dnet.ADDR_TYPE_IP and a.bits == 24 assert a.ip == b'\x01\x02\x03\x04' and a.__repr__() == atxt try: self.assertTrue(a.eth == 'xxx', 'invalid eth property') except ValueError: pass @@ -53,7 +53,7 @@ def test_addr_properties(self): atxt = '00:0d:0e:0a:0d:00' a = dnet.addr(atxt) assert a == dnet.addr('0:d:E:a:D:0') - assert a.type == dnet.ADDR_TYPE_ETH and a.bits == 48 + assert a.addrtype == dnet.ADDR_TYPE_ETH and a.bits == 48 assert a.eth == b'\x00\x0d\x0e\x0a\x0d\x00' and a.__repr__() == atxt try: self.assertTrue(a.ip6 == 'xxx', 'invalid ip6 property') except ValueError: pass @@ -61,7 +61,7 @@ def test_addr_properties(self): atxt = 'fe80::dead:beef:feed:face/48' a = dnet.addr(atxt) assert a == dnet.addr('fe80:0:0::dead:beef:feed:face/48') - assert a.type == dnet.ADDR_TYPE_IP6 and a.bits == 48 + assert a.addrtype == dnet.ADDR_TYPE_IP6 and a.bits == 48 assert a.ip6 == b'\xfe\x80\x00\x00\x00\x00\x00\x00\xde\xad\xbe\xef\xfe\xed\xfa\xce' and a.__repr__() == atxt try: self.assertTrue(a.ip == 'xxx', 'invalid ip property') except ValueError: pass diff --git a/src/Makefile.in b/src/Makefile.in index c69f08a..f9eb197 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -224,7 +224,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ diff --git a/src/intf-win32.c b/src/intf-win32.c index eb804f3..0203c9e 100644 --- a/src/intf-win32.c +++ b/src/intf-win32.c @@ -1,9 +1,8 @@ /* * intf-win32.c * - * Copyright (c) 2002 Dug Song + * Copyright (c) 2023-2024 Oliver Falk * - * $Id$ */ #include "config.h" @@ -26,7 +25,7 @@ struct ifcombo { /* XXX - ipifcons.h incomplete, use IANA ifTypes MIB */ #define MIB_IF_TYPE_TUNNEL 131 -#define MIB_IF_TYPE_MAX 255 +#define MIB_IF_TYPE_MAX 259 /* According to ipifcons.h */ struct intf_handle { struct ifcombo ifcombo[MIB_IF_TYPE_MAX]; @@ -100,7 +99,12 @@ _ifrow_to_entry(intf_t *intf, MIB_IFROW *ifrow, struct intf_entry *entry) struct addr *ap, *lap; int i; + /* The total length of the entry may be passed in inside entry. + Remember it and clear the entry. */ + u_int intf_len = entry->intf_len; memset(entry, 0, sizeof(*entry)); + /* Restore the length. */ + entry->intf_len = intf_len; for (i = 0; i < intf->ifcombo[ifrow->dwType].cnt; i++) { if (intf->ifcombo[ifrow->dwType].idx[i] == ifrow->dwIndex) diff --git a/src/intf.c b/src/intf.c index 0942027..7c94324 100644 --- a/src/intf.c +++ b/src/intf.c @@ -392,12 +392,12 @@ intf_set(intf_t *intf, const struct intf_entry *entry) static void _intf_set_type(struct intf_entry *entry) { - if ((entry->intf_flags & INTF_FLAG_BROADCAST) != 0) + if ((entry->intf_flags & INTF_FLAG_LOOPBACK) != 0) + entry->intf_type = INTF_TYPE_LOOPBACK; + else if ((entry->intf_flags & INTF_FLAG_BROADCAST) != 0) entry->intf_type = INTF_TYPE_ETH; else if ((entry->intf_flags & INTF_FLAG_POINTOPOINT) != 0) entry->intf_type = INTF_TYPE_TUN; - else if ((entry->intf_flags & INTF_FLAG_LOOPBACK) != 0) - entry->intf_type = INTF_TYPE_LOOPBACK; else entry->intf_type = INTF_TYPE_OTHER; } @@ -572,7 +572,7 @@ _intf_get_aliases(intf_t *intf, struct intf_entry *entry) if ((f = fopen(PROC_INET6_FILE, "r")) != NULL) { while ((ap +1) < lap && fgets(buf, sizeof(buf), f) != NULL) { - sscanf(buf, "%04s%04s%04s%04s%04s%04s%04s%04s %02x %02x %02x %02x %32s\n", + sscanf(buf, "%04s%04s%04s%04s%04s%04s%04s%04s %02x %x %02x %02x %32s\n", s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], &idx, &bits, &scope, &flags, name); if (strcmp(name, entry->intf_name) == 0) { diff --git a/src/ndisc-linux.c b/src/ndisc-linux.c index b97e10e..daa4851 100644 --- a/src/ndisc-linux.c +++ b/src/ndisc-linux.c @@ -75,7 +75,6 @@ ndisc_modify(ndisc_t *n, const struct ndisc_entry *entry, int type, int flags) { struct nlmsghdr *nmsg; struct ndmsg *ndm; - struct rtattr *rta; struct sockaddr_nl snl; struct iovec iov; struct msghdr msg; diff --git a/src/rand.c b/src/rand.c index 38fa911..23bdbc1 100644 --- a/src/rand.c +++ b/src/rand.c @@ -5,8 +5,8 @@ * * Copyright (c) 2000 Dug Song * Copyright (c) 1996 David Mazieres + * Copyright (c) 2023-2024 Oliver Falk * - * $Id$ */ #include "config.h" @@ -81,7 +81,12 @@ rand_open(void) if ((fd = open("/dev/arandom", O_RDONLY)) != -1 || (fd = open("/dev/urandom", O_RDONLY)) != -1) { - read(fd, seed + sizeof(*tv), sizeof(seed) - sizeof(*tv)); + /* This is ugly, as we may end up with nothing in buffer, but + * that's very unlikely, anyway, wrappping the read in a conditional + * avoids compiler warning about unused variable */ + if(read(fd, seed + sizeof(*tv), sizeof(seed) - sizeof(*tv))) { + // NOOP + } close(fd); } gettimeofday(tv, NULL); diff --git a/test/Makefile.in b/test/Makefile.in index 856092f..0d48206 100644 --- a/test/Makefile.in +++ b/test/Makefile.in @@ -199,7 +199,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ diff --git a/test/check/Makefile.in b/test/check/Makefile.in index 4641a14..fac597b 100644 --- a/test/check/Makefile.in +++ b/test/check/Makefile.in @@ -441,7 +441,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@ diff --git a/test/check/check_fw.c b/test/check/check_fw.c index 3c92f2d..2e3106b 100644 --- a/test/check/check_fw.c +++ b/test/check/check_fw.c @@ -55,6 +55,7 @@ fw_suite(void) tcase_add_test(tc_core, test_fw_add); tcase_add_test(tc_core, test_fw_delete); tcase_add_test(tc_core, test_fw_loop); + tcase_add_test(tc_core, test_fw_close); return (s); } diff --git a/test/dnet/Makefile.in b/test/dnet/Makefile.in index c87101b..b6902a1 100644 --- a/test/dnet/Makefile.in +++ b/test/dnet/Makefile.in @@ -220,7 +220,6 @@ CHECKINC = @CHECKINC@ CHECKLIB = @CHECKLIB@ CHECK_CFLAGS = @CHECK_CFLAGS@ CHECK_LIBS = @CHECK_LIBS@ -CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CSCOPE = @CSCOPE@ CTAGS = @CTAGS@