2023-09-08T22:03:46,259 Created temporary directory: /tmp/pip-build-tracker-2riw3syt 2023-09-08T22:03:46,261 Initialized build tracking at /tmp/pip-build-tracker-2riw3syt 2023-09-08T22:03:46,261 Created build tracker: /tmp/pip-build-tracker-2riw3syt 2023-09-08T22:03:46,261 Entered build tracker: /tmp/pip-build-tracker-2riw3syt 2023-09-08T22:03:46,262 Created temporary directory: /tmp/pip-wheel-vvdp227h 2023-09-08T22:03:46,265 Created temporary directory: /tmp/pip-ephem-wheel-cache-hb60qvne 2023-09-08T22:03:46,287 Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple 2023-09-08T22:03:46,290 2 location(s) to search for versions of box2d-py: 2023-09-08T22:03:46,290 * https://pypi.org/simple/box2d-py/ 2023-09-08T22:03:46,290 * https://www.piwheels.org/simple/box2d-py/ 2023-09-08T22:03:46,291 Fetching project page and analyzing links: https://pypi.org/simple/box2d-py/ 2023-09-08T22:03:46,292 Getting page https://pypi.org/simple/box2d-py/ 2023-09-08T22:03:46,293 Found index url https://pypi.org/simple/ 2023-09-08T22:03:46,436 Fetched page https://pypi.org/simple/box2d-py/ as application/vnd.pypi.simple.v1+json 2023-09-08T22:03:46,441 Found link https://files.pythonhosted.org/packages/d1/61/8d3837c797f3b959b00d9868f873dca961c1cf59545d82e7f26752f209f7/box2d-py-2.3.1.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.1 2023-09-08T22:03:46,442 Found link https://files.pythonhosted.org/packages/5d/73/1be62ed955f2c57dddca56d8c0755c7b70f490ff03e971080f807db9a869/box2d-py-2.3.4.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.4 2023-09-08T22:03:46,442 Found link https://files.pythonhosted.org/packages/dd/5a/ad8d3ef9c13d5afcc1e44a77f11792ee717f6727b3320bddbc607e935e2a/box2d-py-2.3.5.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.5 2023-09-08T22:03:46,443 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/35/1b/9326661e058e2fbcda2e5b78f58b4406dfb2ae07ae25869cf97e3f708217/box2d_py-2.3.5-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,444 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/72/d7/8f59be9952bcdabb5d716e12b36a6b6c4854f23930938e7d02797125728b/box2d_py-2.3.5-cp36-cp36m-macosx_10_13_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,444 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/16/a0/040870c99d16231bb2001e70ab7fc40d05b297fd4e03448cbad56657c75f/box2d_py-2.3.5-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,445 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/ac/51/2ab97653ad23aba5645d82c6f7335d7a8cd8d9db94bd6f35599e44f7cdea/box2d_py-2.3.5-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,446 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/90/0c/a21a63ba4a45f99da2792318ba82e9afb181da59beab503b1eb34f2088b7/box2d_py-2.3.6-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,447 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/b8/71/f7cdeddf91dcc976448678d2e4b84b83ce868281e97b3ccbbfa685d120e0/box2d_py-2.3.6-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,447 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/6c/9e/7afdf4e96536591e3760780488e7e1763b1c5ce297be7a603502747911ba/box2d_py-2.3.6-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,448 Found link https://files.pythonhosted.org/packages/2f/2c/1de11a022d552d194df396d75b7f6087fc7b9d27a3b13d177db2087fbce5/box2d-py-2.3.7.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.7 2023-09-08T22:03:46,448 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/6f/16/d47e1d6ec7a130445fb12812bcbccf0f7e9a9af9659c27431e5058ad5204/box2d_py-2.3.7-cp35-cp35m-macosx_10_5_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,449 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/47/73/48216f98d890373f2679c1f708641a7cde2f72fb203f9a4692bb02ed7165/box2d_py-2.3.7-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,450 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/c8/70/dd3f135e4cb7586c3c438c2fb54a0667eced89befcdbaf8593097db526b1/box2d_py-2.3.7-cp36-cp36m-macosx_10_7_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,450 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/49/1c/f7c72f6d96e906b40fbe1634dc9b1b7f9edc781d142e5aaedcc9aa4e1ea7/box2d_py-2.3.7-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,451 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/88/f3/73dbd3276344adf90d3894ab6c32e54a8148fea1e67c96822996d037ab53/box2d_py-2.3.7-cp37-cp37m-macosx_10_7_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,451 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/53/82/b0d9543d55729f18ab3187bd6b391e6c944b01743356dc5ad1a577db00cf/box2d_py-2.3.7-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,451 Found link https://files.pythonhosted.org/packages/98/c2/ab05b5329dc4416b5ee5530f0625a79c394a3e3c10abe0812b9345256451/box2d-py-2.3.8.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.8 2023-09-08T22:03:46,452 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/a6/c3/09b5fd0ee5a67d63cfb6ed73131675b2379187042f7b0c1c9839817d6b21/box2d_py-2.3.8-cp35-cp35m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,453 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/c4/59/58faf9c8277efd22509db7fc068d971d894ebf650ff73770401a4d5bed78/box2d_py-2.3.8-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,453 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/04/e3/9ca87ab61772eda6e65a0a21aac4d3ae006c265604ce82403d14a31862dd/box2d_py-2.3.8-cp36-cp36m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,454 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/06/bd/6cdc3fd994b0649dcf5d9bad85bd9e26172308bbe9a421bfc6fdbf5081a6/box2d_py-2.3.8-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,454 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/02/a8/f6f6986fe3c8f53ef8ddf7ac73ec7f87e45b0beccce8067194fa8d658a07/box2d_py-2.3.8-cp37-cp37m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,455 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/87/34/da5393985c3ff9a76351df6127c275dcb5749ae0abbe8d5210f06d97405d/box2d_py-2.3.8-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2023-09-08T22:03:46,456 Fetching project page and analyzing links: https://www.piwheels.org/simple/box2d-py/ 2023-09-08T22:03:46,456 Getting page https://www.piwheels.org/simple/box2d-py/ 2023-09-08T22:03:46,458 Found index url https://www.piwheels.org/simple/ 2023-09-08T22:03:46,735 Fetched page https://www.piwheels.org/simple/box2d-py/ as text/html 2023-09-08T22:03:46,739 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.4-cp39-cp39-linux_armv6l.whl#sha256=4aad27a947974e644fa4b4e391ef14066718d352bebba16cfcbfa506dd5fd4f0 (from https://www.piwheels.org/simple/box2d-py/) 2023-09-08T22:03:46,739 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.4-cp39-cp39-linux_armv7l.whl#sha256=4aad27a947974e644fa4b4e391ef14066718d352bebba16cfcbfa506dd5fd4f0 (from https://www.piwheels.org/simple/box2d-py/) 2023-09-08T22:03:46,740 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.5-cp39-cp39-linux_armv6l.whl#sha256=8c797817040f4b59550773f4dcead3715a1bf278674318335265587c42dc57d0 (from https://www.piwheels.org/simple/box2d-py/) 2023-09-08T22:03:46,741 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.5-cp39-cp39-linux_armv7l.whl#sha256=8c797817040f4b59550773f4dcead3715a1bf278674318335265587c42dc57d0 (from https://www.piwheels.org/simple/box2d-py/) 2023-09-08T22:03:46,741 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.7-cp39-cp39-linux_armv6l.whl#sha256=3fcd8141bd85eb6eef455f4e083cf206b4c71ad350c0531d2a7161e39c4c9d1d (from https://www.piwheels.org/simple/box2d-py/) 2023-09-08T22:03:46,741 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.7-cp39-cp39-linux_armv7l.whl#sha256=3fcd8141bd85eb6eef455f4e083cf206b4c71ad350c0531d2a7161e39c4c9d1d (from https://www.piwheels.org/simple/box2d-py/) 2023-09-08T22:03:46,742 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.8-cp39-cp39-linux_armv6l.whl#sha256=162fca658a9bf149c03a1d447e56a587903ea51079b2e15eabf480493b865f1f (from https://www.piwheels.org/simple/box2d-py/) 2023-09-08T22:03:46,742 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.8-cp39-cp39-linux_armv7l.whl#sha256=162fca658a9bf149c03a1d447e56a587903ea51079b2e15eabf480493b865f1f (from https://www.piwheels.org/simple/box2d-py/) 2023-09-08T22:03:46,743 Skipping link: not a file: https://www.piwheels.org/simple/box2d-py/ 2023-09-08T22:03:46,743 Skipping link: not a file: https://pypi.org/simple/box2d-py/ 2023-09-08T22:03:46,762 Given no hashes to check 1 links for project 'box2d-py': discarding no candidates 2023-09-08T22:03:46,780 Collecting box2d-py==2.3.1 2023-09-08T22:03:46,782 Created temporary directory: /tmp/pip-unpack-2m22zltx 2023-09-08T22:03:47,002 Downloading box2d-py-2.3.1.tar.gz (425 kB) 2023-09-08T22:03:47,661 Added box2d-py==2.3.1 from https://files.pythonhosted.org/packages/d1/61/8d3837c797f3b959b00d9868f873dca961c1cf59545d82e7f26752f209f7/box2d-py-2.3.1.tar.gz to build tracker '/tmp/pip-build-tracker-2riw3syt' 2023-09-08T22:03:47,662 Running setup.py (path:/tmp/pip-wheel-vvdp227h/box2d-py_a5928c812c994ed282e593b40588f333/setup.py) egg_info for package box2d-py 2023-09-08T22:03:47,663 Created temporary directory: /tmp/pip-pip-egg-info-ct314p9t 2023-09-08T22:03:47,664 Preparing metadata (setup.py): started 2023-09-08T22:03:47,665 Running command python setup.py egg_info 2023-09-08T22:03:48,676 Using setuptools (version 68.2.0). 2023-09-08T22:03:48,676 running egg_info 2023-09-08T22:03:48,678 creating /tmp/pip-pip-egg-info-ct314p9t/box2d_py.egg-info 2023-09-08T22:03:48,702 writing /tmp/pip-pip-egg-info-ct314p9t/box2d_py.egg-info/PKG-INFO 2023-09-08T22:03:48,704 writing dependency_links to /tmp/pip-pip-egg-info-ct314p9t/box2d_py.egg-info/dependency_links.txt 2023-09-08T22:03:48,707 writing top-level names to /tmp/pip-pip-egg-info-ct314p9t/box2d_py.egg-info/top_level.txt 2023-09-08T22:03:48,708 writing manifest file '/tmp/pip-pip-egg-info-ct314p9t/box2d_py.egg-info/SOURCES.txt' 2023-09-08T22:03:48,807 reading manifest file '/tmp/pip-pip-egg-info-ct314p9t/box2d_py.egg-info/SOURCES.txt' 2023-09-08T22:03:48,809 reading manifest template 'MANIFEST.in' 2023-09-08T22:03:48,810 warning: no files found matching 'INSTALL' 2023-09-08T22:03:48,811 warning: no files found matching 'MANIFEST' 2023-09-08T22:03:48,811 warning: no files found matching 'README' 2023-09-08T22:03:48,812 warning: no files found matching 'distribute_setup.py' 2023-09-08T22:03:49,115 warning: no files found matching '*.py' under directory 'Box2D' 2023-09-08T22:03:49,485 warning: no files found matching '*.c' under directory 'Box2D' 2023-09-08T22:03:49,519 adding license file 'LICENSE' 2023-09-08T22:03:49,531 writing manifest file '/tmp/pip-pip-egg-info-ct314p9t/box2d_py.egg-info/SOURCES.txt' 2023-09-08T22:03:49,643 Preparing metadata (setup.py): finished with status 'done' 2023-09-08T22:03:49,646 Source in /tmp/pip-wheel-vvdp227h/box2d-py_a5928c812c994ed282e593b40588f333 has version 2.3.1, which satisfies requirement box2d-py==2.3.1 from https://files.pythonhosted.org/packages/d1/61/8d3837c797f3b959b00d9868f873dca961c1cf59545d82e7f26752f209f7/box2d-py-2.3.1.tar.gz 2023-09-08T22:03:49,647 Removed box2d-py==2.3.1 from https://files.pythonhosted.org/packages/d1/61/8d3837c797f3b959b00d9868f873dca961c1cf59545d82e7f26752f209f7/box2d-py-2.3.1.tar.gz from build tracker '/tmp/pip-build-tracker-2riw3syt' 2023-09-08T22:03:49,651 Created temporary directory: /tmp/pip-unpack-n08artbh 2023-09-08T22:03:49,652 Created temporary directory: /tmp/pip-unpack-8agpqks7 2023-09-08T22:03:49,655 Building wheels for collected packages: box2d-py 2023-09-08T22:03:49,659 Created temporary directory: /tmp/pip-wheel-_mri9ku_ 2023-09-08T22:03:49,659 Building wheel for box2d-py (setup.py): started 2023-09-08T22:03:49,660 Destination directory: /tmp/pip-wheel-_mri9ku_ 2023-09-08T22:03:49,661 Running command python setup.py bdist_wheel 2023-09-08T22:03:50,095 Using setuptools (version 68.2.0). 2023-09-08T22:03:50,667 running bdist_wheel 2023-09-08T22:03:50,760 running build 2023-09-08T22:03:50,761 running build_py 2023-09-08T22:03:50,786 creating build 2023-09-08T22:03:50,787 creating build/lib.linux-armv7l-cpython-311 2023-09-08T22:03:50,787 creating build/lib.linux-armv7l-cpython-311/Box2D 2023-09-08T22:03:50,789 copying library/Box2D/Box2D.py -> build/lib.linux-armv7l-cpython-311/Box2D 2023-09-08T22:03:50,798 copying library/Box2D/__init__.py -> build/lib.linux-armv7l-cpython-311/Box2D 2023-09-08T22:03:50,800 creating build/lib.linux-armv7l-cpython-311/Box2D/b2 2023-09-08T22:03:50,800 copying library/Box2D/b2/__init__.py -> build/lib.linux-armv7l-cpython-311/Box2D/b2 2023-09-08T22:03:50,803 running build_ext 2023-09-08T22:03:51,307 building 'Box2D._Box2D' extension 2023-09-08T22:03:51,308 swigging Box2D/Box2D.i to Box2D/Box2D_wrap.cpp 2023-09-08T22:03:51,309 swig -python -c++ -IBox2D -small -O -includeall -ignoremissing -w201 -globals b2Globals -outdir library/Box2D -keyword -w511 -D_SWIG_KWARGS -o Box2D/Box2D_wrap.cpp Box2D/Box2D.i 2023-09-08T22:03:51,893 Box2D/Common/b2Math.h:67: Warning 302: Identifier 'b2Vec2' redefined by %extend (ignored), 2023-09-08T22:03:51,894 Box2D/Box2D_math.i:47: Warning 302: %extend definition of 'b2Vec2'. 2023-09-08T22:03:51,900 Box2D/Common/b2Math.h:158: Warning 302: Identifier 'b2Vec3' redefined by %extend (ignored), 2023-09-08T22:03:51,900 Box2D/Box2D_math.i:168: Warning 302: %extend definition of 'b2Vec3'. 2023-09-08T22:03:51,905 Box2D/Common/b2Math.h:197: Warning 302: Identifier 'b2Mat22' redefined by %extend (ignored), 2023-09-08T22:03:51,906 Box2D/Box2D_math.i:301: Warning 302: %extend definition of 'b2Mat22'. 2023-09-08T22:03:51,911 Box2D/Common/b2Math.h:271: Warning 302: Identifier 'b2Mat33' redefined by %extend (ignored), 2023-09-08T22:03:51,912 Box2D/Box2D_math.i:372: Warning 302: %extend definition of 'b2Mat33'. 2023-09-08T22:03:52,090 Box2D/Collision/b2DynamicTree.h:44: Warning 312: Nested union not currently supported (ignored). 2023-09-08T22:03:52,814 Box2D/Common/b2Settings.h:144: Warning 506: Can't wrap varargs with keyword arguments enabled 2023-09-08T22:03:52,864 Box2D/Common/b2Math.h:91: Warning 509: Overloaded method b2Vec2::operator ()(int32) effectively ignored, 2023-09-08T22:03:52,865 Box2D/Common/b2Math.h:85: Warning 509: as it is shadowed by b2Vec2::operator ()(int32) const. 2023-09-08T22:03:57,230 creating build/temp.linux-armv7l-cpython-311 2023-09-08T22:03:57,230 creating build/temp.linux-armv7l-cpython-311/Box2D 2023-09-08T22:03:57,231 creating build/temp.linux-armv7l-cpython-311/Box2D/Collision 2023-09-08T22:03:57,232 creating build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes 2023-09-08T22:03:57,233 creating build/temp.linux-armv7l-cpython-311/Box2D/Common 2023-09-08T22:03:57,234 creating build/temp.linux-armv7l-cpython-311/Box2D/Dynamics 2023-09-08T22:03:57,234 creating build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts 2023-09-08T22:03:57,235 creating build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints 2023-09-08T22:03:57,236 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Box2D_wrap.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Box2D_wrap.o -I. -Wno-unused 2023-09-08T22:04:00,152 Box2D/Box2D_wrap.cpp: In function ‘PyObject* b2GetPointStates(const b2Manifold*, const b2Manifold*)’: 2023-09-08T22:04:00,152 Box2D/Box2D_wrap.cpp:4109:13: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,153 4109 | if (state1[i]==b2_nullState && state1_length==0) 2023-09-08T22:04:00,153 | ^~ 2023-09-08T22:04:00,154 Box2D/Box2D_wrap.cpp:4111:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,154 4111 | if (state2_length > -1) 2023-09-08T22:04:00,155 | ^~ 2023-09-08T22:04:00,155 Box2D/Box2D_wrap.cpp:4113:13: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,156 4113 | if (state2[i]==b2_nullState && state2_length==0) 2023-09-08T22:04:00,156 | ^~ 2023-09-08T22:04:00,157 Box2D/Box2D_wrap.cpp:4115:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,157 4115 | if (state1_length > -1) 2023-09-08T22:04:00,158 | ^~ 2023-09-08T22:04:00,344 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Random__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,345 Box2D/Box2D_wrap.cpp:5656:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,345 5656 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-08T22:04:00,346 | ^~ 2023-09-08T22:04:00,347 Box2D/Box2D_wrap.cpp:5656:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,347 5656 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-08T22:04:00,348 | ^~~~~~ 2023-09-08T22:04:00,349 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Random(PyObject*, PyObject*)’: 2023-09-08T22:04:00,350 Box2D/Box2D_wrap.cpp:5664:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,351 5664 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Random", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,351 | ^~ 2023-09-08T22:04:00,352 Box2D/Box2D_wrap.cpp:5664:83: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,352 5664 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Random", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,353 | ^~ 2023-09-08T22:04:00,354 Box2D/Box2D_wrap.cpp:5667:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,355 5667 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,356 | ^~ 2023-09-08T22:04:00,356 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,356 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,357 | ^~~~ 2023-09-08T22:04:00,357 Box2D/Box2D_wrap.cpp:5667:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,358 5667 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,358 | ^~~~~~~~~ 2023-09-08T22:04:00,363 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Distance__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,364 Box2D/Box2D_wrap.cpp:5704:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,364 5704 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-08T22:04:00,365 | ^~ 2023-09-08T22:04:00,365 Box2D/Box2D_wrap.cpp:5704:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,366 5704 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-08T22:04:00,366 | ^~~~ 2023-09-08T22:04:00,368 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Distance(PyObject*, PyObject*)’: 2023-09-08T22:04:00,369 Box2D/Box2D_wrap.cpp:5712:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,370 5712 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2Distance", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:00,371 | ^~ 2023-09-08T22:04:00,371 Box2D/Box2D_wrap.cpp:5712:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,372 5712 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2Distance", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:00,373 | ^~ 2023-09-08T22:04:00,373 Box2D/Box2D_wrap.cpp:5715:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,374 5715 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,374 | ^~ 2023-09-08T22:04:00,375 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,376 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,376 | ^~~~ 2023-09-08T22:04:00,377 Box2D/Box2D_wrap.cpp:5715:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,378 5715 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,378 | ^~~~~~~~~ 2023-09-08T22:04:00,384 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_fixtureA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,385 Box2D/Box2D_wrap.cpp:5758:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,386 5758 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,387 | ^~ 2023-09-08T22:04:00,387 Box2D/Box2D_wrap.cpp:5758:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,388 5758 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,389 | ^~~~~~~~ 2023-09-08T22:04:00,391 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_fixtureB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,392 Box2D/Box2D_wrap.cpp:5776:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,392 5776 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,393 | ^~ 2023-09-08T22:04:00,393 Box2D/Box2D_wrap.cpp:5776:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,394 5776 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,394 | ^~~~~~~~ 2023-09-08T22:04:00,399 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_normal_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,399 Box2D/Box2D_wrap.cpp:5799:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,400 5799 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,400 | ^~ 2023-09-08T22:04:00,401 Box2D/Box2D_wrap.cpp:5799:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,402 5799 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,402 | ^~~~~~~~ 2023-09-08T22:04:00,406 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_position_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,407 Box2D/Box2D_wrap.cpp:5822:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,408 5822 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,409 | ^~ 2023-09-08T22:04:00,410 Box2D/Box2D_wrap.cpp:5822:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,410 5822 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,411 | ^~~~~~~~ 2023-09-08T22:04:00,413 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_state_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,414 Box2D/Box2D_wrap.cpp:5838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,414 5838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,415 | ^~ 2023-09-08T22:04:00,416 Box2D/Box2D_wrap.cpp:5838:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,416 5838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,417 | ^~~~~~~~ 2023-09-08T22:04:00,418 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:00,418 Box2D/Box2D_wrap.cpp:5845:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,419 5845 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,420 | ^~ 2023-09-08T22:04:00,421 Box2D/Box2D_wrap.cpp:5845:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,421 5845 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-08T22:04:00,422 | ^~~~~~~~ 2023-09-08T22:04:00,428 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2TimeOfImpact__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,428 Box2D/Box2D_wrap.cpp:5893:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,429 5893 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:00,429 | ^~ 2023-09-08T22:04:00,430 Box2D/Box2D_wrap.cpp:5893:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,430 5893 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:00,431 | ^~~~ 2023-09-08T22:04:00,432 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2TimeOfImpact(PyObject*, PyObject*)’: 2023-09-08T22:04:00,433 Box2D/Box2D_wrap.cpp:5901:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,433 5901 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2TimeOfImpact", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:00,434 | ^~ 2023-09-08T22:04:00,435 Box2D/Box2D_wrap.cpp:5901:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,435 5901 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2TimeOfImpact", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:00,436 | ^~ 2023-09-08T22:04:00,436 Box2D/Box2D_wrap.cpp:5903:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,437 5903 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 7) { 2023-09-08T22:04:00,438 | ^~ 2023-09-08T22:04:00,439 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,439 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,440 | ^~~~ 2023-09-08T22:04:00,440 Box2D/Box2D_wrap.cpp:5903:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,441 5903 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 7) { 2023-09-08T22:04:00,442 | ^~~~~~~~~ 2023-09-08T22:04:00,442 Box2D/Box2D_wrap.cpp:5905:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,443 5905 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,443 | ^~ 2023-09-08T22:04:00,444 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,444 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,445 | ^~~~ 2023-09-08T22:04:00,446 Box2D/Box2D_wrap.cpp:5905:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,447 5905 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,447 | ^~~~~~~~~ 2023-09-08T22:04:00,448 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AssertException___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:00,449 Box2D/Box2D_wrap.cpp:5911:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,449 5911 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AssertException, 0 | 0 ); 2023-09-08T22:04:00,450 | ^~ 2023-09-08T22:04:00,450 Box2D/Box2D_wrap.cpp:5911:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,450 5911 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AssertException, 0 | 0 ); 2023-09-08T22:04:00,451 | ^~~~~~~~ 2023-09-08T22:04:00,451 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2AssertException(PyObject*, PyObject*)’: 2023-09-08T22:04:00,452 Box2D/Box2D_wrap.cpp:5925:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,452 5925 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:00,453 | ^~ 2023-09-08T22:04:00,453 Box2D/Box2D_wrap.cpp:5925:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,454 5925 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:00,454 | ^~~~~~~~ 2023-09-08T22:04:00,457 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Alloc(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,457 Box2D/Box2D_wrap.cpp:5943:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,458 5943 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Alloc", kwnames, &obj0)) SWIG_fail; ecode1 = SWIG_AsVal_int(obj0, &val1); 2023-09-08T22:04:00,458 | ^~ 2023-09-08T22:04:00,459 Box2D/Box2D_wrap.cpp:5943:91: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,460 5943 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Alloc", kwnames, &obj0)) SWIG_fail; ecode1 = SWIG_AsVal_int(obj0, &val1); 2023-09-08T22:04:00,460 | ^~~~~~ 2023-09-08T22:04:00,462 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Free(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,462 Box2D/Box2D_wrap.cpp:5951:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,463 5951 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Free", kwnames, &obj0)) SWIG_fail; { arg1 = obj0; 2023-09-08T22:04:00,464 | ^~ 2023-09-08T22:04:00,465 Box2D/Box2D_wrap.cpp:5951:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,465 5951 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Free", kwnames, &obj0)) SWIG_fail; { arg1 = obj0; 2023-09-08T22:04:00,466 | ^ 2023-09-08T22:04:00,470 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_major_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,471 Box2D/Box2D_wrap.cpp:5974:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,471 5974 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-08T22:04:00,472 | ^~ 2023-09-08T22:04:00,473 Box2D/Box2D_wrap.cpp:5974:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,473 5974 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-08T22:04:00,474 | ^~~~~~~~ 2023-09-08T22:04:00,477 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_minor_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,478 Box2D/Box2D_wrap.cpp:5990:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,478 5990 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-08T22:04:00,479 | ^~ 2023-09-08T22:04:00,479 Box2D/Box2D_wrap.cpp:5990:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,480 5990 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-08T22:04:00,480 | ^~~~~~~~ 2023-09-08T22:04:00,483 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_revision_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,484 Box2D/Box2D_wrap.cpp:6006:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,484 6006 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-08T22:04:00,485 | ^~ 2023-09-08T22:04:00,485 Box2D/Box2D_wrap.cpp:6006:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,486 6006 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-08T22:04:00,487 | ^~~~~~~~ 2023-09-08T22:04:00,488 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:00,489 Box2D/Box2D_wrap.cpp:6013:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,489 6013 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-08T22:04:00,490 | ^~ 2023-09-08T22:04:00,491 Box2D/Box2D_wrap.cpp:6013:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,492 6013 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-08T22:04:00,492 | ^~~~~~~~ 2023-09-08T22:04:00,493 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Version(PyObject*, PyObject*)’: 2023-09-08T22:04:00,494 Box2D/Box2D_wrap.cpp:6020:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,495 6020 | if (!SWIG_Python_UnpackTuple(args, "new_b2Version", 0, 0, 0)) SWIG_fail; { try { result = (b2Version *)new b2Version(); } 2023-09-08T22:04:00,495 | ^~ 2023-09-08T22:04:00,496 Box2D/Box2D_wrap.cpp:6020:76: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,497 6020 | if (!SWIG_Python_UnpackTuple(args, "new_b2Version", 0, 0, 0)) SWIG_fail; { try { result = (b2Version *)new b2Version(); } 2023-09-08T22:04:00,497 | ^ 2023-09-08T22:04:00,504 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec2__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,505 Box2D/Box2D_wrap.cpp:6068:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,506 6068 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-08T22:04:00,507 | ^~ 2023-09-08T22:04:00,507 Box2D/Box2D_wrap.cpp:6068:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,508 6068 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-08T22:04:00,509 | ^~~~~~ 2023-09-08T22:04:00,511 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_Set(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,512 Box2D/Box2D_wrap.cpp:6086:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,512 6086 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2_Set", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:00,513 | ^~ 2023-09-08T22:04:00,513 Box2D/Box2D_wrap.cpp:6086:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,514 6086 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2_Set", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:00,514 | ^ 2023-09-08T22:04:00,518 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___call____SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,519 Box2D/Box2D_wrap.cpp:6105:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,519 6105 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-08T22:04:00,520 | ^~ 2023-09-08T22:04:00,520 Box2D/Box2D_wrap.cpp:6105:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,521 6105 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-08T22:04:00,522 | ^ 2023-09-08T22:04:00,523 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___call____SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,524 Box2D/Box2D_wrap.cpp:6115:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,525 6115 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-08T22:04:00,525 | ^~ 2023-09-08T22:04:00,526 Box2D/Box2D_wrap.cpp:6115:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,527 6115 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-08T22:04:00,528 | ^ 2023-09-08T22:04:00,529 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___call__(PyObject*, PyObject*)’: 2023-09-08T22:04:00,530 Box2D/Box2D_wrap.cpp:6124:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,530 6124 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2___call__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:00,531 | ^~ 2023-09-08T22:04:00,531 Box2D/Box2D_wrap.cpp:6124:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,532 6124 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2___call__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:00,532 | ^~ 2023-09-08T22:04:00,533 Box2D/Box2D_wrap.cpp:6126:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,534 6126 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-08T22:04:00,534 | ^~ 2023-09-08T22:04:00,535 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,536 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,537 | ^~~~ 2023-09-08T22:04:00,537 Box2D/Box2D_wrap.cpp:6126:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,538 6126 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-08T22:04:00,538 | ^~~~~~~~~ 2023-09-08T22:04:00,539 Box2D/Box2D_wrap.cpp:6128:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,539 6128 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,540 | ^~ 2023-09-08T22:04:00,541 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,541 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,542 | ^~~~ 2023-09-08T22:04:00,542 Box2D/Box2D_wrap.cpp:6128:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,543 6128 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,543 | ^~~~~~~~~ 2023-09-08T22:04:00,544 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___add_vector(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,544 Box2D/Box2D_wrap.cpp:6134:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,545 6134 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,546 | ^~ 2023-09-08T22:04:00,546 Box2D/Box2D_wrap.cpp:6134:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,547 6134 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,548 | ^ 2023-09-08T22:04:00,548 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___sub_vector(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,549 Box2D/Box2D_wrap.cpp:6151:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,550 6151 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,551 | ^~ 2023-09-08T22:04:00,551 Box2D/Box2D_wrap.cpp:6151:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,552 6151 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,553 | ^ 2023-09-08T22:04:00,554 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___mul_float(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,556 Box2D/Box2D_wrap.cpp:6168:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,558 6168 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,560 | ^~ 2023-09-08T22:04:00,562 Box2D/Box2D_wrap.cpp:6168:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,563 6168 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,564 | ^ 2023-09-08T22:04:00,565 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_x_set(PyObject*, PyObject*)’: 2023-09-08T22:04:00,566 Box2D/Box2D_wrap.cpp:6211:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,567 6211 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_x_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,567 | ^~ 2023-09-08T22:04:00,568 Box2D/Box2D_wrap.cpp:6211:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,568 6211 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_x_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,569 | ^ 2023-09-08T22:04:00,569 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_y_set(PyObject*, PyObject*)’: 2023-09-08T22:04:00,570 Box2D/Box2D_wrap.cpp:6226:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,571 6226 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_y_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,571 | ^~ 2023-09-08T22:04:00,571 Box2D/Box2D_wrap.cpp:6226:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,572 6226 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_y_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,573 | ^ 2023-09-08T22:04:00,573 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec2(PyObject*, PyObject*)’: 2023-09-08T22:04:00,574 Box2D/Box2D_wrap.cpp:6265:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,574 6265 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec2", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,575 | ^~ 2023-09-08T22:04:00,575 Box2D/Box2D_wrap.cpp:6265:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,576 6265 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec2", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,577 | ^~ 2023-09-08T22:04:00,578 Box2D/Box2D_wrap.cpp:6268:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,578 6268 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-08T22:04:00,579 | ^~ 2023-09-08T22:04:00,580 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,581 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,581 | ^~~~ 2023-09-08T22:04:00,582 Box2D/Box2D_wrap.cpp:6268:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,583 6268 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-08T22:04:00,583 | ^~~~~~~~~ 2023-09-08T22:04:00,584 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_cross__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,585 Box2D/Box2D_wrap.cpp:6276:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,585 6276 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-08T22:04:00,586 | ^~ 2023-09-08T22:04:00,587 Box2D/Box2D_wrap.cpp:6276:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,588 6276 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-08T22:04:00,589 | ^ 2023-09-08T22:04:00,589 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_cross(PyObject*, PyObject*)’: 2023-09-08T22:04:00,590 Box2D/Box2D_wrap.cpp:6302:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,590 6302 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2_cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-08T22:04:00,591 | ^~ 2023-09-08T22:04:00,591 Box2D/Box2D_wrap.cpp:6302:87: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,592 6302 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2_cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-08T22:04:00,593 | ^~ 2023-09-08T22:04:00,593 Box2D/Box2D_wrap.cpp:6304:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,594 6304 | if (!_v) goto check_1; return _wrap_b2Vec2_cross__SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-08T22:04:00,594 | ^~ 2023-09-08T22:04:00,595 Box2D/Box2D_wrap.cpp:6304:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,595 6304 | if (!_v) goto check_1; return _wrap_b2Vec2_cross__SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-08T22:04:00,596 | ^~~~~~ 2023-09-08T22:04:00,597 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___getitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,597 Box2D/Box2D_wrap.cpp:6312:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,598 6312 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,599 | ^~ 2023-09-08T22:04:00,600 Box2D/Box2D_wrap.cpp:6312:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,601 6312 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,601 | ^ 2023-09-08T22:04:00,602 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___setitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,603 Box2D/Box2D_wrap.cpp:6324:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,603 6324 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:00,604 | ^~ 2023-09-08T22:04:00,605 Box2D/Box2D_wrap.cpp:6324:118: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,605 6324 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:00,606 | ^ 2023-09-08T22:04:00,607 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___equ(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,607 Box2D/Box2D_wrap.cpp:6336:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,608 6336 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,609 | ^~ 2023-09-08T22:04:00,610 Box2D/Box2D_wrap.cpp:6336:104: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,611 6336 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,611 | ^ 2023-09-08T22:04:00,612 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_dot(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,612 Box2D/Box2D_wrap.cpp:6353:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,613 6353 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2_dot", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,613 | ^~ 2023-09-08T22:04:00,614 Box2D/Box2D_wrap.cpp:6353:102: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,614 6353 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2_dot", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,615 | ^ 2023-09-08T22:04:00,616 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___truediv__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,616 Box2D/Box2D_wrap.cpp:6370:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,617 6370 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,617 | ^~ 2023-09-08T22:04:00,618 Box2D/Box2D_wrap.cpp:6370:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,619 6370 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,620 | ^ 2023-09-08T22:04:00,620 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___div__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,621 Box2D/Box2D_wrap.cpp:6382:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,622 6382 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,623 | ^~ 2023-09-08T22:04:00,623 Box2D/Box2D_wrap.cpp:6382:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,624 6382 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,625 | ^ 2023-09-08T22:04:00,626 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___mul__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,627 Box2D/Box2D_wrap.cpp:6394:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,627 6394 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,628 | ^~ 2023-09-08T22:04:00,629 Box2D/Box2D_wrap.cpp:6394:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,629 6394 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,630 | ^ 2023-09-08T22:04:00,631 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___add__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,632 Box2D/Box2D_wrap.cpp:6406:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,633 6406 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,634 | ^~ 2023-09-08T22:04:00,634 Box2D/Box2D_wrap.cpp:6406:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,635 6406 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,635 | ^ 2023-09-08T22:04:00,636 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___sub__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,636 Box2D/Box2D_wrap.cpp:6424:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,637 6424 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,637 | ^~ 2023-09-08T22:04:00,638 Box2D/Box2D_wrap.cpp:6424:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,639 6424 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,639 | ^ 2023-09-08T22:04:00,640 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___rmul__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,640 Box2D/Box2D_wrap.cpp:6442:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,641 6442 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,641 | ^~ 2023-09-08T22:04:00,642 Box2D/Box2D_wrap.cpp:6442:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,643 6442 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,643 | ^ 2023-09-08T22:04:00,644 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___rdiv__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,645 Box2D/Box2D_wrap.cpp:6454:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,645 6454 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,646 | ^~ 2023-09-08T22:04:00,647 Box2D/Box2D_wrap.cpp:6454:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,647 6454 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,648 | ^ 2023-09-08T22:04:00,649 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___div_float(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,649 Box2D/Box2D_wrap.cpp:6466:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,650 6466 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,651 | ^~ 2023-09-08T22:04:00,652 Box2D/Box2D_wrap.cpp:6466:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,652 6466 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,653 | ^ 2023-09-08T22:04:00,654 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_Set(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,655 Box2D/Box2D_wrap.cpp:6513:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,655 6513 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Vec3_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2023-09-08T22:04:00,656 | ^~ 2023-09-08T22:04:00,656 Box2D/Box2D_wrap.cpp:6513:118: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,657 6513 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Vec3_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2023-09-08T22:04:00,657 | ^ 2023-09-08T22:04:00,658 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___add_vector(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,659 Box2D/Box2D_wrap.cpp:6535:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,659 6535 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,660 | ^~ 2023-09-08T22:04:00,660 Box2D/Box2D_wrap.cpp:6535:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,661 6535 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,662 | ^ 2023-09-08T22:04:00,662 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___sub_vector(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,663 Box2D/Box2D_wrap.cpp:6553:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,664 6553 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,665 | ^~ 2023-09-08T22:04:00,665 Box2D/Box2D_wrap.cpp:6553:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,666 6553 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,667 | ^ 2023-09-08T22:04:00,668 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___mul_float(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,668 Box2D/Box2D_wrap.cpp:6571:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,669 6571 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,670 | ^~ 2023-09-08T22:04:00,670 Box2D/Box2D_wrap.cpp:6571:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,671 6571 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,672 | ^ 2023-09-08T22:04:00,672 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_x_set(PyObject*, PyObject*)’: 2023-09-08T22:04:00,673 Box2D/Box2D_wrap.cpp:6580:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,674 6580 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_x_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,675 | ^~ 2023-09-08T22:04:00,676 Box2D/Box2D_wrap.cpp:6580:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,676 6580 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_x_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,677 | ^ 2023-09-08T22:04:00,677 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_y_set(PyObject*, PyObject*)’: 2023-09-08T22:04:00,678 Box2D/Box2D_wrap.cpp:6595:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,679 6595 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_y_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,679 | ^~ 2023-09-08T22:04:00,680 Box2D/Box2D_wrap.cpp:6595:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,680 6595 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_y_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,681 | ^ 2023-09-08T22:04:00,681 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_z_set(PyObject*, PyObject*)’: 2023-09-08T22:04:00,682 Box2D/Box2D_wrap.cpp:6610:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,683 6610 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_z_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,683 | ^~ 2023-09-08T22:04:00,684 Box2D/Box2D_wrap.cpp:6610:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,685 6610 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_z_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:00,685 | ^ 2023-09-08T22:04:00,686 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec3(PyObject*, PyObject*)’: 2023-09-08T22:04:00,687 Box2D/Box2D_wrap.cpp:6664:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,687 6664 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec3", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,688 | ^~ 2023-09-08T22:04:00,689 Box2D/Box2D_wrap.cpp:6664:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,690 6664 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec3", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,690 | ^~ 2023-09-08T22:04:00,691 Box2D/Box2D_wrap.cpp:6671:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,692 6671 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,692 | ^~ 2023-09-08T22:04:00,693 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,694 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,695 | ^~~~ 2023-09-08T22:04:00,695 Box2D/Box2D_wrap.cpp:6671:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,696 6671 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,697 | ^~~~~~~~~ 2023-09-08T22:04:00,698 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_cross(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,699 Box2D/Box2D_wrap.cpp:6678:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,700 6678 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3_cross", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,700 | ^~ 2023-09-08T22:04:00,701 Box2D/Box2D_wrap.cpp:6678:104: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,701 6678 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3_cross", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,702 | ^ 2023-09-08T22:04:00,703 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___getitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,703 Box2D/Box2D_wrap.cpp:6697:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,704 6697 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,704 | ^~ 2023-09-08T22:04:00,705 Box2D/Box2D_wrap.cpp:6697:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,705 6697 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,706 | ^ 2023-09-08T22:04:00,707 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___setitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,707 Box2D/Box2D_wrap.cpp:6709:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,708 6709 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec3___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:00,709 | ^~ 2023-09-08T22:04:00,709 Box2D/Box2D_wrap.cpp:6709:118: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,710 6709 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec3___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:00,711 | ^ 2023-09-08T22:04:00,712 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___truediv__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,712 Box2D/Box2D_wrap.cpp:6740:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,713 6740 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,714 | ^~ 2023-09-08T22:04:00,715 Box2D/Box2D_wrap.cpp:6740:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,715 6740 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,716 | ^ 2023-09-08T22:04:00,717 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___div__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,717 Box2D/Box2D_wrap.cpp:6752:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,718 6752 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,719 | ^~ 2023-09-08T22:04:00,720 Box2D/Box2D_wrap.cpp:6752:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,720 6752 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,721 | ^ 2023-09-08T22:04:00,722 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___mul__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,722 Box2D/Box2D_wrap.cpp:6764:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,723 6764 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,723 | ^~ 2023-09-08T22:04:00,724 Box2D/Box2D_wrap.cpp:6764:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,725 6764 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,725 | ^ 2023-09-08T22:04:00,726 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___add__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,726 Box2D/Box2D_wrap.cpp:6776:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,727 6776 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,727 | ^~ 2023-09-08T22:04:00,728 Box2D/Box2D_wrap.cpp:6776:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,728 6776 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,729 | ^ 2023-09-08T22:04:00,729 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___sub__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,730 Box2D/Box2D_wrap.cpp:6795:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,731 6795 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,732 | ^~ 2023-09-08T22:04:00,733 Box2D/Box2D_wrap.cpp:6795:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,733 6795 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,734 | ^ 2023-09-08T22:04:00,735 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___rmul__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,735 Box2D/Box2D_wrap.cpp:6814:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,736 6814 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,737 | ^~ 2023-09-08T22:04:00,737 Box2D/Box2D_wrap.cpp:6814:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,738 6814 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,739 | ^ 2023-09-08T22:04:00,739 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___rdiv__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,740 Box2D/Box2D_wrap.cpp:6826:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,741 6826 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,742 | ^~ 2023-09-08T22:04:00,743 Box2D/Box2D_wrap.cpp:6826:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,743 6826 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,744 | ^ 2023-09-08T22:04:00,744 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___div_float(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:00,745 Box2D/Box2D_wrap.cpp:6838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,746 6838 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,746 | ^~ 2023-09-08T22:04:00,747 Box2D/Box2D_wrap.cpp:6838:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,747 6838 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:00,748 | ^ 2023-09-08T22:04:00,749 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat22__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,749 Box2D/Box2D_wrap.cpp:6864:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,750 6864 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2023-09-08T22:04:00,750 | ^~ 2023-09-08T22:04:00,751 Box2D/Box2D_wrap.cpp:6864:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,752 6864 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2023-09-08T22:04:00,753 | ^ 2023-09-08T22:04:00,759 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___GetInverse(PyObject*, PyObject*)’: 2023-09-08T22:04:00,759 Box2D/Box2D_wrap.cpp:6940:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,760 6940 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-08T22:04:00,761 | ^~ 2023-09-08T22:04:00,762 Box2D/Box2D_wrap.cpp:6940:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,762 6940 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-08T22:04:00,763 | ^~~~~~~~ 2023-09-08T22:04:00,769 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22_col1_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,770 Box2D/Box2D_wrap.cpp:6982:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,771 6982 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-08T22:04:00,771 | ^~ 2023-09-08T22:04:00,772 Box2D/Box2D_wrap.cpp:6982:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,773 6982 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-08T22:04:00,773 | ^~~~~~~~ 2023-09-08T22:04:00,775 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22_col2_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,776 Box2D/Box2D_wrap.cpp:7004:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,777 7004 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-08T22:04:00,778 | ^~ 2023-09-08T22:04:00,778 Box2D/Box2D_wrap.cpp:7004:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,779 7004 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-08T22:04:00,779 | ^~~~~~~~ 2023-09-08T22:04:00,780 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat22(PyObject*, PyObject*)’: 2023-09-08T22:04:00,781 Box2D/Box2D_wrap.cpp:7022:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,782 7022 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat22", 0, 4, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,782 | ^~ 2023-09-08T22:04:00,783 Box2D/Box2D_wrap.cpp:7022:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,783 7022 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat22", 0, 4, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,784 | ^~ 2023-09-08T22:04:00,784 Box2D/Box2D_wrap.cpp:7025:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,785 7025 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2023-09-08T22:04:00,786 | ^~ 2023-09-08T22:04:00,786 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,787 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,788 | ^~~~ 2023-09-08T22:04:00,789 Box2D/Box2D_wrap.cpp:7025:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,789 7025 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2023-09-08T22:04:00,790 | ^~~~~~~~~ 2023-09-08T22:04:00,791 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___SetAngle(PyObject*, PyObject*)’: 2023-09-08T22:04:00,791 Box2D/Box2D_wrap.cpp:7048:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,792 7048 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___SetAngle", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:00,793 | ^~ 2023-09-08T22:04:00,793 Box2D/Box2D_wrap.cpp:7048:93: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,794 7048 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___SetAngle", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:00,795 | ^~ 2023-09-08T22:04:00,795 Box2D/Box2D_wrap.cpp:7050:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,796 7050 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:00,797 | ^~ 2023-09-08T22:04:00,798 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,798 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,799 | ^~~~ 2023-09-08T22:04:00,800 Box2D/Box2D_wrap.cpp:7050:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,801 7050 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:00,802 | ^~~~~~~~~ 2023-09-08T22:04:00,802 Box2D/Box2D_wrap.cpp:7052:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,803 7052 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,804 | ^~ 2023-09-08T22:04:00,804 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,805 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,805 | ^~~~ 2023-09-08T22:04:00,806 Box2D/Box2D_wrap.cpp:7052:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,806 7052 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,807 | ^~~~~~~~~ 2023-09-08T22:04:00,808 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___mul__(PyObject*, PyObject*)’: 2023-09-08T22:04:00,808 Box2D/Box2D_wrap.cpp:7086:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,809 7086 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___mul__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-08T22:04:00,809 | ^~ 2023-09-08T22:04:00,810 Box2D/Box2D_wrap.cpp:7086:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,811 7086 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___mul__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-08T22:04:00,811 | ^~ 2023-09-08T22:04:00,812 Box2D/Box2D_wrap.cpp:7088:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,813 7088 | if (!_v) goto check_1; return _wrap_b2Mat22___mul____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-08T22:04:00,814 | ^~ 2023-09-08T22:04:00,815 Box2D/Box2D_wrap.cpp:7088:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,815 7088 | if (!_v) goto check_1; return _wrap_b2Mat22___mul____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-08T22:04:00,816 | ^~~~~~ 2023-09-08T22:04:00,817 Box2D/Box2D_wrap.cpp:7090:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,818 7090 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: Py_INCREF(Py_NotImplemented); 2023-09-08T22:04:00,818 | ^~ 2023-09-08T22:04:00,819 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,820 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,820 | ^~~~ 2023-09-08T22:04:00,821 Box2D/Box2D_wrap.cpp:7090:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,822 7090 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: Py_INCREF(Py_NotImplemented); 2023-09-08T22:04:00,823 | ^~~~~~~~~ 2023-09-08T22:04:00,823 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat33__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,824 Box2D/Box2D_wrap.cpp:7162:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,825 7162 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2023-09-08T22:04:00,826 | ^~ 2023-09-08T22:04:00,827 Box2D/Box2D_wrap.cpp:7162:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,827 7162 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2023-09-08T22:04:00,828 | ^ 2023-09-08T22:04:00,850 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col1_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,851 Box2D/Box2D_wrap.cpp:7282:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,852 7282 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-08T22:04:00,852 | ^~ 2023-09-08T22:04:00,853 Box2D/Box2D_wrap.cpp:7282:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,853 7282 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-08T22:04:00,854 | ^~~~~~~~ 2023-09-08T22:04:00,857 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col2_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,858 Box2D/Box2D_wrap.cpp:7305:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,858 7305 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-08T22:04:00,859 | ^~ 2023-09-08T22:04:00,860 Box2D/Box2D_wrap.cpp:7305:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,860 7305 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-08T22:04:00,861 | ^~~~~~~~ 2023-09-08T22:04:00,867 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col3_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,868 Box2D/Box2D_wrap.cpp:7328:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,869 7328 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-08T22:04:00,869 | ^~ 2023-09-08T22:04:00,870 Box2D/Box2D_wrap.cpp:7328:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,871 7328 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-08T22:04:00,872 | ^~~~~~~~ 2023-09-08T22:04:00,872 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat33(PyObject*, PyObject*)’: 2023-09-08T22:04:00,873 Box2D/Box2D_wrap.cpp:7346:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,874 7346 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat33", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,875 | ^~ 2023-09-08T22:04:00,875 Box2D/Box2D_wrap.cpp:7346:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,876 7346 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat33", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,877 | ^~ 2023-09-08T22:04:00,878 Box2D/Box2D_wrap.cpp:7349:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,879 7349 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,880 | ^~ 2023-09-08T22:04:00,880 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,881 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,881 | ^~~~ 2023-09-08T22:04:00,882 Box2D/Box2D_wrap.cpp:7349:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,883 7349 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,883 | ^~~~~~~~~ 2023-09-08T22:04:00,897 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Rot(PyObject*, PyObject*)’: 2023-09-08T22:04:00,898 Box2D/Box2D_wrap.cpp:7454:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,898 7454 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Rot", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,899 | ^~ 2023-09-08T22:04:00,899 Box2D/Box2D_wrap.cpp:7454:84: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,900 7454 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Rot", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,901 | ^~ 2023-09-08T22:04:00,901 Box2D/Box2D_wrap.cpp:7457:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,902 7457 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,903 | ^~ 2023-09-08T22:04:00,903 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,904 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,905 | ^~~~ 2023-09-08T22:04:00,905 Box2D/Box2D_wrap.cpp:7457:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,906 7457 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,907 | ^~~~~~~~~ 2023-09-08T22:04:00,926 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Transform(PyObject*, PyObject*)’: 2023-09-08T22:04:00,927 Box2D/Box2D_wrap.cpp:7591:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,928 7591 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Transform", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,928 | ^~ 2023-09-08T22:04:00,929 Box2D/Box2D_wrap.cpp:7591:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,929 7591 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Transform", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:00,930 | ^~ 2023-09-08T22:04:00,931 Box2D/Box2D_wrap.cpp:7593:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,931 7593 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-08T22:04:00,932 | ^~ 2023-09-08T22:04:00,933 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,934 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,934 | ^~~~ 2023-09-08T22:04:00,936 Box2D/Box2D_wrap.cpp:7593:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,936 7593 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-08T22:04:00,937 | ^~~~~~~~~ 2023-09-08T22:04:00,937 Box2D/Box2D_wrap.cpp:7595:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,938 7595 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,938 | ^~ 2023-09-08T22:04:00,939 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,939 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:00,940 | ^~~~ 2023-09-08T22:04:00,941 Box2D/Box2D_wrap.cpp:7595:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:00,941 7595 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:00,942 | ^~~~~~~~~ 2023-09-08T22:04:00,942 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform_position_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,943 Box2D/Box2D_wrap.cpp:7642:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,943 7642 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-08T22:04:00,944 | ^~ 2023-09-08T22:04:00,945 Box2D/Box2D_wrap.cpp:7642:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,945 7642 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-08T22:04:00,946 | ^~~~~~~~ 2023-09-08T22:04:00,947 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform_q_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,948 Box2D/Box2D_wrap.cpp:7659:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,948 7659 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-08T22:04:00,949 | ^~ 2023-09-08T22:04:00,950 Box2D/Box2D_wrap.cpp:7659:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,950 7659 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-08T22:04:00,951 | ^~~~~~~~ 2023-09-08T22:04:00,952 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:00,952 Box2D/Box2D_wrap.cpp:7666:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,953 7666 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-08T22:04:00,954 | ^~ 2023-09-08T22:04:00,954 Box2D/Box2D_wrap.cpp:7666:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,955 7666 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-08T22:04:00,956 | ^~~~~~~~ 2023-09-08T22:04:00,957 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform___get_rotation_matrix(PyObject*, PyObject*)’: 2023-09-08T22:04:00,957 Box2D/Box2D_wrap.cpp:7674:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,958 7674 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-08T22:04:00,959 | ^~ 2023-09-08T22:04:00,959 Box2D/Box2D_wrap.cpp:7674:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,960 7674 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-08T22:04:00,960 | ^~~~~~~~ 2023-09-08T22:04:00,961 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_GetTransform__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:00,962 Box2D/Box2D_wrap.cpp:7721:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,962 7721 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-08T22:04:00,963 | ^~ 2023-09-08T22:04:00,964 Box2D/Box2D_wrap.cpp:7721:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,964 7721 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-08T22:04:00,965 | ^~~~ 2023-09-08T22:04:00,970 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_localCenter_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,971 Box2D/Box2D_wrap.cpp:7765:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,972 7765 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-08T22:04:00,972 | ^~ 2023-09-08T22:04:00,973 Box2D/Box2D_wrap.cpp:7765:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,974 7765 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-08T22:04:00,975 | ^~~~~~~~ 2023-09-08T22:04:00,976 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_c0_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,977 Box2D/Box2D_wrap.cpp:7787:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,978 7787 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-08T22:04:00,979 | ^~ 2023-09-08T22:04:00,980 Box2D/Box2D_wrap.cpp:7787:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,981 7787 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-08T22:04:00,981 | ^~~~~~~~ 2023-09-08T22:04:00,983 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_c_get(PyObject*, PyObject*)’: 2023-09-08T22:04:00,983 Box2D/Box2D_wrap.cpp:7809:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,984 7809 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-08T22:04:00,985 | ^~ 2023-09-08T22:04:00,986 Box2D/Box2D_wrap.cpp:7809:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:00,987 7809 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-08T22:04:00,987 | ^~~~~~~~ 2023-09-08T22:04:00,997 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_GetTransform(PyObject*, PyObject*)’: 2023-09-08T22:04:00,997 Box2D/Box2D_wrap.cpp:7878:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:00,999 7878 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Sweep_GetTransform", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:00,999 | ^~ 2023-09-08T22:04:00,999 Box2D/Box2D_wrap.cpp:7878:95: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,000 7878 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Sweep_GetTransform", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:01,001 | ^~ 2023-09-08T22:04:01,001 Box2D/Box2D_wrap.cpp:7880:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,002 7880 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:01,002 | ^~ 2023-09-08T22:04:01,003 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,003 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,004 | ^~~~ 2023-09-08T22:04:01,005 Box2D/Box2D_wrap.cpp:7880:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,005 7880 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:01,006 | ^~~~~~~~~ 2023-09-08T22:04:01,007 Box2D/Box2D_wrap.cpp:7882:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,007 7882 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,008 | ^~ 2023-09-08T22:04:01,008 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,009 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,010 | ^~~~ 2023-09-08T22:04:01,010 Box2D/Box2D_wrap.cpp:7882:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,011 7882 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,012 | ^~~~~~~~~ 2023-09-08T22:04:01,012 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Sweep(PyObject*, PyObject*)’: 2023-09-08T22:04:01,013 Box2D/Box2D_wrap.cpp:7887:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,014 7887 | if (!SWIG_Python_UnpackTuple(args, "new_b2Sweep", 0, 0, 0)) SWIG_fail; { try { result = (b2Sweep *)new b2Sweep(); } 2023-09-08T22:04:01,014 | ^~ 2023-09-08T22:04:01,015 Box2D/Box2D_wrap.cpp:7887:74: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,016 7887 | if (!SWIG_Python_UnpackTuple(args, "new_b2Sweep", 0, 0, 0)) SWIG_fail; { try { result = (b2Sweep *)new b2Sweep(); } 2023-09-08T22:04:01,016 | ^ 2023-09-08T22:04:01,017 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,018 Box2D/Box2D_wrap.cpp:7961:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,019 7961 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2023-09-08T22:04:01,019 | ^~ 2023-09-08T22:04:01,020 Box2D/Box2D_wrap.cpp:7961:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,021 7961 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2023-09-08T22:04:01,022 | ^ 2023-09-08T22:04:01,023 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,023 Box2D/Box2D_wrap.cpp:7977:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,024 7977 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-08T22:04:01,024 | ^~ 2023-09-08T22:04:01,025 Box2D/Box2D_wrap.cpp:7977:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,026 7977 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-08T22:04:01,026 | ^~~~~~ 2023-09-08T22:04:01,028 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,028 Box2D/Box2D_wrap.cpp:7993:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,029 7993 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-08T22:04:01,029 | ^~ 2023-09-08T22:04:01,030 Box2D/Box2D_wrap.cpp:7993:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,031 7993 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-08T22:04:01,031 | ^~~~ 2023-09-08T22:04:01,033 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,034 Box2D/Box2D_wrap.cpp:8012:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,034 8012 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-08T22:04:01,035 | ^~ 2023-09-08T22:04:01,036 Box2D/Box2D_wrap.cpp:8012:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,036 8012 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-08T22:04:01,037 | ^~~~ 2023-09-08T22:04:01,039 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceSquared(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,039 Box2D/Box2D_wrap.cpp:8032:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,040 8032 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2DistanceSquared", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,041 | ^~ 2023-09-08T22:04:01,042 Box2D/Box2D_wrap.cpp:8032:109: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,042 8032 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2DistanceSquared", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,043 | ^ 2023-09-08T22:04:01,050 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Dot(PyObject*, PyObject*)’: 2023-09-08T22:04:01,051 Box2D/Box2D_wrap.cpp:8079:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,052 8079 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Dot", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-08T22:04:01,053 | ^~ 2023-09-08T22:04:01,054 Box2D/Box2D_wrap.cpp:8079:80: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,054 8079 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Dot", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-08T22:04:01,055 | ^~ 2023-09-08T22:04:01,055 Box2D/Box2D_wrap.cpp:8081:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,056 8081 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,056 | ^~ 2023-09-08T22:04:01,057 Box2D/Box2D_wrap.cpp:8081:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,057 8081 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,058 | ^ 2023-09-08T22:04:01,059 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_3(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,059 Box2D/Box2D_wrap.cpp:8090:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,060 8090 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2023-09-08T22:04:01,061 | ^~ 2023-09-08T22:04:01,061 Box2D/Box2D_wrap.cpp:8090:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,062 8090 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2023-09-08T22:04:01,063 | ^ 2023-09-08T22:04:01,063 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross(PyObject*, PyObject*)’: 2023-09-08T22:04:01,064 Box2D/Box2D_wrap.cpp:8115:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,064 8115 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-08T22:04:01,065 | ^~ 2023-09-08T22:04:01,066 Box2D/Box2D_wrap.cpp:8115:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,067 8115 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-08T22:04:01,067 | ^~ 2023-09-08T22:04:01,068 Box2D/Box2D_wrap.cpp:8117:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,068 8117 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,069 | ^~ 2023-09-08T22:04:01,069 Box2D/Box2D_wrap.cpp:8117:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,070 8117 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,071 | ^ 2023-09-08T22:04:01,071 Box2D/Box2D_wrap.cpp:8121:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,072 8121 | if (!_v) goto check_2; { { int res = SWIG_AsVal_float(argv[1], NULL); _v = SWIG_CheckState(res); } } if (!_v) goto check_2; 2023-09-08T22:04:01,073 | ^~ 2023-09-08T22:04:01,073 Box2D/Box2D_wrap.cpp:8121:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,074 8121 | if (!_v) goto check_2; { { int res = SWIG_AsVal_float(argv[1], NULL); _v = SWIG_CheckState(res); } } if (!_v) goto check_2; 2023-09-08T22:04:01,075 | ^ 2023-09-08T22:04:01,076 Box2D/Box2D_wrap.cpp:8124:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,076 8124 | if (!_v) goto check_3; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,077 | ^~ 2023-09-08T22:04:01,077 Box2D/Box2D_wrap.cpp:8124:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,078 8124 | if (!_v) goto check_3; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,079 | ^ 2023-09-08T22:04:01,079 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,080 Box2D/Box2D_wrap.cpp:8166:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,080 8166 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat33, 0 | 0); 2023-09-08T22:04:01,081 | ^~ 2023-09-08T22:04:01,082 Box2D/Box2D_wrap.cpp:8166:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,082 8166 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat33, 0 | 0); 2023-09-08T22:04:01,083 | ^~~~ 2023-09-08T22:04:01,088 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_3(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,089 Box2D/Box2D_wrap.cpp:8207:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,090 8207 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-08T22:04:01,090 | ^~ 2023-09-08T22:04:01,091 Box2D/Box2D_wrap.cpp:8207:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,092 8207 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-08T22:04:01,093 | ^~~~ 2023-09-08T22:04:01,093 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,094 Box2D/Box2D_wrap.cpp:8223:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,095 8223 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-08T22:04:01,096 | ^~ 2023-09-08T22:04:01,097 Box2D/Box2D_wrap.cpp:8223:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,097 8223 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-08T22:04:01,098 | ^~~~ 2023-09-08T22:04:01,099 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_4(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,099 Box2D/Box2D_wrap.cpp:8239:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,100 8239 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-08T22:04:01,101 | ^~ 2023-09-08T22:04:01,101 Box2D/Box2D_wrap.cpp:8239:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,102 8239 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-08T22:04:01,103 | ^~~~ 2023-09-08T22:04:01,104 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT__SWIG_3(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,104 Box2D/Box2D_wrap.cpp:8258:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,105 8258 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-08T22:04:01,106 | ^~ 2023-09-08T22:04:01,106 Box2D/Box2D_wrap.cpp:8258:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,107 8258 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-08T22:04:01,107 | ^~~~ 2023-09-08T22:04:01,108 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_5(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,108 Box2D/Box2D_wrap.cpp:8277:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,109 8277 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Transform, 0 | 0); 2023-09-08T22:04:01,110 | ^~ 2023-09-08T22:04:01,110 Box2D/Box2D_wrap.cpp:8277:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,111 8277 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Transform, 0 | 0); 2023-09-08T22:04:01,112 | ^~~~ 2023-09-08T22:04:01,112 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT__SWIG_4(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,113 Box2D/Box2D_wrap.cpp:8297:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,113 8297 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Transform, 0 | 0); 2023-09-08T22:04:01,114 | ^~ 2023-09-08T22:04:01,115 Box2D/Box2D_wrap.cpp:8297:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,115 8297 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Transform, 0 | 0); 2023-09-08T22:04:01,116 | ^~~~ 2023-09-08T22:04:01,120 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul(PyObject*, PyObject*)’: 2023-09-08T22:04:01,121 Box2D/Box2D_wrap.cpp:8333:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,122 8333 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mul", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-08T22:04:01,122 | ^~ 2023-09-08T22:04:01,123 Box2D/Box2D_wrap.cpp:8333:80: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,124 8333 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mul", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-08T22:04:01,124 | ^~ 2023-09-08T22:04:01,125 Box2D/Box2D_wrap.cpp:8335:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,125 8335 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,126 | ^~ 2023-09-08T22:04:01,127 Box2D/Box2D_wrap.cpp:8335:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,128 8335 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,128 | ^ 2023-09-08T22:04:01,129 Box2D/Box2D_wrap.cpp:8339:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,130 8339 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2023-09-08T22:04:01,131 | ^~ 2023-09-08T22:04:01,132 Box2D/Box2D_wrap.cpp:8339:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,132 8339 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2023-09-08T22:04:01,133 | ^ 2023-09-08T22:04:01,133 Box2D/Box2D_wrap.cpp:8346:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,134 8346 | if (!_v) goto check_4; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Rot, SWIG_POINTER_NO_NULL | 0); 2023-09-08T22:04:01,134 | ^~ 2023-09-08T22:04:01,135 Box2D/Box2D_wrap.cpp:8346:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,135 8346 | if (!_v) goto check_4; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Rot, SWIG_POINTER_NO_NULL | 0); 2023-09-08T22:04:01,136 | ^ 2023-09-08T22:04:01,136 Box2D/Box2D_wrap.cpp:8353:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,137 8353 | if (!_v) goto check_6; return _wrap_b2Mul__SWIG_5(self, argc, argv);} check_6: if (argc == 2) { 2023-09-08T22:04:01,137 | ^~ 2023-09-08T22:04:01,138 Box2D/Box2D_wrap.cpp:8353:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,138 8353 | if (!_v) goto check_6; return _wrap_b2Mul__SWIG_5(self, argc, argv);} check_6: if (argc == 2) { 2023-09-08T22:04:01,139 | ^~~~~~ 2023-09-08T22:04:01,140 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT(PyObject*, PyObject*)’: 2023-09-08T22:04:01,140 Box2D/Box2D_wrap.cpp:8378:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,141 8378 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2MulT", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-08T22:04:01,142 | ^~ 2023-09-08T22:04:01,143 Box2D/Box2D_wrap.cpp:8378:81: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,143 8378 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2MulT", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-08T22:04:01,144 | ^~ 2023-09-08T22:04:01,144 Box2D/Box2D_wrap.cpp:8380:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,145 8380 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,146 | ^~ 2023-09-08T22:04:01,146 Box2D/Box2D_wrap.cpp:8380:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,147 8380 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,148 | ^ 2023-09-08T22:04:01,148 Box2D/Box2D_wrap.cpp:8384:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,149 8384 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2023-09-08T22:04:01,150 | ^~ 2023-09-08T22:04:01,151 Box2D/Box2D_wrap.cpp:8384:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,151 8384 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2023-09-08T22:04:01,152 | ^ 2023-09-08T22:04:01,153 Box2D/Box2D_wrap.cpp:8389:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,154 8389 | if (!_v) goto check_3; return _wrap_b2MulT__SWIG_2(self, argc, argv);} check_3: if (argc == 2) { int _v = 0; { 2023-09-08T22:04:01,154 | ^~ 2023-09-08T22:04:01,155 Box2D/Box2D_wrap.cpp:8389:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,155 8389 | if (!_v) goto check_3; return _wrap_b2MulT__SWIG_2(self, argc, argv);} check_3: if (argc == 2) { int _v = 0; { 2023-09-08T22:04:01,156 | ^~~~~~ 2023-09-08T22:04:01,156 Box2D/Box2D_wrap.cpp:8391:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,157 8391 | if (!_v) goto check_4; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,157 | ^~ 2023-09-08T22:04:01,158 Box2D/Box2D_wrap.cpp:8391:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,159 8391 | if (!_v) goto check_4; { { _v = (PySequence_Check(argv[1]) || 2023-09-08T22:04:01,159 | ^ 2023-09-08T22:04:01,160 Box2D/Box2D_wrap.cpp:8395:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,160 8395 | if (!_v) goto check_5; return _wrap_b2MulT__SWIG_4(self, argc, argv);} check_5: if (argc == 2) { 2023-09-08T22:04:01,161 | ^~ 2023-09-08T22:04:01,161 Box2D/Box2D_wrap.cpp:8395:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,162 8395 | if (!_v) goto check_5; return _wrap_b2MulT__SWIG_4(self, argc, argv);} check_5: if (argc == 2) { 2023-09-08T22:04:01,162 | ^~~~~~ 2023-09-08T22:04:01,163 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Abs__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,164 Box2D/Box2D_wrap.cpp:8419:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,165 8419 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-08T22:04:01,165 | ^~ 2023-09-08T22:04:01,166 Box2D/Box2D_wrap.cpp:8419:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,167 8419 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-08T22:04:01,168 | ^~~~ 2023-09-08T22:04:01,168 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Abs(PyObject*, PyObject*)’: 2023-09-08T22:04:01,169 Box2D/Box2D_wrap.cpp:8429:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,170 8429 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Abs", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { int _v = 0; { { 2023-09-08T22:04:01,170 | ^~ 2023-09-08T22:04:01,171 Box2D/Box2D_wrap.cpp:8429:80: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,172 8429 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Abs", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { int _v = 0; { { 2023-09-08T22:04:01,172 | ^~ 2023-09-08T22:04:01,173 Box2D/Box2D_wrap.cpp:8431:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,174 8431 | if (!_v) goto check_1; return _wrap_b2Abs__SWIG_1(self, argc, argv);} check_1: if (argc == 1) { 2023-09-08T22:04:01,174 | ^~ 2023-09-08T22:04:01,175 Box2D/Box2D_wrap.cpp:8431:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,176 8431 | if (!_v) goto check_1; return _wrap_b2Abs__SWIG_1(self, argc, argv);} check_1: if (argc == 1) { 2023-09-08T22:04:01,177 | ^~~~~~ 2023-09-08T22:04:01,177 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Min(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,178 Box2D/Box2D_wrap.cpp:8438:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,179 8438 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Min", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2023-09-08T22:04:01,179 | ^~ 2023-09-08T22:04:01,180 Box2D/Box2D_wrap.cpp:8438:97: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,180 8438 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Min", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2023-09-08T22:04:01,181 | ^ 2023-09-08T22:04:01,181 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Max(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,182 Box2D/Box2D_wrap.cpp:8462:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,182 8462 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Max", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2023-09-08T22:04:01,183 | ^~ 2023-09-08T22:04:01,183 Box2D/Box2D_wrap.cpp:8462:97: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,184 8462 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Max", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2023-09-08T22:04:01,185 | ^ 2023-09-08T22:04:01,186 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Clamp(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,186 Box2D/Box2D_wrap.cpp:8487:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,187 8487 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Clamp", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:01,188 | ^~ 2023-09-08T22:04:01,188 Box2D/Box2D_wrap.cpp:8487:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,189 8487 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Clamp", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:01,190 | ^ 2023-09-08T22:04:01,190 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature_indexA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,191 Box2D/Box2D_wrap.cpp:8550:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,192 8550 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,192 | ^~ 2023-09-08T22:04:01,193 Box2D/Box2D_wrap.cpp:8550:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,193 8550 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,194 | ^~~~~~~~ 2023-09-08T22:04:01,195 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature_indexB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,195 Box2D/Box2D_wrap.cpp:8568:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,196 8568 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,197 | ^~ 2023-09-08T22:04:01,198 Box2D/Box2D_wrap.cpp:8568:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,198 8568 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,199 | ^~~~~~~~ 2023-09-08T22:04:01,199 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature_typeA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,200 Box2D/Box2D_wrap.cpp:8586:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,200 8586 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,201 | ^~ 2023-09-08T22:04:01,201 Box2D/Box2D_wrap.cpp:8586:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,202 8586 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,202 | ^~~~~~~~ 2023-09-08T22:04:01,203 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature_typeB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,203 Box2D/Box2D_wrap.cpp:8604:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,204 8604 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,205 | ^~ 2023-09-08T22:04:01,205 Box2D/Box2D_wrap.cpp:8604:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,206 8604 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,207 | ^~~~~~~~ 2023-09-08T22:04:01,207 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,208 Box2D/Box2D_wrap.cpp:8611:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,209 8611 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,209 | ^~ 2023-09-08T22:04:01,210 Box2D/Box2D_wrap.cpp:8611:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,211 8611 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-08T22:04:01,212 | ^~~~~~~~ 2023-09-08T22:04:01,212 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactFeature(PyObject*, PyObject*)’: 2023-09-08T22:04:01,213 Box2D/Box2D_wrap.cpp:8625:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,214 8625 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:01,214 | ^~ 2023-09-08T22:04:01,215 Box2D/Box2D_wrap.cpp:8625:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,216 8625 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:01,216 | ^~~~~~~~ 2023-09-08T22:04:01,217 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactID_key_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,218 Box2D/Box2D_wrap.cpp:8672:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,219 8672 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2023-09-08T22:04:01,219 | ^~ 2023-09-08T22:04:01,220 Box2D/Box2D_wrap.cpp:8672:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,221 8672 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2023-09-08T22:04:01,221 | ^~~~~~~~ 2023-09-08T22:04:01,222 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactID___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,222 Box2D/Box2D_wrap.cpp:8679:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,223 8679 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2023-09-08T22:04:01,223 | ^~ 2023-09-08T22:04:01,224 Box2D/Box2D_wrap.cpp:8679:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,224 8679 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2023-09-08T22:04:01,225 | ^~~~~~~~ 2023-09-08T22:04:01,226 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2ContactID(PyObject*, PyObject*)’: 2023-09-08T22:04:01,226 Box2D/Box2D_wrap.cpp:8686:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,227 8686 | if (!SWIG_Python_UnpackTuple(args, "new_b2ContactID", 0, 0, 0)) SWIG_fail; { try { result = (b2ContactID *)new b2ContactID(); } 2023-09-08T22:04:01,227 | ^~ 2023-09-08T22:04:01,228 Box2D/Box2D_wrap.cpp:8686:78: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,229 8686 | if (!SWIG_Python_UnpackTuple(args, "new_b2ContactID", 0, 0, 0)) SWIG_fail; { try { result = (b2ContactID *)new b2ContactID(); } 2023-09-08T22:04:01,229 | ^ 2023-09-08T22:04:01,230 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ManifoldPoint_localPoint_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,231 Box2D/Box2D_wrap.cpp:8726:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,231 8726 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-08T22:04:01,232 | ^~ 2023-09-08T22:04:01,233 Box2D/Box2D_wrap.cpp:8726:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,234 8726 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-08T22:04:01,234 | ^~~~~~~~ 2023-09-08T22:04:01,235 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ManifoldPoint_normalImpulse_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,236 Box2D/Box2D_wrap.cpp:8742:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,236 8742 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-08T22:04:01,237 | ^~ 2023-09-08T22:04:01,238 Box2D/Box2D_wrap.cpp:8742:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,238 8742 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-08T22:04:01,239 | ^~~~~~~~ 2023-09-08T22:04:01,240 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ManifoldPoint_tangentImpulse_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,241 Box2D/Box2D_wrap.cpp:8758:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,241 8758 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-08T22:04:01,242 | ^~ 2023-09-08T22:04:01,243 Box2D/Box2D_wrap.cpp:8758:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,243 8758 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-08T22:04:01,244 | ^~~~~~~~ 2023-09-08T22:04:01,245 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ManifoldPoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,245 Box2D/Box2D_wrap.cpp:8784:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,246 8784 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-08T22:04:01,246 | ^~ 2023-09-08T22:04:01,247 Box2D/Box2D_wrap.cpp:8784:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,247 8784 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-08T22:04:01,248 | ^~~~~~~~ 2023-09-08T22:04:01,248 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_localNormal_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,249 Box2D/Box2D_wrap.cpp:8832:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,249 8832 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,250 | ^~ 2023-09-08T22:04:01,251 Box2D/Box2D_wrap.cpp:8832:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,252 8832 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,252 | ^~~~~~~~ 2023-09-08T22:04:01,253 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_localPoint_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,254 Box2D/Box2D_wrap.cpp:8855:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,255 8855 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,255 | ^~ 2023-09-08T22:04:01,256 Box2D/Box2D_wrap.cpp:8855:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,257 8855 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,257 | ^~~~~~~~ 2023-09-08T22:04:01,258 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_type__get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,259 Box2D/Box2D_wrap.cpp:8871:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,259 8871 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,260 | ^~ 2023-09-08T22:04:01,260 Box2D/Box2D_wrap.cpp:8871:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,261 8871 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,262 | ^~~~~~~~ 2023-09-08T22:04:01,263 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_pointCount_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,263 Box2D/Box2D_wrap.cpp:8887:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,264 8887 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,265 | ^~ 2023-09-08T22:04:01,265 Box2D/Box2D_wrap.cpp:8887:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,266 8887 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,266 | ^~~~~~~~ 2023-09-08T22:04:01,267 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,268 Box2D/Box2D_wrap.cpp:8894:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,268 8894 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,269 | ^~ 2023-09-08T22:04:01,269 Box2D/Box2D_wrap.cpp:8894:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,270 8894 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-08T22:04:01,270 | ^~~~~~~~ 2023-09-08T22:04:01,271 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Manifold(PyObject*, PyObject*)’: 2023-09-08T22:04:01,271 Box2D/Box2D_wrap.cpp:8914:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,272 8914 | if (!SWIG_Python_UnpackTuple(args, "new_b2Manifold", 0, 0, 0)) SWIG_fail; { try { result = (b2Manifold *)new b2Manifold(); } 2023-09-08T22:04:01,273 | ^~ 2023-09-08T22:04:01,274 Box2D/Box2D_wrap.cpp:8914:77: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,274 8914 | if (!SWIG_Python_UnpackTuple(args, "new_b2Manifold", 0, 0, 0)) SWIG_fail; { try { result = (b2Manifold *)new b2Manifold(); } 2023-09-08T22:04:01,275 | ^ 2023-09-08T22:04:01,282 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WorldManifold_normal_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,283 Box2D/Box2D_wrap.cpp:8985:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,283 8985 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WorldManifold, 0 | 0 ); 2023-09-08T22:04:01,284 | ^~ 2023-09-08T22:04:01,285 Box2D/Box2D_wrap.cpp:8985:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,286 8985 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WorldManifold, 0 | 0 ); 2023-09-08T22:04:01,286 | ^~~~~~~~ 2023-09-08T22:04:01,287 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WorldManifold___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,288 Box2D/Box2D_wrap.cpp:8992:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,288 8992 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WorldManifold, 0 | 0 ); 2023-09-08T22:04:01,289 | ^~ 2023-09-08T22:04:01,290 Box2D/Box2D_wrap.cpp:8992:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,291 8992 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WorldManifold, 0 | 0 ); 2023-09-08T22:04:01,291 | ^~~~~~~~ 2023-09-08T22:04:01,295 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ClipVertex_v_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,296 Box2D/Box2D_wrap.cpp:9048:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,297 9048 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-08T22:04:01,297 | ^~ 2023-09-08T22:04:01,298 Box2D/Box2D_wrap.cpp:9048:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,298 9048 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-08T22:04:01,299 | ^~~~~~~~ 2023-09-08T22:04:01,299 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ClipVertex_id_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,300 Box2D/Box2D_wrap.cpp:9066:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,301 9066 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-08T22:04:01,301 | ^~ 2023-09-08T22:04:01,302 Box2D/Box2D_wrap.cpp:9066:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,302 9066 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-08T22:04:01,303 | ^~~~~~~~ 2023-09-08T22:04:01,304 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ClipVertex___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,304 Box2D/Box2D_wrap.cpp:9074:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,305 9074 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-08T22:04:01,305 | ^~ 2023-09-08T22:04:01,306 Box2D/Box2D_wrap.cpp:9074:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,307 9074 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-08T22:04:01,308 | ^~~~~~~~ 2023-09-08T22:04:01,312 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastInput_p1_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,313 Box2D/Box2D_wrap.cpp:9121:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,313 9121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-08T22:04:01,314 | ^~ 2023-09-08T22:04:01,315 Box2D/Box2D_wrap.cpp:9121:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,316 9121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-08T22:04:01,316 | ^~~~~~~~ 2023-09-08T22:04:01,318 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastInput_p2_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,319 Box2D/Box2D_wrap.cpp:9144:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,319 9144 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-08T22:04:01,320 | ^~ 2023-09-08T22:04:01,321 Box2D/Box2D_wrap.cpp:9144:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,322 9144 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-08T22:04:01,322 | ^~~~~~~~ 2023-09-08T22:04:01,324 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastInput_maxFraction_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,324 Box2D/Box2D_wrap.cpp:9160:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,325 9160 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-08T22:04:01,325 | ^~ 2023-09-08T22:04:01,326 Box2D/Box2D_wrap.cpp:9160:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,326 9160 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-08T22:04:01,327 | ^~~~~~~~ 2023-09-08T22:04:01,327 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastInput___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,328 Box2D/Box2D_wrap.cpp:9167:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,328 9167 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-08T22:04:01,329 | ^~ 2023-09-08T22:04:01,330 Box2D/Box2D_wrap.cpp:9167:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,330 9167 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-08T22:04:01,331 | ^~~~~~~~ 2023-09-08T22:04:01,335 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastOutput_normal_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,336 Box2D/Box2D_wrap.cpp:9215:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,336 9215 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-08T22:04:01,337 | ^~ 2023-09-08T22:04:01,337 Box2D/Box2D_wrap.cpp:9215:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,338 9215 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-08T22:04:01,339 | ^~~~~~~~ 2023-09-08T22:04:01,339 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastOutput_fraction_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,340 Box2D/Box2D_wrap.cpp:9231:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,341 9231 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-08T22:04:01,342 | ^~ 2023-09-08T22:04:01,342 Box2D/Box2D_wrap.cpp:9231:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,343 9231 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-08T22:04:01,344 | ^~~~~~~~ 2023-09-08T22:04:01,344 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastOutput___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,345 Box2D/Box2D_wrap.cpp:9238:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,346 9238 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-08T22:04:01,347 | ^~ 2023-09-08T22:04:01,347 Box2D/Box2D_wrap.cpp:9238:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,348 9238 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-08T22:04:01,349 | ^~~~~~~~ 2023-09-08T22:04:01,350 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___GetCenter(PyObject*, PyObject*)’: 2023-09-08T22:04:01,350 Box2D/Box2D_wrap.cpp:9277:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,351 9277 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-08T22:04:01,351 | ^~ 2023-09-08T22:04:01,352 Box2D/Box2D_wrap.cpp:9277:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,352 9277 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-08T22:04:01,353 | ^~~~~~~~ 2023-09-08T22:04:01,353 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___GetExtents(PyObject*, PyObject*)’: 2023-09-08T22:04:01,354 Box2D/Box2D_wrap.cpp:9286:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,355 9286 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-08T22:04:01,355 | ^~ 2023-09-08T22:04:01,356 Box2D/Box2D_wrap.cpp:9286:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,356 9286 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-08T22:04:01,357 | ^~~~~~~~ 2023-09-08T22:04:01,361 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_Combine(PyObject*, PyObject*)’: 2023-09-08T22:04:01,362 Box2D/Box2D_wrap.cpp:9331:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,362 9331 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB_Combine", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:01,363 | ^~ 2023-09-08T22:04:01,363 Box2D/Box2D_wrap.cpp:9331:89: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,364 9331 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB_Combine", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:01,364 | ^~ 2023-09-08T22:04:01,365 Box2D/Box2D_wrap.cpp:9333:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,366 9333 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:01,366 | ^~ 2023-09-08T22:04:01,367 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,368 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,368 | ^~~~ 2023-09-08T22:04:01,369 Box2D/Box2D_wrap.cpp:9333:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,370 9333 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:01,370 | ^~~~~~~~~ 2023-09-08T22:04:01,371 Box2D/Box2D_wrap.cpp:9335:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,372 9335 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,372 | ^~ 2023-09-08T22:04:01,373 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,374 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,375 | ^~~~ 2023-09-08T22:04:01,375 Box2D/Box2D_wrap.cpp:9335:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,376 9335 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,376 | ^~~~~~~~~ 2023-09-08T22:04:01,377 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_lowerBound_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,378 Box2D/Box2D_wrap.cpp:9388:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,378 9388 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-08T22:04:01,379 | ^~ 2023-09-08T22:04:01,379 Box2D/Box2D_wrap.cpp:9388:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,380 9388 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-08T22:04:01,380 | ^~~~~~~~ 2023-09-08T22:04:01,383 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_upperBound_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,384 Box2D/Box2D_wrap.cpp:9410:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,385 9410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-08T22:04:01,385 | ^~ 2023-09-08T22:04:01,386 Box2D/Box2D_wrap.cpp:9410:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,386 9410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-08T22:04:01,387 | ^~~~~~~~ 2023-09-08T22:04:01,391 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___contains__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,392 Box2D/Box2D_wrap.cpp:9440:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,393 9440 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB___contains__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:01,393 | ^~ 2023-09-08T22:04:01,394 Box2D/Box2D_wrap.cpp:9440:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,395 9440 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB___contains__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:01,396 | ^~ 2023-09-08T22:04:01,396 Box2D/Box2D_wrap.cpp:9442:6: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,397 9442 | if (!_v) goto check_1; return _wrap_b2AABB___contains____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-08T22:04:01,397 | ^~ 2023-09-08T22:04:01,398 Box2D/Box2D_wrap.cpp:9442:29: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,399 9442 | if (!_v) goto check_1; return _wrap_b2AABB___contains____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-08T22:04:01,399 | ^~~~~~ 2023-09-08T22:04:01,400 Box2D/Box2D_wrap.cpp:9444:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,401 9444 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,402 | ^~ 2023-09-08T22:04:01,403 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,403 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,404 | ^~~~ 2023-09-08T22:04:01,404 Box2D/Box2D_wrap.cpp:9444:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,405 9444 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,405 | ^~~~~~~~~ 2023-09-08T22:04:01,406 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2AABB(PyObject*, PyObject*)’: 2023-09-08T22:04:01,406 Box2D/Box2D_wrap.cpp:9463:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,407 9463 | if (!SWIG_Python_UnpackTuple(args, "new_b2AABB", 0, 0, 0)) SWIG_fail; { try { result = (b2AABB *)new b2AABB(); } 2023-09-08T22:04:01,407 | ^~ 2023-09-08T22:04:01,408 Box2D/Box2D_wrap.cpp:9463:73: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,408 9463 | if (!SWIG_Python_UnpackTuple(args, "new_b2AABB", 0, 0, 0)) SWIG_fail; { try { result = (b2AABB *)new b2AABB(); } 2023-09-08T22:04:01,409 | ^ 2023-09-08T22:04:01,430 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TestOverlap__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,431 Box2D/Box2D_wrap.cpp:9662:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,431 9662 | if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2023-09-08T22:04:01,432 | ^~ 2023-09-08T22:04:01,432 Box2D/Box2D_wrap.cpp:9662:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,433 9662 | if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2023-09-08T22:04:01,434 | ^~~~ 2023-09-08T22:04:01,437 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TestOverlap(PyObject*, PyObject*)’: 2023-09-08T22:04:01,438 Box2D/Box2D_wrap.cpp:9703:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,439 9703 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2TestOverlap", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:01,439 | ^~ 2023-09-08T22:04:01,440 Box2D/Box2D_wrap.cpp:9703:88: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,441 9703 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2TestOverlap", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:01,441 | ^~ 2023-09-08T22:04:01,442 Box2D/Box2D_wrap.cpp:9706:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,442 9706 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,443 | ^~ 2023-09-08T22:04:01,444 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,444 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,445 | ^~~~ 2023-09-08T22:04:01,446 Box2D/Box2D_wrap.cpp:9706:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,446 9706 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,447 | ^~~~~~~~~ 2023-09-08T22:04:01,451 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Vec2Array_cast(PyObject*, PyObject*)’: 2023-09-08T22:04:01,452 Box2D/Box2D_wrap.cpp:9759:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,452 9759 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__b2Vec2Array, 0 | 0 ); 2023-09-08T22:04:01,453 | ^~ 2023-09-08T22:04:01,453 Box2D/Box2D_wrap.cpp:9759:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,454 9759 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__b2Vec2Array, 0 | 0 ); 2023-09-08T22:04:01,455 | ^~~~~~~~ 2023-09-08T22:04:01,455 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Vec2Array_frompointer(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,456 Box2D/Box2D_wrap.cpp:9768:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,456 9768 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:_b2Vec2Array_frompointer", kwnames, &obj0)) SWIG_fail; { 2023-09-08T22:04:01,457 | ^~ 2023-09-08T22:04:01,458 Box2D/Box2D_wrap.cpp:9768:108: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,458 9768 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:_b2Vec2Array_frompointer", kwnames, &obj0)) SWIG_fail; { 2023-09-08T22:04:01,459 | ^ 2023-09-08T22:04:01,463 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_Set(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,463 Box2D/Box2D_wrap.cpp:9815:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,464 9815 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Color_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2023-09-08T22:04:01,464 | ^~ 2023-09-08T22:04:01,465 Box2D/Box2D_wrap.cpp:9815:119: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,466 9815 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Color_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2023-09-08T22:04:01,466 | ^ 2023-09-08T22:04:01,467 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_r_set(PyObject*, PyObject*)’: 2023-09-08T22:04:01,467 Box2D/Box2D_wrap.cpp:9828:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,468 9828 | if (!SWIG_Python_UnpackTuple(args, "b2Color_r_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:01,469 | ^~ 2023-09-08T22:04:01,469 Box2D/Box2D_wrap.cpp:9828:83: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,470 9828 | if (!SWIG_Python_UnpackTuple(args, "b2Color_r_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:01,470 | ^ 2023-09-08T22:04:01,471 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_g_set(PyObject*, PyObject*)’: 2023-09-08T22:04:01,472 Box2D/Box2D_wrap.cpp:9843:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,472 9843 | if (!SWIG_Python_UnpackTuple(args, "b2Color_g_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:01,473 | ^~ 2023-09-08T22:04:01,473 Box2D/Box2D_wrap.cpp:9843:83: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,474 9843 | if (!SWIG_Python_UnpackTuple(args, "b2Color_g_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:01,475 | ^ 2023-09-08T22:04:01,476 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_b_set(PyObject*, PyObject*)’: 2023-09-08T22:04:01,476 Box2D/Box2D_wrap.cpp:9858:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,477 9858 | if (!SWIG_Python_UnpackTuple(args, "b2Color_b_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:01,477 | ^~ 2023-09-08T22:04:01,478 Box2D/Box2D_wrap.cpp:9858:83: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,478 9858 | if (!SWIG_Python_UnpackTuple(args, "b2Color_b_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-08T22:04:01,479 | ^ 2023-09-08T22:04:01,483 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Color(PyObject*, PyObject*)’: 2023-09-08T22:04:01,484 Box2D/Box2D_wrap.cpp:9893:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,484 9893 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Color", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:01,485 | ^~ 2023-09-08T22:04:01,485 Box2D/Box2D_wrap.cpp:9893:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,486 9893 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Color", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-08T22:04:01,486 | ^~ 2023-09-08T22:04:01,487 Box2D/Box2D_wrap.cpp:9896:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,488 9896 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:01,488 | ^~ 2023-09-08T22:04:01,489 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,490 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,490 | ^~~~ 2023-09-08T22:04:01,491 Box2D/Box2D_wrap.cpp:9896:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,492 9896 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:01,492 | ^~~~~~~~~ 2023-09-08T22:04:01,493 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___getitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,494 Box2D/Box2D_wrap.cpp:9911:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,494 9911 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,495 | ^~ 2023-09-08T22:04:01,496 Box2D/Box2D_wrap.cpp:9911:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,496 9911 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,497 | ^ 2023-09-08T22:04:01,497 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___setitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,498 Box2D/Box2D_wrap.cpp:9923:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,499 9923 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Color___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:01,500 | ^~ 2023-09-08T22:04:01,500 Box2D/Box2D_wrap.cpp:9923:119: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,501 9923 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Color___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-08T22:04:01,501 | ^ 2023-09-08T22:04:01,502 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___truediv__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,502 Box2D/Box2D_wrap.cpp:9935:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,503 9935 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,503 | ^~ 2023-09-08T22:04:01,504 Box2D/Box2D_wrap.cpp:9935:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,505 9935 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,505 | ^ 2023-09-08T22:04:01,506 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___add__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,506 Box2D/Box2D_wrap.cpp:9947:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,507 9947 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,507 | ^~ 2023-09-08T22:04:01,508 Box2D/Box2D_wrap.cpp:9947:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,509 9947 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,509 | ^ 2023-09-08T22:04:01,510 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___sub__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,511 Box2D/Box2D_wrap.cpp:9966:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,512 9966 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,512 | ^~ 2023-09-08T22:04:01,513 Box2D/Box2D_wrap.cpp:9966:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,514 9966 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,514 | ^ 2023-09-08T22:04:01,515 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___div__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,515 Box2D/Box2D_wrap.cpp:9985:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,516 9985 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,517 | ^~ 2023-09-08T22:04:01,517 Box2D/Box2D_wrap.cpp:9985:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,518 9985 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,519 | ^ 2023-09-08T22:04:01,520 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___rmul__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,520 Box2D/Box2D_wrap.cpp:9997:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,521 9997 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,521 | ^~ 2023-09-08T22:04:01,522 Box2D/Box2D_wrap.cpp:9997:108: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,522 9997 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,523 | ^ 2023-09-08T22:04:01,523 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___mul__(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,524 Box2D/Box2D_wrap.cpp:10009:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,524 10009 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,525 | ^~ 2023-09-08T22:04:01,526 Box2D/Box2D_wrap.cpp:10009:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,526 10009 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,527 | ^ 2023-09-08T22:04:01,527 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___isub(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,528 Box2D/Box2D_wrap.cpp:10021:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,528 10021 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___isub", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,529 | ^~ 2023-09-08T22:04:01,530 Box2D/Box2D_wrap.cpp:10021:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,530 10021 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___isub", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,531 | ^ 2023-09-08T22:04:01,531 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___itruediv(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,532 Box2D/Box2D_wrap.cpp:10039:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,533 10039 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___itruediv", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,533 | ^~ 2023-09-08T22:04:01,534 Box2D/Box2D_wrap.cpp:10039:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,535 10039 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___itruediv", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,535 | ^ 2023-09-08T22:04:01,536 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___idiv(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,536 Box2D/Box2D_wrap.cpp:10057:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,537 10057 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___idiv", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,538 | ^~ 2023-09-08T22:04:01,538 Box2D/Box2D_wrap.cpp:10057:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,539 10057 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___idiv", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,539 | ^ 2023-09-08T22:04:01,540 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___imul(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,541 Box2D/Box2D_wrap.cpp:10075:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,541 10075 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___imul", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,542 | ^~ 2023-09-08T22:04:01,542 Box2D/Box2D_wrap.cpp:10075:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,543 10075 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___imul", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,543 | ^ 2023-09-08T22:04:01,544 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___iadd(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,544 Box2D/Box2D_wrap.cpp:10093:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,545 10093 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___iadd", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,545 | ^~ 2023-09-08T22:04:01,546 Box2D/Box2D_wrap.cpp:10093:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,547 10093 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___iadd", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,547 | ^ 2023-09-08T22:04:01,548 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___equ(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,548 Box2D/Box2D_wrap.cpp:10111:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,549 10111 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,549 | ^~ 2023-09-08T22:04:01,550 Box2D/Box2D_wrap.cpp:10111:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,551 10111 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-08T22:04:01,551 | ^ 2023-09-08T22:04:01,555 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Draw(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,555 Box2D/Box2D_wrap.cpp:10145:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,556 10145 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2Draw", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:01,557 | ^~ 2023-09-08T22:04:01,557 Box2D/Box2D_wrap.cpp:10145:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,558 10145 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2Draw", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:01,559 | ^~~~ 2023-09-08T22:04:01,610 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_convertVertices_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,610 Box2D/Box2D_wrap.cpp:10433:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,611 10433 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,612 | ^~ 2023-09-08T22:04:01,612 Box2D/Box2D_wrap.cpp:10433:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,613 10433 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,613 | ^~~~~~~~ 2023-09-08T22:04:01,616 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_center_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,617 Box2D/Box2D_wrap.cpp:10456:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,617 10456 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,618 | ^~ 2023-09-08T22:04:01,618 Box2D/Box2D_wrap.cpp:10456:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,619 10456 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,619 | ^~~~~~~~ 2023-09-08T22:04:01,622 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_offset_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,623 Box2D/Box2D_wrap.cpp:10479:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,623 10479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,624 | ^~ 2023-09-08T22:04:01,625 Box2D/Box2D_wrap.cpp:10479:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,625 10479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,626 | ^~~~~~~~ 2023-09-08T22:04:01,627 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_zoom_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,627 Box2D/Box2D_wrap.cpp:10495:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,628 10495 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,628 | ^~ 2023-09-08T22:04:01,629 Box2D/Box2D_wrap.cpp:10495:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,630 10495 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,630 | ^~~~~~~~ 2023-09-08T22:04:01,632 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_screenSize_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,633 Box2D/Box2D_wrap.cpp:10518:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,633 10518 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,634 | ^~ 2023-09-08T22:04:01,635 Box2D/Box2D_wrap.cpp:10518:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,635 10518 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,636 | ^~~~~~~~ 2023-09-08T22:04:01,637 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_flipY_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,638 Box2D/Box2D_wrap.cpp:10534:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,638 10534 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,639 | ^~ 2023-09-08T22:04:01,639 Box2D/Box2D_wrap.cpp:10534:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,640 10534 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,640 | ^~~~~~~~ 2023-09-08T22:04:01,641 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_flipX_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,641 Box2D/Box2D_wrap.cpp:10550:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,642 10550 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,642 | ^~ 2023-09-08T22:04:01,643 Box2D/Box2D_wrap.cpp:10550:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,644 10550 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,644 | ^~~~~~~~ 2023-09-08T22:04:01,693 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2DrawExtended(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:01,693 Box2D/Box2D_wrap.cpp:10820:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,694 10820 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DrawExtended", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:01,695 | ^~ 2023-09-08T22:04:01,695 Box2D/Box2D_wrap.cpp:10820:102: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,696 10820 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DrawExtended", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:01,696 | ^~~~ 2023-09-08T22:04:01,697 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,698 Box2D/Box2D_wrap.cpp:10828:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,698 10828 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,699 | ^~ 2023-09-08T22:04:01,699 Box2D/Box2D_wrap.cpp:10828:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,700 10828 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-08T22:04:01,701 | ^~~~~~~~ 2023-09-08T22:04:01,703 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData_mass_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,704 Box2D/Box2D_wrap.cpp:10880:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,705 10880 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-08T22:04:01,705 | ^~ 2023-09-08T22:04:01,706 Box2D/Box2D_wrap.cpp:10880:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,707 10880 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-08T22:04:01,707 | ^~~~~~~~ 2023-09-08T22:04:01,709 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData_center_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,710 Box2D/Box2D_wrap.cpp:10903:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,711 10903 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-08T22:04:01,711 | ^~ 2023-09-08T22:04:01,712 Box2D/Box2D_wrap.cpp:10903:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,712 10903 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-08T22:04:01,713 | ^~~~~~~~ 2023-09-08T22:04:01,714 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData_I_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,714 Box2D/Box2D_wrap.cpp:10919:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,715 10919 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-08T22:04:01,715 | ^~ 2023-09-08T22:04:01,716 Box2D/Box2D_wrap.cpp:10919:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,717 10919 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-08T22:04:01,717 | ^~~~~~~~ 2023-09-08T22:04:01,718 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,718 Box2D/Box2D_wrap.cpp:10926:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,719 10926 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-08T22:04:01,719 | ^~ 2023-09-08T22:04:01,720 Box2D/Box2D_wrap.cpp:10926:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,721 10926 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-08T22:04:01,721 | ^~~~~~~~ 2023-09-08T22:04:01,722 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2MassData(PyObject*, PyObject*)’: 2023-09-08T22:04:01,723 Box2D/Box2D_wrap.cpp:10933:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,723 10933 | if (!SWIG_Python_UnpackTuple(args, "new_b2MassData", 0, 0, 0)) SWIG_fail; { try { result = (b2MassData *)new b2MassData(); } 2023-09-08T22:04:01,724 | ^~ 2023-09-08T22:04:01,725 Box2D/Box2D_wrap.cpp:10933:77: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,725 10933 | if (!SWIG_Python_UnpackTuple(args, "new_b2MassData", 0, 0, 0)) SWIG_fail; { try { result = (b2MassData *)new b2MassData(); } 2023-09-08T22:04:01,726 | ^ 2023-09-08T22:04:01,726 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Shape___GetType(PyObject*, PyObject*)’: 2023-09-08T22:04:01,727 Box2D/Box2D_wrap.cpp:10964:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,728 10964 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2023-09-08T22:04:01,728 | ^~ 2023-09-08T22:04:01,729 Box2D/Box2D_wrap.cpp:10964:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,730 10964 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2023-09-08T22:04:01,730 | ^~~~~~~~ 2023-09-08T22:04:01,752 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2CircleShape_pos_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,753 Box2D/Box2D_wrap.cpp:11117:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,753 11117 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2023-09-08T22:04:01,754 | ^~ 2023-09-08T22:04:01,754 Box2D/Box2D_wrap.cpp:11117:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,755 11117 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2023-09-08T22:04:01,755 | ^~~~~~~~ 2023-09-08T22:04:01,756 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2CircleShape___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,757 Box2D/Box2D_wrap.cpp:11124:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,757 11124 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2023-09-08T22:04:01,758 | ^~ 2023-09-08T22:04:01,758 Box2D/Box2D_wrap.cpp:11124:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,759 11124 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2023-09-08T22:04:01,759 | ^~~~~~~~ 2023-09-08T22:04:01,760 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2EdgeShape(PyObject*, PyObject*)’: 2023-09-08T22:04:01,760 Box2D/Box2D_wrap.cpp:11149:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,761 11149 | if (!SWIG_Python_UnpackTuple(args, "new_b2EdgeShape", 0, 0, 0)) SWIG_fail; { try { result = (b2EdgeShape *)new b2EdgeShape(); } 2023-09-08T22:04:01,762 | ^~ 2023-09-08T22:04:01,762 Box2D/Box2D_wrap.cpp:11149:78: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,763 11149 | if (!SWIG_Python_UnpackTuple(args, "new_b2EdgeShape", 0, 0, 0)) SWIG_fail; { try { result = (b2EdgeShape *)new b2EdgeShape(); } 2023-09-08T22:04:01,763 | ^ 2023-09-08T22:04:01,770 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_vertex1_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,771 Box2D/Box2D_wrap.cpp:11197:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,772 11197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,772 | ^~ 2023-09-08T22:04:01,773 Box2D/Box2D_wrap.cpp:11197:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,774 11197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,774 | ^~~~~~~~ 2023-09-08T22:04:01,777 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_vertex2_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,777 Box2D/Box2D_wrap.cpp:11220:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,778 11220 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,779 | ^~ 2023-09-08T22:04:01,779 Box2D/Box2D_wrap.cpp:11220:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,780 11220 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,781 | ^~~~~~~~ 2023-09-08T22:04:01,783 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_vertex0_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,784 Box2D/Box2D_wrap.cpp:11243:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,784 11243 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,785 | ^~ 2023-09-08T22:04:01,785 Box2D/Box2D_wrap.cpp:11243:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,786 11243 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,787 | ^~~~~~~~ 2023-09-08T22:04:01,789 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_vertex3_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,790 Box2D/Box2D_wrap.cpp:11266:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,790 11266 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,791 | ^~ 2023-09-08T22:04:01,792 Box2D/Box2D_wrap.cpp:11266:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,792 11266 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,793 | ^~~~~~~~ 2023-09-08T22:04:01,794 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_hasVertex0_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,794 Box2D/Box2D_wrap.cpp:11282:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,795 11282 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,796 | ^~ 2023-09-08T22:04:01,796 Box2D/Box2D_wrap.cpp:11282:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,797 11282 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,798 | ^~~~~~~~ 2023-09-08T22:04:01,798 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_hasVertex3_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,799 Box2D/Box2D_wrap.cpp:11298:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,800 11298 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,800 | ^~ 2023-09-08T22:04:01,801 Box2D/Box2D_wrap.cpp:11298:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,801 11298 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,802 | ^~~~~~~~ 2023-09-08T22:04:01,803 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,803 Box2D/Box2D_wrap.cpp:11305:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,804 11305 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,805 | ^~ 2023-09-08T22:04:01,805 Box2D/Box2D_wrap.cpp:11305:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,806 11305 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-08T22:04:01,806 | ^~~~~~~~ 2023-09-08T22:04:01,826 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_prevVertex_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,827 Box2D/Box2D_wrap.cpp:11448:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,828 11448 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,828 | ^~ 2023-09-08T22:04:01,829 Box2D/Box2D_wrap.cpp:11448:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,829 11448 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,830 | ^~~~~~~~ 2023-09-08T22:04:01,832 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_nextVertex_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,833 Box2D/Box2D_wrap.cpp:11471:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,834 11471 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,834 | ^~ 2023-09-08T22:04:01,835 Box2D/Box2D_wrap.cpp:11471:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,835 11471 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,836 | ^~~~~~~~ 2023-09-08T22:04:01,837 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_hasPrevVertex_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,837 Box2D/Box2D_wrap.cpp:11487:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,838 11487 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,839 | ^~ 2023-09-08T22:04:01,840 Box2D/Box2D_wrap.cpp:11487:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,840 11487 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,841 | ^~~~~~~~ 2023-09-08T22:04:01,841 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_hasNextVertex_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,842 Box2D/Box2D_wrap.cpp:11503:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,843 11503 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,843 | ^~ 2023-09-08T22:04:01,844 Box2D/Box2D_wrap.cpp:11503:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,845 11503 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,845 | ^~~~~~~~ 2023-09-08T22:04:01,846 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,846 Box2D/Box2D_wrap.cpp:11510:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,848 11510 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,848 | ^~ 2023-09-08T22:04:01,849 Box2D/Box2D_wrap.cpp:11510:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,849 11510 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,850 | ^~~~~~~~ 2023-09-08T22:04:01,850 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape___get_vertices(PyObject*, PyObject*)’: 2023-09-08T22:04:01,851 Box2D/Box2D_wrap.cpp:11518:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,851 11518 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,852 | ^~ 2023-09-08T22:04:01,853 Box2D/Box2D_wrap.cpp:11518:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,853 11518 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,854 | ^~~~~~~~ 2023-09-08T22:04:01,855 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape___get_count(PyObject*, PyObject*)’: 2023-09-08T22:04:01,855 Box2D/Box2D_wrap.cpp:11556:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,856 11556 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,857 | ^~ 2023-09-08T22:04:01,857 Box2D/Box2D_wrap.cpp:11556:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,858 11556 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-08T22:04:01,859 | ^~~~~~~~ 2023-09-08T22:04:01,869 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_SetAsBox(PyObject*, PyObject*)’: 2023-09-08T22:04:01,870 Box2D/Box2D_wrap.cpp:11633:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,870 11633 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape_SetAsBox", 0, 5, argv))) SWIG_fail; --argc; if (argc == 3) { 2023-09-08T22:04:01,871 | ^~ 2023-09-08T22:04:01,872 Box2D/Box2D_wrap.cpp:11633:98: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,873 11633 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape_SetAsBox", 0, 5, argv))) SWIG_fail; --argc; if (argc == 3) { 2023-09-08T22:04:01,873 | ^~ 2023-09-08T22:04:01,874 Box2D/Box2D_wrap.cpp:11635:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,874 11635 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 5) { 2023-09-08T22:04:01,875 | ^~ 2023-09-08T22:04:01,875 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,876 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,877 | ^~~~ 2023-09-08T22:04:01,878 Box2D/Box2D_wrap.cpp:11635:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,878 11635 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 5) { 2023-09-08T22:04:01,879 | ^~~~~~~~~ 2023-09-08T22:04:01,880 Box2D/Box2D_wrap.cpp:11637:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,880 11637 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,881 | ^~ 2023-09-08T22:04:01,881 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,882 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,882 | ^~~~ 2023-09-08T22:04:01,883 Box2D/Box2D_wrap.cpp:11637:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,884 11637 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,884 | ^~~~~~~~~ 2023-09-08T22:04:01,885 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_Validate(PyObject*, PyObject*)’: 2023-09-08T22:04:01,885 Box2D/Box2D_wrap.cpp:11643:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,886 11643 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,886 | ^~ 2023-09-08T22:04:01,887 Box2D/Box2D_wrap.cpp:11643:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,887 11643 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,888 | ^~~~~~~~ 2023-09-08T22:04:01,888 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_centroid_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,889 Box2D/Box2D_wrap.cpp:11667:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,890 11667 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,890 | ^~ 2023-09-08T22:04:01,891 Box2D/Box2D_wrap.cpp:11667:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,892 11667 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,892 | ^~~~~~~~ 2023-09-08T22:04:01,893 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_vertexCount_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,894 Box2D/Box2D_wrap.cpp:11683:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,894 11683 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,895 | ^~ 2023-09-08T22:04:01,895 Box2D/Box2D_wrap.cpp:11683:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,896 11683 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,897 | ^~~~~~~~ 2023-09-08T22:04:01,897 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,898 Box2D/Box2D_wrap.cpp:11690:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,899 11690 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,899 | ^~ 2023-09-08T22:04:01,901 Box2D/Box2D_wrap.cpp:11690:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,901 11690 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,902 | ^~~~~~~~ 2023-09-08T22:04:01,902 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___get_vertices(PyObject*, PyObject*)’: 2023-09-08T22:04:01,903 Box2D/Box2D_wrap.cpp:11698:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,903 11698 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,904 | ^~ 2023-09-08T22:04:01,904 Box2D/Box2D_wrap.cpp:11698:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,905 11698 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,906 | ^~~~~~~~ 2023-09-08T22:04:01,906 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___get_normals(PyObject*, PyObject*)’: 2023-09-08T22:04:01,907 Box2D/Box2D_wrap.cpp:11706:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,907 11706 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,908 | ^~ 2023-09-08T22:04:01,908 Box2D/Box2D_wrap.cpp:11706:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,909 11706 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,910 | ^~~~~~~~ 2023-09-08T22:04:01,910 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_set_vertex(PyObject*, PyObject*)’: 2023-09-08T22:04:01,911 Box2D/Box2D_wrap.cpp:11776:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,911 11776 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2023-09-08T22:04:01,912 | ^~ 2023-09-08T22:04:01,912 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,913 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,914 | ^~~~ 2023-09-08T22:04:01,914 Box2D/Box2D_wrap.cpp:11776:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,915 11776 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2023-09-08T22:04:01,915 | ^~~~~~~~~ 2023-09-08T22:04:01,916 Box2D/Box2D_wrap.cpp:11778:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,917 11778 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,917 | ^~ 2023-09-08T22:04:01,918 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,919 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,919 | ^~~~ 2023-09-08T22:04:01,920 Box2D/Box2D_wrap.cpp:11778:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,920 11778 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,921 | ^~~~~~~~~ 2023-09-08T22:04:01,922 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___set_vertices_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:01,923 Box2D/Box2D_wrap.cpp:11784:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,923 11784 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,923 | ^~ 2023-09-08T22:04:01,924 Box2D/Box2D_wrap.cpp:11784:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,924 11784 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-08T22:04:01,925 | ^~~~ 2023-09-08T22:04:01,926 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___set_vertices_internal(PyObject*, PyObject*)’: 2023-09-08T22:04:01,926 Box2D/Box2D_wrap.cpp:11792:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,927 11792 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape___set_vertices_internal", 0, 3, argv))) SWIG_fail; --argc; 2023-09-08T22:04:01,927 | ^~ 2023-09-08T22:04:01,928 Box2D/Box2D_wrap.cpp:11792:113: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,928 11792 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape___set_vertices_internal", 0, 3, argv))) SWIG_fail; --argc; 2023-09-08T22:04:01,929 | ^~ 2023-09-08T22:04:01,930 Box2D/Box2D_wrap.cpp:11794:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,931 11794 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:01,931 | ^~ 2023-09-08T22:04:01,932 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,932 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,933 | ^~~~ 2023-09-08T22:04:01,934 Box2D/Box2D_wrap.cpp:11794:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,935 11794 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:01,935 | ^~~~~~~~~ 2023-09-08T22:04:01,936 Box2D/Box2D_wrap.cpp:11796:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,937 11796 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,937 | ^~ 2023-09-08T22:04:01,938 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,939 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:01,939 | ^~~~ 2023-09-08T22:04:01,940 Box2D/Box2D_wrap.cpp:11796:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:01,940 11796 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:01,941 | ^~~~~~~~~ 2023-09-08T22:04:01,942 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_IsLeaf(PyObject*, PyObject*)’: 2023-09-08T22:04:01,942 Box2D/Box2D_wrap.cpp:11820:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,943 11820 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,944 | ^~ 2023-09-08T22:04:01,945 Box2D/Box2D_wrap.cpp:11820:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,945 11820 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,946 | ^~~~~~~~ 2023-09-08T22:04:01,946 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_aabb_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,947 Box2D/Box2D_wrap.cpp:11838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,947 11838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,948 | ^~ 2023-09-08T22:04:01,949 Box2D/Box2D_wrap.cpp:11838:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,949 11838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,950 | ^~~~~~~~ 2023-09-08T22:04:01,950 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_child1_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,951 Box2D/Box2D_wrap.cpp:11854:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,951 11854 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,952 | ^~ 2023-09-08T22:04:01,953 Box2D/Box2D_wrap.cpp:11854:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,953 11854 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,954 | ^~~~~~~~ 2023-09-08T22:04:01,955 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_child2_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,955 Box2D/Box2D_wrap.cpp:11870:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,956 11870 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,957 | ^~ 2023-09-08T22:04:01,957 Box2D/Box2D_wrap.cpp:11870:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,958 11870 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,959 | ^~~~~~~~ 2023-09-08T22:04:01,960 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_height_get(PyObject*, PyObject*)’: 2023-09-08T22:04:01,960 Box2D/Box2D_wrap.cpp:11886:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,961 11886 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,962 | ^~ 2023-09-08T22:04:01,962 Box2D/Box2D_wrap.cpp:11886:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,963 11886 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-08T22:04:01,964 | ^~~~~~~~ 2023-09-08T22:04:01,965 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2TreeNode(PyObject*, PyObject*)’: 2023-09-08T22:04:01,965 Box2D/Box2D_wrap.cpp:11892:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,966 11892 | if (!SWIG_Python_UnpackTuple(args, "new_b2TreeNode", 0, 0, 0)) SWIG_fail; { try { result = (b2TreeNode *)new b2TreeNode(); } 2023-09-08T22:04:01,967 | ^~ 2023-09-08T22:04:01,967 Box2D/Box2D_wrap.cpp:11892:77: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,968 11892 | if (!SWIG_Python_UnpackTuple(args, "new_b2TreeNode", 0, 0, 0)) SWIG_fail; { try { result = (b2TreeNode *)new b2TreeNode(); } 2023-09-08T22:04:01,968 | ^ 2023-09-08T22:04:01,969 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Pair(PyObject*, PyObject*)’: 2023-09-08T22:04:01,970 Box2D/Box2D_wrap.cpp:11952:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,970 11952 | if (!SWIG_Python_UnpackTuple(args, "new_b2Pair", 0, 0, 0)) SWIG_fail; { try { result = (b2Pair *)new b2Pair(); } 2023-09-08T22:04:01,971 | ^~ 2023-09-08T22:04:01,971 Box2D/Box2D_wrap.cpp:11952:73: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,972 11952 | if (!SWIG_Python_UnpackTuple(args, "new_b2Pair", 0, 0, 0)) SWIG_fail; { try { result = (b2Pair *)new b2Pair(); } 2023-09-08T22:04:01,972 | ^ 2023-09-08T22:04:01,979 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetProxyCount(PyObject*, PyObject*)’: 2023-09-08T22:04:01,979 Box2D/Box2D_wrap.cpp:12049:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,980 12049 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,981 | ^~ 2023-09-08T22:04:01,981 Box2D/Box2D_wrap.cpp:12049:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,982 12049 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,983 | ^~~~~~~~ 2023-09-08T22:04:01,983 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeHeight(PyObject*, PyObject*)’: 2023-09-08T22:04:01,984 Box2D/Box2D_wrap.cpp:12057:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,985 12057 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,986 | ^~ 2023-09-08T22:04:01,986 Box2D/Box2D_wrap.cpp:12057:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,987 12057 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,988 | ^~~~~~~~ 2023-09-08T22:04:01,988 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeBalance(PyObject*, PyObject*)’: 2023-09-08T22:04:01,989 Box2D/Box2D_wrap.cpp:12065:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,990 12065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,990 | ^~ 2023-09-08T22:04:01,991 Box2D/Box2D_wrap.cpp:12065:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,992 12065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,992 | ^~~~~~~~ 2023-09-08T22:04:01,993 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeQuality(PyObject*, PyObject*)’: 2023-09-08T22:04:01,994 Box2D/Box2D_wrap.cpp:12073:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,995 12073 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,995 | ^~ 2023-09-08T22:04:01,996 Box2D/Box2D_wrap.cpp:12073:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:01,996 12073 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,997 | ^~~~~~~~ 2023-09-08T22:04:01,998 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:01,998 Box2D/Box2D_wrap.cpp:12098:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:01,999 12098 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:01,999 | ^~ 2023-09-08T22:04:02,000 Box2D/Box2D_wrap.cpp:12098:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,001 12098 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-08T22:04:02,002 | ^~~~~~~~ 2023-09-08T22:04:02,011 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceProxy___get_vertex_count(PyObject*, PyObject*)’: 2023-09-08T22:04:02,011 Box2D/Box2D_wrap.cpp:12192:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,012 12192 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-08T22:04:02,013 | ^~ 2023-09-08T22:04:02,014 Box2D/Box2D_wrap.cpp:12192:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,015 12192 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-08T22:04:02,015 | ^~~~~~~~ 2023-09-08T22:04:02,018 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceProxy_m_buffer_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,019 Box2D/Box2D_wrap.cpp:12226:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,020 12226 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-08T22:04:02,020 | ^~ 2023-09-08T22:04:02,021 Box2D/Box2D_wrap.cpp:12226:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,022 12226 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-08T22:04:02,022 | ^~~~~~~~ 2023-09-08T22:04:02,023 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceProxy___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,024 Box2D/Box2D_wrap.cpp:12233:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,024 12233 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-08T22:04:02,025 | ^~ 2023-09-08T22:04:02,026 Box2D/Box2D_wrap.cpp:12233:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,027 12233 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-08T22:04:02,027 | ^~~~~~~~ 2023-09-08T22:04:02,040 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceInput_useRadii_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,040 Box2D/Box2D_wrap.cpp:12344:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,041 12344 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-08T22:04:02,042 | ^~ 2023-09-08T22:04:02,042 Box2D/Box2D_wrap.cpp:12344:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,043 12344 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-08T22:04:02,044 | ^~~~~~~~ 2023-09-08T22:04:02,044 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceInput___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,045 Box2D/Box2D_wrap.cpp:12351:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,045 12351 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-08T22:04:02,046 | ^~ 2023-09-08T22:04:02,046 Box2D/Box2D_wrap.cpp:12351:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,047 12351 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-08T22:04:02,047 | ^~~~~~~~ 2023-09-08T22:04:02,059 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceOutput_distance_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,060 Box2D/Box2D_wrap.cpp:12442:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,060 12442 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-08T22:04:02,061 | ^~ 2023-09-08T22:04:02,062 Box2D/Box2D_wrap.cpp:12442:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,062 12442 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-08T22:04:02,063 | ^~~~~~~~ 2023-09-08T22:04:02,064 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceOutput_iterations_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,065 Box2D/Box2D_wrap.cpp:12458:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,065 12458 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-08T22:04:02,066 | ^~ 2023-09-08T22:04:02,067 Box2D/Box2D_wrap.cpp:12458:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,067 12458 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-08T22:04:02,068 | ^~~~~~~~ 2023-09-08T22:04:02,069 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceOutput___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,069 Box2D/Box2D_wrap.cpp:12465:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,070 12465 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-08T22:04:02,071 | ^~ 2023-09-08T22:04:02,071 Box2D/Box2D_wrap.cpp:12465:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,072 12465 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-08T22:04:02,073 | ^~~~~~~~ 2023-09-08T22:04:02,074 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceOutput(PyObject*, PyObject*)’: 2023-09-08T22:04:02,074 Box2D/Box2D_wrap.cpp:12479:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,075 12479 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,076 | ^~ 2023-09-08T22:04:02,076 Box2D/Box2D_wrap.cpp:12479:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,077 12479 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,077 | ^~~~~~~~ 2023-09-08T22:04:02,078 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_proxyA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,079 Box2D/Box2D_wrap.cpp:12508:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,079 12508 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,080 | ^~ 2023-09-08T22:04:02,080 Box2D/Box2D_wrap.cpp:12508:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,081 12508 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,081 | ^~~~~~~~ 2023-09-08T22:04:02,082 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_proxyB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,082 Box2D/Box2D_wrap.cpp:12527:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,083 12527 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,084 | ^~ 2023-09-08T22:04:02,084 Box2D/Box2D_wrap.cpp:12527:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,085 12527 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,086 | ^~~~~~~~ 2023-09-08T22:04:02,087 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_sweepA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,087 Box2D/Box2D_wrap.cpp:12545:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,088 12545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,089 | ^~ 2023-09-08T22:04:02,090 Box2D/Box2D_wrap.cpp:12545:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,090 12545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,091 | ^~~~~~~~ 2023-09-08T22:04:02,092 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_sweepB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,092 Box2D/Box2D_wrap.cpp:12562:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,093 12562 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,094 | ^~ 2023-09-08T22:04:02,094 Box2D/Box2D_wrap.cpp:12562:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,095 12562 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,096 | ^~~~~~~~ 2023-09-08T22:04:02,097 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_tMax_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,097 Box2D/Box2D_wrap.cpp:12578:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,097 12578 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,098 | ^~ 2023-09-08T22:04:02,099 Box2D/Box2D_wrap.cpp:12578:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,099 12578 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,100 | ^~~~~~~~ 2023-09-08T22:04:02,100 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,101 Box2D/Box2D_wrap.cpp:12585:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,101 12585 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,102 | ^~ 2023-09-08T22:04:02,103 Box2D/Box2D_wrap.cpp:12585:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,103 12585 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-08T22:04:02,104 | ^~~~~~~~ 2023-09-08T22:04:02,105 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2TOIInput(PyObject*, PyObject*)’: 2023-09-08T22:04:02,106 Box2D/Box2D_wrap.cpp:12592:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,106 12592 | if (!SWIG_Python_UnpackTuple(args, "new_b2TOIInput", 0, 0, 0)) SWIG_fail; { try { result = (b2TOIInput *)new b2TOIInput(); } 2023-09-08T22:04:02,107 | ^~ 2023-09-08T22:04:02,108 Box2D/Box2D_wrap.cpp:12592:77: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,108 12592 | if (!SWIG_Python_UnpackTuple(args, "new_b2TOIInput", 0, 0, 0)) SWIG_fail; { try { result = (b2TOIInput *)new b2TOIInput(); } 2023-09-08T22:04:02,109 | ^ 2023-09-08T22:04:02,110 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIOutput_state_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,111 Box2D/Box2D_wrap.cpp:12625:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,111 12625 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-08T22:04:02,112 | ^~ 2023-09-08T22:04:02,113 Box2D/Box2D_wrap.cpp:12625:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,113 12625 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-08T22:04:02,114 | ^~~~~~~~ 2023-09-08T22:04:02,115 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIOutput_t_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,115 Box2D/Box2D_wrap.cpp:12641:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,116 12641 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-08T22:04:02,117 | ^~ 2023-09-08T22:04:02,117 Box2D/Box2D_wrap.cpp:12641:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,118 12641 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-08T22:04:02,119 | ^~~~~~~~ 2023-09-08T22:04:02,120 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIOutput___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,120 Box2D/Box2D_wrap.cpp:12648:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,121 12648 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-08T22:04:02,121 | ^~ 2023-09-08T22:04:02,122 Box2D/Box2D_wrap.cpp:12648:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,123 12648 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-08T22:04:02,123 | ^~~~~~~~ 2023-09-08T22:04:02,124 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2TOIOutput(PyObject*, PyObject*)’: 2023-09-08T22:04:02,124 Box2D/Box2D_wrap.cpp:12655:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,125 12655 | if (!SWIG_Python_UnpackTuple(args, "new_b2TOIOutput", 0, 0, 0)) SWIG_fail; { try { result = (b2TOIOutput *)new b2TOIOutput(); } 2023-09-08T22:04:02,126 | ^~ 2023-09-08T22:04:02,126 Box2D/Box2D_wrap.cpp:12655:78: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,127 12655 | if (!SWIG_Python_UnpackTuple(args, "new_b2TOIOutput", 0, 0, 0)) SWIG_fail; { try { result = (b2TOIOutput *)new b2TOIOutput(); } 2023-09-08T22:04:02,127 | ^ 2023-09-08T22:04:02,128 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2BodyDef(PyObject*, PyObject*)’: 2023-09-08T22:04:02,129 Box2D/Box2D_wrap.cpp:12678:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,129 12678 | if (!SWIG_Python_UnpackTuple(args, "new_b2BodyDef", 0, 0, 0)) SWIG_fail; { try { result = (b2BodyDef *)new b2BodyDef(); } 2023-09-08T22:04:02,130 | ^~ 2023-09-08T22:04:02,131 Box2D/Box2D_wrap.cpp:12678:76: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,132 12678 | if (!SWIG_Python_UnpackTuple(args, "new_b2BodyDef", 0, 0, 0)) SWIG_fail; { try { result = (b2BodyDef *)new b2BodyDef(); } 2023-09-08T22:04:02,132 | ^ 2023-09-08T22:04:02,133 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_type_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,134 Box2D/Box2D_wrap.cpp:12693:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,135 12693 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,135 | ^~ 2023-09-08T22:04:02,136 Box2D/Box2D_wrap.cpp:12693:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,137 12693 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,137 | ^~~~~~~~ 2023-09-08T22:04:02,138 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_position_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,139 Box2D/Box2D_wrap.cpp:12716:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,140 12716 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,140 | ^~ 2023-09-08T22:04:02,141 Box2D/Box2D_wrap.cpp:12716:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,142 12716 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,142 | ^~~~~~~~ 2023-09-08T22:04:02,143 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angle_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,143 Box2D/Box2D_wrap.cpp:12732:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,144 12732 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,145 | ^~ 2023-09-08T22:04:02,145 Box2D/Box2D_wrap.cpp:12732:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,146 12732 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,146 | ^~~~~~~~ 2023-09-08T22:04:02,147 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_linearVelocity_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,147 Box2D/Box2D_wrap.cpp:12755:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,148 12755 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,149 | ^~ 2023-09-08T22:04:02,149 Box2D/Box2D_wrap.cpp:12755:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,150 12755 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,151 | ^~~~~~~~ 2023-09-08T22:04:02,151 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angularVelocity_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,152 Box2D/Box2D_wrap.cpp:12771:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,153 12771 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,153 | ^~ 2023-09-08T22:04:02,154 Box2D/Box2D_wrap.cpp:12771:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,155 12771 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,155 | ^~~~~~~~ 2023-09-08T22:04:02,156 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_linearDamping_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,157 Box2D/Box2D_wrap.cpp:12787:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,157 12787 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,158 | ^~ 2023-09-08T22:04:02,159 Box2D/Box2D_wrap.cpp:12787:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,159 12787 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,160 | ^~~~~~~~ 2023-09-08T22:04:02,161 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angularDamping_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,161 Box2D/Box2D_wrap.cpp:12803:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,162 12803 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,163 | ^~ 2023-09-08T22:04:02,164 Box2D/Box2D_wrap.cpp:12803:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,164 12803 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,165 | ^~~~~~~~ 2023-09-08T22:04:02,166 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_allowSleep_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,166 Box2D/Box2D_wrap.cpp:12819:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,167 12819 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,167 | ^~ 2023-09-08T22:04:02,168 Box2D/Box2D_wrap.cpp:12819:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,168 12819 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,169 | ^~~~~~~~ 2023-09-08T22:04:02,170 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_awake_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,170 Box2D/Box2D_wrap.cpp:12835:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,171 12835 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,171 | ^~ 2023-09-08T22:04:02,172 Box2D/Box2D_wrap.cpp:12835:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,172 12835 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,173 | ^~~~~~~~ 2023-09-08T22:04:02,174 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_fixedRotation_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,174 Box2D/Box2D_wrap.cpp:12851:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,175 12851 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,176 | ^~ 2023-09-08T22:04:02,177 Box2D/Box2D_wrap.cpp:12851:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,177 12851 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,178 | ^~~~~~~~ 2023-09-08T22:04:02,179 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_bullet_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,180 Box2D/Box2D_wrap.cpp:12867:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,180 12867 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,181 | ^~ 2023-09-08T22:04:02,182 Box2D/Box2D_wrap.cpp:12867:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,182 12867 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,183 | ^~~~~~~~ 2023-09-08T22:04:02,184 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_active_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,184 Box2D/Box2D_wrap.cpp:12883:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,185 12883 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,186 | ^~ 2023-09-08T22:04:02,187 Box2D/Box2D_wrap.cpp:12883:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,187 12883 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,188 | ^~~~~~~~ 2023-09-08T22:04:02,188 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_gravityScale_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,189 Box2D/Box2D_wrap.cpp:12899:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,190 12899 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,190 | ^~ 2023-09-08T22:04:02,191 Box2D/Box2D_wrap.cpp:12899:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,191 12899 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,192 | ^~~~~~~~ 2023-09-08T22:04:02,192 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,193 Box2D/Box2D_wrap.cpp:12906:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,193 12906 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,194 | ^~ 2023-09-08T22:04:02,195 Box2D/Box2D_wrap.cpp:12906:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,195 12906 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,196 | ^~~~~~~~ 2023-09-08T22:04:02,196 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef___GetUserData(PyObject*, PyObject*)’: 2023-09-08T22:04:02,197 Box2D/Box2D_wrap.cpp:12914:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,198 12914 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,199 | ^~ 2023-09-08T22:04:02,199 Box2D/Box2D_wrap.cpp:12914:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,200 12914 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-08T22:04:02,201 | ^~~~~~~~ 2023-09-08T22:04:02,201 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___CreateFixture__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,202 Box2D/Box2D_wrap.cpp:12956:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,203 12956 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,203 | ^~ 2023-09-08T22:04:02,204 Box2D/Box2D_wrap.cpp:12956:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,205 12956 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,205 | ^~~~ 2023-09-08T22:04:02,206 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetTransform(PyObject*, PyObject*)’: 2023-09-08T22:04:02,207 Box2D/Box2D_wrap.cpp:12989:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,208 12989 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,209 | ^~ 2023-09-08T22:04:02,209 Box2D/Box2D_wrap.cpp:12989:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,210 12989 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,210 | ^~~~~~~~ 2023-09-08T22:04:02,211 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetPosition(PyObject*, PyObject*)’: 2023-09-08T22:04:02,212 Box2D/Box2D_wrap.cpp:12998:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,212 12998 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,213 | ^~ 2023-09-08T22:04:02,213 Box2D/Box2D_wrap.cpp:12998:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,214 12998 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,214 | ^~~~~~~~ 2023-09-08T22:04:02,215 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorldCenter(PyObject*, PyObject*)’: 2023-09-08T22:04:02,216 Box2D/Box2D_wrap.cpp:13013:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,216 13013 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,217 | ^~ 2023-09-08T22:04:02,217 Box2D/Box2D_wrap.cpp:13013:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,218 13013 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,219 | ^~~~~~~~ 2023-09-08T22:04:02,219 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetLocalCenter(PyObject*, PyObject*)’: 2023-09-08T22:04:02,220 Box2D/Box2D_wrap.cpp:13021:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,221 13021 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,222 | ^~ 2023-09-08T22:04:02,222 Box2D/Box2D_wrap.cpp:13021:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,223 13021 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,224 | ^~~~~~~~ 2023-09-08T22:04:02,224 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetLinearVelocity(PyObject*, PyObject*)’: 2023-09-08T22:04:02,225 Box2D/Box2D_wrap.cpp:13046:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,226 13046 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,226 | ^~ 2023-09-08T22:04:02,227 Box2D/Box2D_wrap.cpp:13046:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,228 13046 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,229 | ^~~~~~~~ 2023-09-08T22:04:02,282 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetType(PyObject*, PyObject*)’: 2023-09-08T22:04:02,283 Box2D/Box2D_wrap.cpp:13399:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,284 13399 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,284 | ^~ 2023-09-08T22:04:02,285 Box2D/Box2D_wrap.cpp:13399:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,285 13399 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,286 | ^~~~~~~~ 2023-09-08T22:04:02,301 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,301 Box2D/Box2D_wrap.cpp:13492:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,302 13492 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,303 | ^~ 2023-09-08T22:04:02,303 Box2D/Box2D_wrap.cpp:13492:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,304 13492 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,304 | ^~~~ 2023-09-08T22:04:02,305 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,306 Box2D/Box2D_wrap.cpp:13500:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,307 13500 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,307 | ^~ 2023-09-08T22:04:02,308 Box2D/Box2D_wrap.cpp:13500:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,308 13500 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,309 | ^~~~ 2023-09-08T22:04:02,310 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal(PyObject*, PyObject*)’: 2023-09-08T22:04:02,310 Box2D/Box2D_wrap.cpp:13508:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,311 13508 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetFixtureList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,311 | ^~ 2023-09-08T22:04:02,312 Box2D/Box2D_wrap.cpp:13508:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,313 13508 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetFixtureList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,313 | ^~ 2023-09-08T22:04:02,314 Box2D/Box2D_wrap.cpp:13510:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,315 13510 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,315 | ^~ 2023-09-08T22:04:02,316 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,317 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,317 | ^~~~ 2023-09-08T22:04:02,318 Box2D/Box2D_wrap.cpp:13510:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,319 13510 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,320 | ^~~~~~~~~ 2023-09-08T22:04:02,320 Box2D/Box2D_wrap.cpp:13512:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,320 13512 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,321 | ^~ 2023-09-08T22:04:02,321 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,322 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,322 | ^~~~ 2023-09-08T22:04:02,323 Box2D/Box2D_wrap.cpp:13512:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,323 13512 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,324 | ^~~~~~~~~ 2023-09-08T22:04:02,324 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,325 Box2D/Box2D_wrap.cpp:13517:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,325 13517 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,326 | ^~ 2023-09-08T22:04:02,326 Box2D/Box2D_wrap.cpp:13517:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,327 13517 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,328 | ^~~~ 2023-09-08T22:04:02,328 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,329 Box2D/Box2D_wrap.cpp:13526:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,329 13526 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,330 | ^~ 2023-09-08T22:04:02,331 Box2D/Box2D_wrap.cpp:13526:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,332 13526 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,332 | ^~~~ 2023-09-08T22:04:02,333 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal(PyObject*, PyObject*)’: 2023-09-08T22:04:02,333 Box2D/Box2D_wrap.cpp:13535:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,334 13535 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,335 | ^~ 2023-09-08T22:04:02,335 Box2D/Box2D_wrap.cpp:13535:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,336 13535 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,336 | ^~ 2023-09-08T22:04:02,337 Box2D/Box2D_wrap.cpp:13537:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,338 13537 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,338 | ^~ 2023-09-08T22:04:02,339 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,339 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,340 | ^~~~ 2023-09-08T22:04:02,340 Box2D/Box2D_wrap.cpp:13537:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,341 13537 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,341 | ^~~~~~~~~ 2023-09-08T22:04:02,342 Box2D/Box2D_wrap.cpp:13539:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,342 13539 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,343 | ^~ 2023-09-08T22:04:02,344 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,344 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,344 | ^~~~ 2023-09-08T22:04:02,345 Box2D/Box2D_wrap.cpp:13539:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,345 13539 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,346 | ^~~~~~~~~ 2023-09-08T22:04:02,346 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetContactList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,347 Box2D/Box2D_wrap.cpp:13544:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,347 13544 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,348 | ^~ 2023-09-08T22:04:02,349 Box2D/Box2D_wrap.cpp:13544:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,349 13544 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,350 | ^~~~ 2023-09-08T22:04:02,351 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetContactList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,352 Box2D/Box2D_wrap.cpp:13553:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,352 13553 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,353 | ^~ 2023-09-08T22:04:02,354 Box2D/Box2D_wrap.cpp:13553:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,354 13553 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,355 | ^~~~ 2023-09-08T22:04:02,355 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetContactList_internal(PyObject*, PyObject*)’: 2023-09-08T22:04:02,356 Box2D/Box2D_wrap.cpp:13562:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,357 13562 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,357 | ^~ 2023-09-08T22:04:02,358 Box2D/Box2D_wrap.cpp:13562:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,358 13562 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,359 | ^~ 2023-09-08T22:04:02,359 Box2D/Box2D_wrap.cpp:13564:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,360 13564 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,360 | ^~ 2023-09-08T22:04:02,361 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,361 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,362 | ^~~~ 2023-09-08T22:04:02,363 Box2D/Box2D_wrap.cpp:13564:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,363 13564 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,364 | ^~~~~~~~~ 2023-09-08T22:04:02,364 Box2D/Box2D_wrap.cpp:13566:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,365 13566 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,365 | ^~ 2023-09-08T22:04:02,366 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,367 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,367 | ^~~~ 2023-09-08T22:04:02,368 Box2D/Box2D_wrap.cpp:13566:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,369 13566 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,369 | ^~~~~~~~~ 2023-09-08T22:04:02,370 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,371 Box2D/Box2D_wrap.cpp:13571:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,371 13571 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,372 | ^~ 2023-09-08T22:04:02,372 Box2D/Box2D_wrap.cpp:13571:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,373 13571 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,374 | ^~~~ 2023-09-08T22:04:02,374 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,375 Box2D/Box2D_wrap.cpp:13579:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,375 13579 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,376 | ^~ 2023-09-08T22:04:02,377 Box2D/Box2D_wrap.cpp:13579:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,377 13579 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,378 | ^~~~ 2023-09-08T22:04:02,379 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext(PyObject*, PyObject*)’: 2023-09-08T22:04:02,379 Box2D/Box2D_wrap.cpp:13586:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,380 13586 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,381 | ^~ 2023-09-08T22:04:02,381 Box2D/Box2D_wrap.cpp:13586:91: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,382 13586 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,382 | ^~ 2023-09-08T22:04:02,383 Box2D/Box2D_wrap.cpp:13588:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,383 13588 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,384 | ^~ 2023-09-08T22:04:02,384 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,385 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,386 | ^~~~ 2023-09-08T22:04:02,386 Box2D/Box2D_wrap.cpp:13588:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,387 13588 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,387 | ^~~~~~~~~ 2023-09-08T22:04:02,388 Box2D/Box2D_wrap.cpp:13590:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,389 13590 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,390 | ^~ 2023-09-08T22:04:02,390 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,391 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,392 | ^~~~ 2023-09-08T22:04:02,393 Box2D/Box2D_wrap.cpp:13590:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,393 13590 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,394 | ^~~~~~~~~ 2023-09-08T22:04:02,395 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,395 Box2D/Box2D_wrap.cpp:13595:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,396 13595 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,397 | ^~ 2023-09-08T22:04:02,397 Box2D/Box2D_wrap.cpp:13595:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,398 13595 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,399 | ^~~~ 2023-09-08T22:04:02,399 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,400 Box2D/Box2D_wrap.cpp:13603:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,401 13603 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,402 | ^~ 2023-09-08T22:04:02,402 Box2D/Box2D_wrap.cpp:13603:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,403 13603 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,404 | ^~~~ 2023-09-08T22:04:02,404 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld(PyObject*, PyObject*)’: 2023-09-08T22:04:02,405 Box2D/Box2D_wrap.cpp:13610:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,405 13610 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetWorld", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,406 | ^~ 2023-09-08T22:04:02,406 Box2D/Box2D_wrap.cpp:13610:92: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,407 13610 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetWorld", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,408 | ^~ 2023-09-08T22:04:02,408 Box2D/Box2D_wrap.cpp:13612:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,409 13612 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,409 | ^~ 2023-09-08T22:04:02,410 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,410 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,411 | ^~~~ 2023-09-08T22:04:02,411 Box2D/Box2D_wrap.cpp:13612:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,412 13612 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,413 | ^~~~~~~~~ 2023-09-08T22:04:02,413 Box2D/Box2D_wrap.cpp:13614:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,414 13614 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,415 | ^~ 2023-09-08T22:04:02,415 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,416 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,417 | ^~~~ 2023-09-08T22:04:02,417 Box2D/Box2D_wrap.cpp:13614:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,418 13614 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,419 | ^~~~~~~~~ 2023-09-08T22:04:02,419 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___CreateFixture(PyObject*, PyObject*)’: 2023-09-08T22:04:02,420 Box2D/Box2D_wrap.cpp:13653:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,420 13653 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___CreateFixture", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:02,421 | ^~ 2023-09-08T22:04:02,422 Box2D/Box2D_wrap.cpp:13653:97: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,422 13653 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___CreateFixture", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-08T22:04:02,423 | ^~ 2023-09-08T22:04:02,424 Box2D/Box2D_wrap.cpp:13655:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,425 13655 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:02,425 | ^~ 2023-09-08T22:04:02,426 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,426 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,427 | ^~~~ 2023-09-08T22:04:02,427 Box2D/Box2D_wrap.cpp:13655:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,428 13655 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-08T22:04:02,428 | ^~~~~~~~~ 2023-09-08T22:04:02,429 Box2D/Box2D_wrap.cpp:13657:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,429 13657 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,430 | ^~ 2023-09-08T22:04:02,430 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,431 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,431 | ^~~~ 2023-09-08T22:04:02,432 Box2D/Box2D_wrap.cpp:13657:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,432 13657 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,433 | ^~~~~~~~~ 2023-09-08T22:04:02,434 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetUserData(PyObject*, PyObject*)’: 2023-09-08T22:04:02,435 Box2D/Box2D_wrap.cpp:13663:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,435 13663 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,436 | ^~ 2023-09-08T22:04:02,436 Box2D/Box2D_wrap.cpp:13663:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,437 13663 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-08T22:04:02,438 | ^~~~~~~~ 2023-09-08T22:04:02,438 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Filter(PyObject*, PyObject*)’: 2023-09-08T22:04:02,439 Box2D/Box2D_wrap.cpp:13692:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,440 13692 | if (!SWIG_Python_UnpackTuple(args, "new_b2Filter", 0, 0, 0)) SWIG_fail; { try { result = (b2Filter *)new b2Filter(); } 2023-09-08T22:04:02,440 | ^~ 2023-09-08T22:04:02,441 Box2D/Box2D_wrap.cpp:13692:75: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,442 13692 | if (!SWIG_Python_UnpackTuple(args, "new_b2Filter", 0, 0, 0)) SWIG_fail; { try { result = (b2Filter *)new b2Filter(); } 2023-09-08T22:04:02,442 | ^ 2023-09-08T22:04:02,443 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Filter_categoryBits_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,443 Box2D/Box2D_wrap.cpp:13708:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,444 13708 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2023-09-08T22:04:02,445 | ^~ 2023-09-08T22:04:02,446 Box2D/Box2D_wrap.cpp:13708:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,446 13708 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2023-09-08T22:04:02,447 | ^~~~~~~~ 2023-09-08T22:04:02,447 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Filter_maskBits_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,448 Box2D/Box2D_wrap.cpp:13725:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,448 13725 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2023-09-08T22:04:02,449 | ^~ 2023-09-08T22:04:02,450 Box2D/Box2D_wrap.cpp:13725:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,450 13725 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2023-09-08T22:04:02,451 | ^~~~~~~~ 2023-09-08T22:04:02,452 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_shape_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,452 Box2D/Box2D_wrap.cpp:13788:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,453 13788 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,454 | ^~ 2023-09-08T22:04:02,454 Box2D/Box2D_wrap.cpp:13788:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,455 13788 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,455 | ^~~~~~~~ 2023-09-08T22:04:02,456 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_friction_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,456 Box2D/Box2D_wrap.cpp:13810:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,457 13810 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,458 | ^~ 2023-09-08T22:04:02,458 Box2D/Box2D_wrap.cpp:13810:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,459 13810 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,460 | ^~~~~~~~ 2023-09-08T22:04:02,460 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_restitution_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,461 Box2D/Box2D_wrap.cpp:13826:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,462 13826 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,462 | ^~ 2023-09-08T22:04:02,463 Box2D/Box2D_wrap.cpp:13826:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,464 13826 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,464 | ^~~~~~~~ 2023-09-08T22:04:02,465 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_density_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,466 Box2D/Box2D_wrap.cpp:13842:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,466 13842 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,467 | ^~ 2023-09-08T22:04:02,468 Box2D/Box2D_wrap.cpp:13842:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,469 13842 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,469 | ^~~~~~~~ 2023-09-08T22:04:02,470 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_isSensor_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,470 Box2D/Box2D_wrap.cpp:13858:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,471 13858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,471 | ^~ 2023-09-08T22:04:02,472 Box2D/Box2D_wrap.cpp:13858:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,472 13858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,473 | ^~~~~~~~ 2023-09-08T22:04:02,474 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_filter_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,474 Box2D/Box2D_wrap.cpp:13876:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,475 13876 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,475 | ^~ 2023-09-08T22:04:02,476 Box2D/Box2D_wrap.cpp:13876:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,476 13876 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,477 | ^~~~~~~~ 2023-09-08T22:04:02,478 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,478 Box2D/Box2D_wrap.cpp:13883:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,479 13883 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,479 | ^~ 2023-09-08T22:04:02,480 Box2D/Box2D_wrap.cpp:13883:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,480 13883 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,481 | ^~~~~~~~ 2023-09-08T22:04:02,482 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef___GetUserData(PyObject*, PyObject*)’: 2023-09-08T22:04:02,483 Box2D/Box2D_wrap.cpp:13891:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,483 13891 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,484 | ^~ 2023-09-08T22:04:02,484 Box2D/Box2D_wrap.cpp:13891:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,485 13891 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-08T22:04:02,486 | ^~~~~~~~ 2023-09-08T22:04:02,487 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy_aabb_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,487 Box2D/Box2D_wrap.cpp:13943:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,488 13943 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,489 | ^~ 2023-09-08T22:04:02,490 Box2D/Box2D_wrap.cpp:13943:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,490 13943 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,490 | ^~~~~~~~ 2023-09-08T22:04:02,491 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy_fixture_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,491 Box2D/Box2D_wrap.cpp:13961:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,492 13961 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,492 | ^~ 2023-09-08T22:04:02,493 Box2D/Box2D_wrap.cpp:13961:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,494 13961 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,494 | ^~~~~~~~ 2023-09-08T22:04:02,495 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy_childIndex_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,495 Box2D/Box2D_wrap.cpp:13977:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,496 13977 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,496 | ^~ 2023-09-08T22:04:02,497 Box2D/Box2D_wrap.cpp:13977:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,497 13977 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,498 | ^~~~~~~~ 2023-09-08T22:04:02,499 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy_proxyId_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,499 Box2D/Box2D_wrap.cpp:13993:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,500 13993 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,501 | ^~ 2023-09-08T22:04:02,501 Box2D/Box2D_wrap.cpp:13993:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,502 13993 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,502 | ^~~~~~~~ 2023-09-08T22:04:02,503 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,503 Box2D/Box2D_wrap.cpp:14000:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,504 14000 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,505 | ^~ 2023-09-08T22:04:02,505 Box2D/Box2D_wrap.cpp:14000:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,506 14000 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-08T22:04:02,507 | ^~~~~~~~ 2023-09-08T22:04:02,507 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetType(PyObject*, PyObject*)’: 2023-09-08T22:04:02,508 Box2D/Box2D_wrap.cpp:14032:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,509 14032 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,510 | ^~ 2023-09-08T22:04:02,510 Box2D/Box2D_wrap.cpp:14032:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,511 14032 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,511 | ^~~~~~~~ 2023-09-08T22:04:02,511 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetShape__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,512 Box2D/Box2D_wrap.cpp:14040:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,513 14040 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,513 | ^~ 2023-09-08T22:04:02,514 Box2D/Box2D_wrap.cpp:14040:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,514 14040 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,515 | ^~~~ 2023-09-08T22:04:02,515 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetShape__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,516 Box2D/Box2D_wrap.cpp:14053:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,516 14053 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,517 | ^~ 2023-09-08T22:04:02,517 Box2D/Box2D_wrap.cpp:14053:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,518 14053 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,519 | ^~~~ 2023-09-08T22:04:02,519 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetShape(PyObject*, PyObject*)’: 2023-09-08T22:04:02,520 Box2D/Box2D_wrap.cpp:14066:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,521 14066 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetShape", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,521 | ^~ 2023-09-08T22:04:02,522 Box2D/Box2D_wrap.cpp:14066:95: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,523 14066 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetShape", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,523 | ^~ 2023-09-08T22:04:02,524 Box2D/Box2D_wrap.cpp:14068:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,524 14068 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,525 | ^~ 2023-09-08T22:04:02,526 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,527 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,527 | ^~~~ 2023-09-08T22:04:02,528 Box2D/Box2D_wrap.cpp:14068:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,529 14068 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,530 | ^~~~~~~~~ 2023-09-08T22:04:02,530 Box2D/Box2D_wrap.cpp:14070:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,531 14070 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,531 | ^~ 2023-09-08T22:04:02,532 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,532 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,533 | ^~~~ 2023-09-08T22:04:02,533 Box2D/Box2D_wrap.cpp:14070:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,534 14070 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,534 | ^~~~~~~~~ 2023-09-08T22:04:02,535 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___IsSensor(PyObject*, PyObject*)’: 2023-09-08T22:04:02,535 Box2D/Box2D_wrap.cpp:14085:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,536 14085 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,537 | ^~ 2023-09-08T22:04:02,537 Box2D/Box2D_wrap.cpp:14085:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,538 14085 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,538 | ^~~~~~~~ 2023-09-08T22:04:02,539 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetFilterData(PyObject*, PyObject*)’: 2023-09-08T22:04:02,540 Box2D/Box2D_wrap.cpp:14108:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,540 14108 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,541 | ^~ 2023-09-08T22:04:02,542 Box2D/Box2D_wrap.cpp:14108:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,542 14108 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,543 | ^~~~~~~~ 2023-09-08T22:04:02,544 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,544 Box2D/Box2D_wrap.cpp:14122:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,545 14122 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,546 | ^~ 2023-09-08T22:04:02,546 Box2D/Box2D_wrap.cpp:14122:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,547 14122 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,548 | ^~~~ 2023-09-08T22:04:02,548 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,549 Box2D/Box2D_wrap.cpp:14130:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,550 14130 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,550 | ^~ 2023-09-08T22:04:02,552 Box2D/Box2D_wrap.cpp:14130:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,552 14130 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,553 | ^~~~ 2023-09-08T22:04:02,553 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody(PyObject*, PyObject*)’: 2023-09-08T22:04:02,554 Box2D/Box2D_wrap.cpp:14137:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,554 14137 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetBody", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,555 | ^~ 2023-09-08T22:04:02,555 Box2D/Box2D_wrap.cpp:14137:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,556 14137 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetBody", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,557 | ^~ 2023-09-08T22:04:02,557 Box2D/Box2D_wrap.cpp:14139:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,558 14139 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,558 | ^~ 2023-09-08T22:04:02,559 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,560 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,560 | ^~~~ 2023-09-08T22:04:02,561 Box2D/Box2D_wrap.cpp:14139:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,562 14139 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,562 | ^~~~~~~~~ 2023-09-08T22:04:02,563 Box2D/Box2D_wrap.cpp:14141:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,564 14141 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,565 | ^~ 2023-09-08T22:04:02,565 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,566 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,567 | ^~~~ 2023-09-08T22:04:02,568 Box2D/Box2D_wrap.cpp:14141:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,568 14141 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,569 | ^~~~~~~~~ 2023-09-08T22:04:02,569 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,570 Box2D/Box2D_wrap.cpp:14146:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,571 14146 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,571 | ^~ 2023-09-08T22:04:02,572 Box2D/Box2D_wrap.cpp:14146:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,572 14146 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,573 | ^~~~ 2023-09-08T22:04:02,574 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,575 Box2D/Box2D_wrap.cpp:14154:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,575 14154 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,576 | ^~ 2023-09-08T22:04:02,576 Box2D/Box2D_wrap.cpp:14154:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,577 14154 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,577 | ^~~~ 2023-09-08T22:04:02,578 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetNext(PyObject*, PyObject*)’: 2023-09-08T22:04:02,578 Box2D/Box2D_wrap.cpp:14161:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,579 14161 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,580 | ^~ 2023-09-08T22:04:02,580 Box2D/Box2D_wrap.cpp:14161:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,581 14161 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,581 | ^~ 2023-09-08T22:04:02,582 Box2D/Box2D_wrap.cpp:14163:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,582 14163 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,583 | ^~ 2023-09-08T22:04:02,584 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,584 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,585 | ^~~~ 2023-09-08T22:04:02,586 Box2D/Box2D_wrap.cpp:14163:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,586 14163 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,587 | ^~~~~~~~~ 2023-09-08T22:04:02,588 Box2D/Box2D_wrap.cpp:14165:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,588 14165 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,589 | ^~ 2023-09-08T22:04:02,590 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,590 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,591 | ^~~~ 2023-09-08T22:04:02,591 Box2D/Box2D_wrap.cpp:14165:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,592 14165 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,593 | ^~~~~~~~~ 2023-09-08T22:04:02,593 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetDensity(PyObject*, PyObject*)’: 2023-09-08T22:04:02,594 Box2D/Box2D_wrap.cpp:14232:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,595 14232 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,596 | ^~ 2023-09-08T22:04:02,596 Box2D/Box2D_wrap.cpp:14232:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,597 14232 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,597 | ^~~~~~~~ 2023-09-08T22:04:02,598 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetFriction(PyObject*, PyObject*)’: 2023-09-08T22:04:02,598 Box2D/Box2D_wrap.cpp:14240:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,599 14240 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,599 | ^~ 2023-09-08T22:04:02,600 Box2D/Box2D_wrap.cpp:14240:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,600 14240 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,601 | ^~~~~~~~ 2023-09-08T22:04:02,601 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetRestitution(PyObject*, PyObject*)’: 2023-09-08T22:04:02,602 Box2D/Box2D_wrap.cpp:14258:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,603 14258 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,603 | ^~ 2023-09-08T22:04:02,604 Box2D/Box2D_wrap.cpp:14258:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,604 14258 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,605 | ^~~~~~~~ 2023-09-08T22:04:02,606 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,606 Box2D/Box2D_wrap.cpp:14298:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,607 14298 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,607 | ^~ 2023-09-08T22:04:02,608 Box2D/Box2D_wrap.cpp:14298:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,609 14298 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,610 | ^~~~~~~~ 2023-09-08T22:04:02,610 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetUserData(PyObject*, PyObject*)’: 2023-09-08T22:04:02,611 Box2D/Box2D_wrap.cpp:14306:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,612 14306 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,613 | ^~ 2023-09-08T22:04:02,613 Box2D/Box2D_wrap.cpp:14306:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,614 14306 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-08T22:04:02,615 | ^~~~~~~~ 2023-09-08T22:04:02,616 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DestructionListener(PyObject*, PyObject*)’: 2023-09-08T22:04:02,617 Box2D/Box2D_wrap.cpp:14343:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,618 14343 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,619 | ^~ 2023-09-08T22:04:02,619 Box2D/Box2D_wrap.cpp:14343:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,620 14343 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,621 | ^~~~~~~~ 2023-09-08T22:04:02,621 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DestructionListener_SayGoodbye(PyObject*, PyObject*)’: 2023-09-08T22:04:02,622 Box2D/Box2D_wrap.cpp:14379:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,622 14379 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2DestructionListener_SayGoodbye", 0, 2, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,623 | ^~ 2023-09-08T22:04:02,623 Box2D/Box2D_wrap.cpp:14379:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,624 14379 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2DestructionListener_SayGoodbye", 0, 2, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,624 | ^~ 2023-09-08T22:04:02,625 Box2D/Box2D_wrap.cpp:14384:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,626 14384 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,626 | ^~ 2023-09-08T22:04:02,627 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,627 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,628 | ^~~~ 2023-09-08T22:04:02,629 Box2D/Box2D_wrap.cpp:14384:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,629 14384 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,630 | ^~~~~~~~~ 2023-09-08T22:04:02,631 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2DestructionListener(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,631 Box2D/Box2D_wrap.cpp:14399:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,632 14399 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DestructionListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,632 | ^~ 2023-09-08T22:04:02,633 Box2D/Box2D_wrap.cpp:14399:109: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,634 14399 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DestructionListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,635 | ^~~~ 2023-09-08T22:04:02,635 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFilter___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,636 Box2D/Box2D_wrap.cpp:14454:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,636 14454 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFilter, 0 | 0 ); 2023-09-08T22:04:02,637 | ^~ 2023-09-08T22:04:02,638 Box2D/Box2D_wrap.cpp:14454:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,639 14454 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFilter, 0 | 0 ); 2023-09-08T22:04:02,639 | ^~~~~~~~ 2023-09-08T22:04:02,640 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2ContactFilter(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,641 Box2D/Box2D_wrap.cpp:14463:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,641 14463 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactFilter", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,642 | ^~ 2023-09-08T22:04:02,642 Box2D/Box2D_wrap.cpp:14463:103: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,643 14463 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactFilter", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,643 | ^~~~ 2023-09-08T22:04:02,644 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactImpulse_count_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,644 Box2D/Box2D_wrap.cpp:14499:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,645 14499 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactImpulse, 0 | 0 ); 2023-09-08T22:04:02,646 | ^~ 2023-09-08T22:04:02,646 Box2D/Box2D_wrap.cpp:14499:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,647 14499 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactImpulse, 0 | 0 ); 2023-09-08T22:04:02,647 | ^~~~~~~~ 2023-09-08T22:04:02,648 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactImpulse___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,649 Box2D/Box2D_wrap.cpp:14506:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,650 14506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactImpulse, 0 | 0 ); 2023-09-08T22:04:02,650 | ^~ 2023-09-08T22:04:02,651 Box2D/Box2D_wrap.cpp:14506:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,652 14506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactImpulse, 0 | 0 ); 2023-09-08T22:04:02,652 | ^~~~~~~~ 2023-09-08T22:04:02,653 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactImpulse(PyObject*, PyObject*)’: 2023-09-08T22:04:02,654 Box2D/Box2D_wrap.cpp:14536:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,655 14536 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,655 | ^~ 2023-09-08T22:04:02,656 Box2D/Box2D_wrap.cpp:14536:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,657 14536 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,657 | ^~~~~~~~ 2023-09-08T22:04:02,658 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactListener(PyObject*, PyObject*)’: 2023-09-08T22:04:02,659 Box2D/Box2D_wrap.cpp:14554:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,659 14554 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,660 | ^~ 2023-09-08T22:04:02,661 Box2D/Box2D_wrap.cpp:14554:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,662 14554 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,662 | ^~~~~~~~ 2023-09-08T22:04:02,663 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactListener___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,664 Box2D/Box2D_wrap.cpp:14632:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,665 14632 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactListener, 0 | 0 ); 2023-09-08T22:04:02,665 | ^~ 2023-09-08T22:04:02,666 Box2D/Box2D_wrap.cpp:14632:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,667 14632 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactListener, 0 | 0 ); 2023-09-08T22:04:02,667 | ^~~~~~~~ 2023-09-08T22:04:02,668 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2ContactListener(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,668 Box2D/Box2D_wrap.cpp:14641:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,669 14641 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,669 | ^~ 2023-09-08T22:04:02,670 Box2D/Box2D_wrap.cpp:14641:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,670 14641 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,671 | ^~~~ 2023-09-08T22:04:02,672 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2QueryCallback___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,672 Box2D/Box2D_wrap.cpp:14691:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,673 14691 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2QueryCallback, 0 | 0 ); 2023-09-08T22:04:02,673 | ^~ 2023-09-08T22:04:02,674 Box2D/Box2D_wrap.cpp:14691:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,675 14691 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2QueryCallback, 0 | 0 ); 2023-09-08T22:04:02,675 | ^~~~~~~~ 2023-09-08T22:04:02,676 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2QueryCallback(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,677 Box2D/Box2D_wrap.cpp:14700:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,677 14700 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2QueryCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,678 | ^~ 2023-09-08T22:04:02,679 Box2D/Box2D_wrap.cpp:14700:103: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,679 14700 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2QueryCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,680 | ^~~~ 2023-09-08T22:04:02,681 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RayCastCallback(PyObject*, PyObject*)’: 2023-09-08T22:04:02,681 Box2D/Box2D_wrap.cpp:14727:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,682 14727 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,683 | ^~ 2023-09-08T22:04:02,683 Box2D/Box2D_wrap.cpp:14727:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,684 14727 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,685 | ^~~~~~~~ 2023-09-08T22:04:02,686 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastCallback___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,686 Box2D/Box2D_wrap.cpp:14772:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,687 14772 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastCallback, 0 | 0 ); 2023-09-08T22:04:02,687 | ^~ 2023-09-08T22:04:02,688 Box2D/Box2D_wrap.cpp:14772:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,688 14772 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastCallback, 0 | 0 ); 2023-09-08T22:04:02,689 | ^~~~~~~~ 2023-09-08T22:04:02,689 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2RayCastCallback(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,690 Box2D/Box2D_wrap.cpp:14781:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,691 14781 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2RayCastCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,691 | ^~ 2023-09-08T22:04:02,692 Box2D/Box2D_wrap.cpp:14781:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,692 14781 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2RayCastCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-08T22:04:02,693 | ^~~~ 2023-09-08T22:04:02,694 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_step_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,694 Box2D/Box2D_wrap.cpp:14817:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,695 14817 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,696 | ^~ 2023-09-08T22:04:02,696 Box2D/Box2D_wrap.cpp:14817:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,697 14817 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,698 | ^~~~~~~~ 2023-09-08T22:04:02,698 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_collide_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,699 Box2D/Box2D_wrap.cpp:14833:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,700 14833 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,700 | ^~ 2023-09-08T22:04:02,701 Box2D/Box2D_wrap.cpp:14833:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,702 14833 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,702 | ^~~~~~~~ 2023-09-08T22:04:02,703 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solve_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,704 Box2D/Box2D_wrap.cpp:14849:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,704 14849 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,705 | ^~ 2023-09-08T22:04:02,705 Box2D/Box2D_wrap.cpp:14849:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,706 14849 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,707 | ^~~~~~~~ 2023-09-08T22:04:02,708 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveInit_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,708 Box2D/Box2D_wrap.cpp:14865:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,709 14865 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,709 | ^~ 2023-09-08T22:04:02,710 Box2D/Box2D_wrap.cpp:14865:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,710 14865 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,711 | ^~~~~~~~ 2023-09-08T22:04:02,711 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveVelocity_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,712 Box2D/Box2D_wrap.cpp:14881:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,712 14881 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,713 | ^~ 2023-09-08T22:04:02,713 Box2D/Box2D_wrap.cpp:14881:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,714 14881 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,715 | ^~~~~~~~ 2023-09-08T22:04:02,715 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solvePosition_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,716 Box2D/Box2D_wrap.cpp:14897:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,716 14897 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,717 | ^~ 2023-09-08T22:04:02,718 Box2D/Box2D_wrap.cpp:14897:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,719 14897 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,719 | ^~~~~~~~ 2023-09-08T22:04:02,720 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_broadphase_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,721 Box2D/Box2D_wrap.cpp:14913:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,721 14913 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,722 | ^~ 2023-09-08T22:04:02,723 Box2D/Box2D_wrap.cpp:14913:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,723 14913 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,724 | ^~~~~~~~ 2023-09-08T22:04:02,725 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveTOI_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,726 Box2D/Box2D_wrap.cpp:14929:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,726 14929 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,727 | ^~ 2023-09-08T22:04:02,728 Box2D/Box2D_wrap.cpp:14929:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,728 14929 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-08T22:04:02,729 | ^~~~~~~~ 2023-09-08T22:04:02,730 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Profile(PyObject*, PyObject*)’: 2023-09-08T22:04:02,730 Box2D/Box2D_wrap.cpp:14935:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,731 14935 | if (!SWIG_Python_UnpackTuple(args, "new_b2Profile", 0, 0, 0)) SWIG_fail; { try { result = (b2Profile *)new b2Profile(); } 2023-09-08T22:04:02,731 | ^~ 2023-09-08T22:04:02,732 Box2D/Box2D_wrap.cpp:14935:76: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,732 14935 | if (!SWIG_Python_UnpackTuple(args, "new_b2Profile", 0, 0, 0)) SWIG_fail; { try { result = (b2Profile *)new b2Profile(); } 2023-09-08T22:04:02,733 | ^ 2023-09-08T22:04:02,734 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2SolverData_step_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,734 Box2D/Box2D_wrap.cpp:14970:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,735 14970 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-08T22:04:02,735 | ^~ 2023-09-08T22:04:02,736 Box2D/Box2D_wrap.cpp:14970:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,737 14970 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-08T22:04:02,737 | ^~~~~~~~ 2023-09-08T22:04:02,738 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2SolverData_positions_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,739 Box2D/Box2D_wrap.cpp:14988:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,739 14988 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-08T22:04:02,740 | ^~ 2023-09-08T22:04:02,741 Box2D/Box2D_wrap.cpp:14988:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,741 14988 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-08T22:04:02,742 | ^~~~~~~~ 2023-09-08T22:04:02,743 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2SolverData_velocities_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,743 Box2D/Box2D_wrap.cpp:15006:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,744 15006 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-08T22:04:02,745 | ^~ 2023-09-08T22:04:02,745 Box2D/Box2D_wrap.cpp:15006:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,746 15006 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-08T22:04:02,747 | ^~~~~~~~ 2023-09-08T22:04:02,747 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager_FindNewContacts(PyObject*, PyObject*)’: 2023-09-08T22:04:02,748 Box2D/Box2D_wrap.cpp:15060:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,749 15060 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-08T22:04:02,749 | ^~ 2023-09-08T22:04:02,750 Box2D/Box2D_wrap.cpp:15060:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,751 15060 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-08T22:04:02,751 | ^~~~~~~~ 2023-09-08T22:04:02,752 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager_Collide(PyObject*, PyObject*)’: 2023-09-08T22:04:02,752 Box2D/Box2D_wrap.cpp:15079:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,753 15079 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-08T22:04:02,753 | ^~ 2023-09-08T22:04:02,754 Box2D/Box2D_wrap.cpp:15079:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,754 15079 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-08T22:04:02,755 | ^~~~~~~~ 2023-09-08T22:04:02,756 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager_contactCount_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,756 Box2D/Box2D_wrap.cpp:15132:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,757 15132 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-08T22:04:02,757 | ^~ 2023-09-08T22:04:02,758 Box2D/Box2D_wrap.cpp:15132:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,759 15132 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-08T22:04:02,759 | ^~~~~~~~ 2023-09-08T22:04:02,767 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,768 Box2D/Box2D_wrap.cpp:15198:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,768 15198 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-08T22:04:02,769 | ^~ 2023-09-08T22:04:02,770 Box2D/Box2D_wrap.cpp:15198:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,770 15198 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-08T22:04:02,771 | ^~~~~~~~ 2023-09-08T22:04:02,772 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactManager(PyObject*, PyObject*)’: 2023-09-08T22:04:02,772 Box2D/Box2D_wrap.cpp:15206:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,773 15206 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,774 | ^~ 2023-09-08T22:04:02,774 Box2D/Box2D_wrap.cpp:15206:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,775 15206 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:02,776 | ^~~~~~~~ 2023-09-08T22:04:02,789 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_Step(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,790 Box2D/Box2D_wrap.cpp:15308:92: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-08T22:04:02,791 15308 | arg4 = static_cast< int32 >(val4); { try { (arg1)->Step(arg2,arg3,arg4); } catch (Swig::DirectorException) { SWIG_fail; } 2023-09-08T22:04:02,791 | ^~~~~~~~~~~~~~~~~ 2023-09-08T22:04:02,793 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DrawDebugData(PyObject*, PyObject*)’: 2023-09-08T22:04:02,794 Box2D/Box2D_wrap.cpp:15320:98: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-08T22:04:02,794 15320 | arg1 = reinterpret_cast< b2World * >(argp1); { try { (arg1)->DrawDebugData(); } catch (Swig::DirectorException) { 2023-09-08T22:04:02,795 | ^~~~~~~~~~~~~~~~~ 2023-09-08T22:04:02,797 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_QueryAABB(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,797 Box2D/Box2D_wrap.cpp:15339:18: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-08T22:04:02,798 15339 | catch (Swig::DirectorException) { SWIG_fail; } catch (b2AssertException) { SWIG_fail; } } resultobj = SWIG_Py_Void(); 2023-09-08T22:04:02,798 | ^~~~~~~~~~~~~~~~~ 2023-09-08T22:04:02,803 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_RayCast(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,804 Box2D/Box2D_wrap.cpp:15369:107: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-08T22:04:02,804 15369 | ((b2World const *)arg1)->RayCast(arg2,(b2Vec2 const &)*arg3,(b2Vec2 const &)*arg4); } catch (Swig::DirectorException) { 2023-09-08T22:04:02,805 | ^~~~~~~~~~~~~~~~~ 2023-09-08T22:04:02,806 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,807 Box2D/Box2D_wrap.cpp:15374:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,807 15374 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,808 | ^~ 2023-09-08T22:04:02,809 Box2D/Box2D_wrap.cpp:15374:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,809 15374 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,810 | ^~~~ 2023-09-08T22:04:02,811 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,812 Box2D/Box2D_wrap.cpp:15382:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,812 15382 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,813 | ^~ 2023-09-08T22:04:02,813 Box2D/Box2D_wrap.cpp:15382:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,814 15382 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,815 | ^~~~ 2023-09-08T22:04:02,815 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal(PyObject*, PyObject*)’: 2023-09-08T22:04:02,816 Box2D/Box2D_wrap.cpp:15390:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,816 15390 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetBodyList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,817 | ^~ 2023-09-08T22:04:02,818 Box2D/Box2D_wrap.cpp:15390:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,818 15390 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetBodyList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,819 | ^~ 2023-09-08T22:04:02,819 Box2D/Box2D_wrap.cpp:15392:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,820 15392 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,820 | ^~ 2023-09-08T22:04:02,821 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,821 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,822 | ^~~~ 2023-09-08T22:04:02,822 Box2D/Box2D_wrap.cpp:15392:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,823 15392 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,824 | ^~~~~~~~~ 2023-09-08T22:04:02,824 Box2D/Box2D_wrap.cpp:15394:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,825 15394 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,825 | ^~ 2023-09-08T22:04:02,826 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,826 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,827 | ^~~~ 2023-09-08T22:04:02,828 Box2D/Box2D_wrap.cpp:15394:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,828 15394 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,829 | ^~~~~~~~~ 2023-09-08T22:04:02,829 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,830 Box2D/Box2D_wrap.cpp:15399:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,831 15399 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,831 | ^~ 2023-09-08T22:04:02,832 Box2D/Box2D_wrap.cpp:15399:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,833 15399 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,833 | ^~~~ 2023-09-08T22:04:02,834 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,835 Box2D/Box2D_wrap.cpp:15420:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,835 15420 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,836 | ^~ 2023-09-08T22:04:02,836 Box2D/Box2D_wrap.cpp:15420:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,837 15420 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,838 | ^~~~ 2023-09-08T22:04:02,839 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal(PyObject*, PyObject*)’: 2023-09-08T22:04:02,839 Box2D/Box2D_wrap.cpp:15441:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,840 15441 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,840 | ^~ 2023-09-08T22:04:02,841 Box2D/Box2D_wrap.cpp:15441:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,841 15441 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,842 | ^~ 2023-09-08T22:04:02,842 Box2D/Box2D_wrap.cpp:15443:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,843 15443 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,843 | ^~ 2023-09-08T22:04:02,844 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,844 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,845 | ^~~~ 2023-09-08T22:04:02,845 Box2D/Box2D_wrap.cpp:15443:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,846 15443 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,846 | ^~~~~~~~~ 2023-09-08T22:04:02,847 Box2D/Box2D_wrap.cpp:15445:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,848 15445 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,848 | ^~ 2023-09-08T22:04:02,849 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,849 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,850 | ^~~~ 2023-09-08T22:04:02,851 Box2D/Box2D_wrap.cpp:15445:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,852 15445 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,852 | ^~~~~~~~~ 2023-09-08T22:04:02,853 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,854 Box2D/Box2D_wrap.cpp:15450:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,855 15450 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,855 | ^~ 2023-09-08T22:04:02,856 Box2D/Box2D_wrap.cpp:15450:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,857 15450 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,857 | ^~~~ 2023-09-08T22:04:02,858 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,859 Box2D/Box2D_wrap.cpp:15458:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,859 15458 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,860 | ^~ 2023-09-08T22:04:02,861 Box2D/Box2D_wrap.cpp:15458:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,861 15458 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,862 | ^~~~ 2023-09-08T22:04:02,862 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal(PyObject*, PyObject*)’: 2023-09-08T22:04:02,863 Box2D/Box2D_wrap.cpp:15466:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,863 15466 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,864 | ^~ 2023-09-08T22:04:02,865 Box2D/Box2D_wrap.cpp:15466:108: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,865 15466 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-08T22:04:02,866 | ^~ 2023-09-08T22:04:02,866 Box2D/Box2D_wrap.cpp:15468:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,867 15468 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,867 | ^~ 2023-09-08T22:04:02,868 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,868 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,869 | ^~~~ 2023-09-08T22:04:02,870 Box2D/Box2D_wrap.cpp:15468:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,870 15468 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,871 | ^~~~~~~~~ 2023-09-08T22:04:02,872 Box2D/Box2D_wrap.cpp:15470:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,872 15470 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,873 | ^~ 2023-09-08T22:04:02,873 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,874 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,875 | ^~~~ 2023-09-08T22:04:02,875 Box2D/Box2D_wrap.cpp:15470:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,876 15470 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,876 | ^~~~~~~~~ 2023-09-08T22:04:02,882 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetGravity(PyObject*, PyObject*)’: 2023-09-08T22:04:02,882 Box2D/Box2D_wrap.cpp:15609:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,883 15609 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,884 | ^~ 2023-09-08T22:04:02,884 Box2D/Box2D_wrap.cpp:15609:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,885 15609 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,886 | ^~~~~~~~ 2023-09-08T22:04:02,893 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactManager(PyObject*, PyObject*)’: 2023-09-08T22:04:02,894 Box2D/Box2D_wrap.cpp:15659:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,894 15659 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,895 | ^~ 2023-09-08T22:04:02,895 Box2D/Box2D_wrap.cpp:15659:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,896 15659 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,896 | ^~~~~~~~ 2023-09-08T22:04:02,897 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_GetProfile(PyObject*, PyObject*)’: 2023-09-08T22:04:02,897 Box2D/Box2D_wrap.cpp:15669:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,898 15669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,899 | ^~ 2023-09-08T22:04:02,899 Box2D/Box2D_wrap.cpp:15669:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,900 15669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-08T22:04:02,900 | ^~~~~~~~ 2023-09-08T22:04:02,909 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DestroyBody(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,910 Box2D/Box2D_wrap.cpp:15736:104: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-08T22:04:02,910 15736 | arg2 = reinterpret_cast< b2Body * >(argp2); { try { b2World_DestroyBody(arg1,arg2); } catch (Swig::DirectorException) { 2023-09-08T22:04:02,911 | ^~~~~~~~~~~~~~~~~ 2023-09-08T22:04:02,912 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DestroyJoint(PyObject*, PyObject*, PyObject*)’: 2023-09-08T22:04:02,913 Box2D/Box2D_wrap.cpp:15748:106: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-08T22:04:02,913 15748 | arg2 = reinterpret_cast< b2Joint * >(argp2); { try { b2World_DestroyJoint(arg1,arg2); } catch (Swig::DirectorException) { 2023-09-08T22:04:02,914 | ^~~~~~~~~~~~~~~~~ 2023-09-08T22:04:02,919 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactEdge_other_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,920 Box2D/Box2D_wrap.cpp:15797:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,921 15797 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-08T22:04:02,921 | ^~ 2023-09-08T22:04:02,922 Box2D/Box2D_wrap.cpp:15797:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,923 15797 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-08T22:04:02,923 | ^~~~~~~~ 2023-09-08T22:04:02,924 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactEdge_contact_get(PyObject*, PyObject*)’: 2023-09-08T22:04:02,925 Box2D/Box2D_wrap.cpp:15815:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,925 15815 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-08T22:04:02,926 | ^~ 2023-09-08T22:04:02,927 Box2D/Box2D_wrap.cpp:15815:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,927 15815 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-08T22:04:02,928 | ^~~~~~~~ 2023-09-08T22:04:02,932 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactEdge___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:02,932 Box2D/Box2D_wrap.cpp:15860:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,933 15860 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-08T22:04:02,933 | ^~ 2023-09-08T22:04:02,934 Box2D/Box2D_wrap.cpp:15860:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,935 15860 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-08T22:04:02,935 | ^~~~~~~~ 2023-09-08T22:04:02,937 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetManifold__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,938 Box2D/Box2D_wrap.cpp:15892:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,939 15892 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,939 | ^~ 2023-09-08T22:04:02,940 Box2D/Box2D_wrap.cpp:15892:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,941 15892 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,942 | ^~~~ 2023-09-08T22:04:02,942 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetManifold__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,943 Box2D/Box2D_wrap.cpp:15900:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,944 15900 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,945 | ^~ 2023-09-08T22:04:02,945 Box2D/Box2D_wrap.cpp:15900:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,946 15900 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,947 | ^~~~ 2023-09-08T22:04:02,947 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetManifold(PyObject*, PyObject*)’: 2023-09-08T22:04:02,948 Box2D/Box2D_wrap.cpp:15907:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,948 15907 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetManifold", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,949 | ^~ 2023-09-08T22:04:02,950 Box2D/Box2D_wrap.cpp:15907:98: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,950 15907 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetManifold", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,951 | ^~ 2023-09-08T22:04:02,952 Box2D/Box2D_wrap.cpp:15909:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,952 15909 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,953 | ^~ 2023-09-08T22:04:02,953 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,954 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,954 | ^~~~ 2023-09-08T22:04:02,955 Box2D/Box2D_wrap.cpp:15909:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,955 15909 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,956 | ^~~~~~~~~ 2023-09-08T22:04:02,956 Box2D/Box2D_wrap.cpp:15911:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,957 15911 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,957 | ^~ 2023-09-08T22:04:02,958 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,958 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,959 | ^~~~ 2023-09-08T22:04:02,960 Box2D/Box2D_wrap.cpp:15911:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,960 15911 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,961 | ^~~~~~~~~ 2023-09-08T22:04:02,961 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___IsTouching(PyObject*, PyObject*)’: 2023-09-08T22:04:02,962 Box2D/Box2D_wrap.cpp:15929:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,963 15929 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,963 | ^~ 2023-09-08T22:04:02,964 Box2D/Box2D_wrap.cpp:15929:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,965 15929 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,965 | ^~~~~~~~ 2023-09-08T22:04:02,966 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___IsEnabled(PyObject*, PyObject*)’: 2023-09-08T22:04:02,967 Box2D/Box2D_wrap.cpp:15947:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,967 15947 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,968 | ^~ 2023-09-08T22:04:02,968 Box2D/Box2D_wrap.cpp:15947:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,969 15947 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,970 | ^~~~~~~~ 2023-09-08T22:04:02,970 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,971 Box2D/Box2D_wrap.cpp:15955:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,971 15955 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,972 | ^~ 2023-09-08T22:04:02,973 Box2D/Box2D_wrap.cpp:15955:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,974 15955 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,974 | ^~~~ 2023-09-08T22:04:02,975 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,975 Box2D/Box2D_wrap.cpp:15963:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,975 15963 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,976 | ^~ 2023-09-08T22:04:02,977 Box2D/Box2D_wrap.cpp:15963:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,977 15963 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,978 | ^~~~ 2023-09-08T22:04:02,978 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetNext(PyObject*, PyObject*)’: 2023-09-08T22:04:02,979 Box2D/Box2D_wrap.cpp:15970:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,979 15970 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,980 | ^~ 2023-09-08T22:04:02,980 Box2D/Box2D_wrap.cpp:15970:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,981 15970 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:02,982 | ^~ 2023-09-08T22:04:02,983 Box2D/Box2D_wrap.cpp:15972:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,983 15972 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,984 | ^~ 2023-09-08T22:04:02,985 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,986 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,986 | ^~~~ 2023-09-08T22:04:02,987 Box2D/Box2D_wrap.cpp:15972:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,988 15972 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:02,988 | ^~~~~~~~~ 2023-09-08T22:04:02,989 Box2D/Box2D_wrap.cpp:15974:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,990 15974 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,990 | ^~ 2023-09-08T22:04:02,991 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,992 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:02,992 | ^~~~ 2023-09-08T22:04:02,993 Box2D/Box2D_wrap.cpp:15974:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:02,994 15974 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:02,994 | ^~~~~~~~~ 2023-09-08T22:04:02,995 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureA__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,996 Box2D/Box2D_wrap.cpp:15979:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:02,996 15979 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,997 | ^~ 2023-09-08T22:04:02,997 Box2D/Box2D_wrap.cpp:15979:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:02,998 15979 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:02,998 | ^~~~ 2023-09-08T22:04:02,999 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureA__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:02,999 Box2D/Box2D_wrap.cpp:15987:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,000 15987 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,000 | ^~ 2023-09-08T22:04:03,001 Box2D/Box2D_wrap.cpp:15987:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,001 15987 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,002 | ^~~~ 2023-09-08T22:04:03,003 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,003 Box2D/Box2D_wrap.cpp:15994:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,004 15994 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureA", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:03,004 | ^~ 2023-09-08T22:04:03,005 Box2D/Box2D_wrap.cpp:15994:98: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,006 15994 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureA", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:03,006 | ^~ 2023-09-08T22:04:03,007 Box2D/Box2D_wrap.cpp:15996:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,008 15996 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:03,008 | ^~ 2023-09-08T22:04:03,009 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,010 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:03,010 | ^~~~ 2023-09-08T22:04:03,011 Box2D/Box2D_wrap.cpp:15996:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:03,011 15996 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:03,012 | ^~~~~~~~~ 2023-09-08T22:04:03,013 Box2D/Box2D_wrap.cpp:15998:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,013 15998 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:03,014 | ^~ 2023-09-08T22:04:03,014 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,015 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:03,016 | ^~~~ 2023-09-08T22:04:03,016 Box2D/Box2D_wrap.cpp:15998:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:03,017 15998 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:03,018 | ^~~~~~~~~ 2023-09-08T22:04:03,018 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetChildIndexA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,019 Box2D/Box2D_wrap.cpp:16003:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,019 16003 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,020 | ^~ 2023-09-08T22:04:03,020 Box2D/Box2D_wrap.cpp:16003:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,021 16003 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,021 | ^~~~~~~~ 2023-09-08T22:04:03,022 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureB__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:03,022 Box2D/Box2D_wrap.cpp:16011:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,023 16011 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,024 | ^~ 2023-09-08T22:04:03,024 Box2D/Box2D_wrap.cpp:16011:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,025 16011 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,025 | ^~~~ 2023-09-08T22:04:03,026 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureB__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:03,027 Box2D/Box2D_wrap.cpp:16019:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,027 16019 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,028 | ^~ 2023-09-08T22:04:03,028 Box2D/Box2D_wrap.cpp:16019:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,029 16019 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,030 | ^~~~ 2023-09-08T22:04:03,030 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,031 Box2D/Box2D_wrap.cpp:16026:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,031 16026 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureB", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:03,032 | ^~ 2023-09-08T22:04:03,033 Box2D/Box2D_wrap.cpp:16026:98: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,033 16026 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureB", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:03,034 | ^~ 2023-09-08T22:04:03,035 Box2D/Box2D_wrap.cpp:16028:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,035 16028 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:03,036 | ^~ 2023-09-08T22:04:03,037 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,037 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:03,038 | ^~~~ 2023-09-08T22:04:03,038 Box2D/Box2D_wrap.cpp:16028:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:03,039 16028 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:03,040 | ^~~~~~~~~ 2023-09-08T22:04:03,040 Box2D/Box2D_wrap.cpp:16030:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,041 16030 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:03,041 | ^~ 2023-09-08T22:04:03,042 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,042 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:03,043 | ^~~~ 2023-09-08T22:04:03,043 Box2D/Box2D_wrap.cpp:16030:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:03,044 16030 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:03,044 | ^~~~~~~~~ 2023-09-08T22:04:03,045 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetChildIndexB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,046 Box2D/Box2D_wrap.cpp:16035:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,046 16035 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,047 | ^~ 2023-09-08T22:04:03,047 Box2D/Box2D_wrap.cpp:16035:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,048 16035 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,049 | ^~~~~~~~ 2023-09-08T22:04:03,049 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFriction(PyObject*, PyObject*)’: 2023-09-08T22:04:03,050 Box2D/Box2D_wrap.cpp:16053:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,051 16053 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,051 | ^~ 2023-09-08T22:04:03,052 Box2D/Box2D_wrap.cpp:16053:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,053 16053 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,053 | ^~~~~~~~ 2023-09-08T22:04:03,054 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetRestitution(PyObject*, PyObject*)’: 2023-09-08T22:04:03,055 Box2D/Box2D_wrap.cpp:16078:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,055 16078 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,056 | ^~ 2023-09-08T22:04:03,057 Box2D/Box2D_wrap.cpp:16078:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,058 16078 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,059 | ^~~~~~~~ 2023-09-08T22:04:03,059 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetTangentSpeed(PyObject*, PyObject*)’: 2023-09-08T22:04:03,059 Box2D/Box2D_wrap.cpp:16102:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,060 16102 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,061 | ^~ 2023-09-08T22:04:03,061 Box2D/Box2D_wrap.cpp:16102:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,062 16102 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,062 | ^~~~~~~~ 2023-09-08T22:04:03,063 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,063 Box2D/Box2D_wrap.cpp:16134:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,064 16134 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,064 | ^~ 2023-09-08T22:04:03,065 Box2D/Box2D_wrap.cpp:16134:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,066 16134 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-08T22:04:03,066 | ^~~~~~~~ 2023-09-08T22:04:03,067 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian_linear_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,067 Box2D/Box2D_wrap.cpp:16165:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,068 16165 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-08T22:04:03,068 | ^~ 2023-09-08T22:04:03,069 Box2D/Box2D_wrap.cpp:16165:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,070 16165 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-08T22:04:03,070 | ^~~~~~~~ 2023-09-08T22:04:03,071 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian_angularA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,071 Box2D/Box2D_wrap.cpp:16181:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,072 16181 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-08T22:04:03,073 | ^~ 2023-09-08T22:04:03,073 Box2D/Box2D_wrap.cpp:16181:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,074 16181 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-08T22:04:03,075 | ^~~~~~~~ 2023-09-08T22:04:03,075 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian_angularB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,076 Box2D/Box2D_wrap.cpp:16197:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,077 16197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-08T22:04:03,077 | ^~ 2023-09-08T22:04:03,078 Box2D/Box2D_wrap.cpp:16197:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,079 16197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-08T22:04:03,079 | ^~~~~~~~ 2023-09-08T22:04:03,080 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,080 Box2D/Box2D_wrap.cpp:16204:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,081 16204 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-08T22:04:03,081 | ^~ 2023-09-08T22:04:03,082 Box2D/Box2D_wrap.cpp:16204:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,083 16204 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-08T22:04:03,083 | ^~~~~~~~ 2023-09-08T22:04:03,084 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Jacobian(PyObject*, PyObject*)’: 2023-09-08T22:04:03,084 Box2D/Box2D_wrap.cpp:16211:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,085 16211 | if (!SWIG_Python_UnpackTuple(args, "new_b2Jacobian", 0, 0, 0)) SWIG_fail; { try { result = (b2Jacobian *)new b2Jacobian(); } 2023-09-08T22:04:03,085 | ^~ 2023-09-08T22:04:03,086 Box2D/Box2D_wrap.cpp:16211:77: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,087 16211 | if (!SWIG_Python_UnpackTuple(args, "new_b2Jacobian", 0, 0, 0)) SWIG_fail; { try { result = (b2Jacobian *)new b2Jacobian(); } 2023-09-08T22:04:03,087 | ^ 2023-09-08T22:04:03,088 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge_other_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,088 Box2D/Box2D_wrap.cpp:16245:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,089 16245 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,089 | ^~ 2023-09-08T22:04:03,090 Box2D/Box2D_wrap.cpp:16245:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,091 16245 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,091 | ^~~~~~~~ 2023-09-08T22:04:03,092 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge_joint_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,092 Box2D/Box2D_wrap.cpp:16262:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,093 16262 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,093 | ^~ 2023-09-08T22:04:03,094 Box2D/Box2D_wrap.cpp:16262:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,095 16262 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,095 | ^~~~~~~~ 2023-09-08T22:04:03,096 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge_prev_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,097 Box2D/Box2D_wrap.cpp:16293:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,097 16293 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,098 | ^~ 2023-09-08T22:04:03,099 Box2D/Box2D_wrap.cpp:16293:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,099 16293 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,100 | ^~~~~~~~ 2023-09-08T22:04:03,100 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge_next_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,101 Box2D/Box2D_wrap.cpp:16312:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,102 16312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,102 | ^~ 2023-09-08T22:04:03,103 Box2D/Box2D_wrap.cpp:16312:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,103 16312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,104 | ^~~~~~~~ 2023-09-08T22:04:03,104 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,105 Box2D/Box2D_wrap.cpp:16320:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,105 16320 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,106 | ^~ 2023-09-08T22:04:03,107 Box2D/Box2D_wrap.cpp:16320:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,107 16320 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-08T22:04:03,108 | ^~~~~~~~ 2023-09-08T22:04:03,108 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2JointEdge(PyObject*, PyObject*)’: 2023-09-08T22:04:03,109 Box2D/Box2D_wrap.cpp:16327:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,109 16327 | if (!SWIG_Python_UnpackTuple(args, "new_b2JointEdge", 0, 0, 0)) SWIG_fail; { try { result = (b2JointEdge *)new b2JointEdge(); } 2023-09-08T22:04:03,110 | ^~ 2023-09-08T22:04:03,110 Box2D/Box2D_wrap.cpp:16327:78: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,111 16327 | if (!SWIG_Python_UnpackTuple(args, "new_b2JointEdge", 0, 0, 0)) SWIG_fail; { try { result = (b2JointEdge *)new b2JointEdge(); } 2023-09-08T22:04:03,112 | ^ 2023-09-08T22:04:03,113 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2JointDef(PyObject*, PyObject*)’: 2023-09-08T22:04:03,113 Box2D/Box2D_wrap.cpp:16350:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,114 16350 | if (!SWIG_Python_UnpackTuple(args, "new_b2JointDef", 0, 0, 0)) SWIG_fail; { try { result = (b2JointDef *)new b2JointDef(); } 2023-09-08T22:04:03,114 | ^~ 2023-09-08T22:04:03,115 Box2D/Box2D_wrap.cpp:16350:77: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,116 16350 | if (!SWIG_Python_UnpackTuple(args, "new_b2JointDef", 0, 0, 0)) SWIG_fail; { try { result = (b2JointDef *)new b2JointDef(); } 2023-09-08T22:04:03,116 | ^ 2023-09-08T22:04:03,117 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_type_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,118 Box2D/Box2D_wrap.cpp:16365:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,119 16365 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,119 | ^~ 2023-09-08T22:04:03,120 Box2D/Box2D_wrap.cpp:16365:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,120 16365 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,121 | ^~~~~~~~ 2023-09-08T22:04:03,121 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_bodyA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,122 Box2D/Box2D_wrap.cpp:16382:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,123 16382 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,123 | ^~ 2023-09-08T22:04:03,124 Box2D/Box2D_wrap.cpp:16382:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,124 16382 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,125 | ^~~~~~~~ 2023-09-08T22:04:03,125 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_bodyB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,126 Box2D/Box2D_wrap.cpp:16399:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,126 16399 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,127 | ^~ 2023-09-08T22:04:03,127 Box2D/Box2D_wrap.cpp:16399:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,128 16399 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,129 | ^~~~~~~~ 2023-09-08T22:04:03,129 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_collideConnected_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,130 Box2D/Box2D_wrap.cpp:16415:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,131 16415 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,131 | ^~ 2023-09-08T22:04:03,132 Box2D/Box2D_wrap.cpp:16415:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,132 16415 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,133 | ^~~~~~~~ 2023-09-08T22:04:03,134 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,134 Box2D/Box2D_wrap.cpp:16422:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,135 16422 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,135 | ^~ 2023-09-08T22:04:03,136 Box2D/Box2D_wrap.cpp:16422:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,137 16422 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,137 | ^~~~~~~~ 2023-09-08T22:04:03,138 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef___GetUserData(PyObject*, PyObject*)’: 2023-09-08T22:04:03,139 Box2D/Box2D_wrap.cpp:16430:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,140 16430 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,140 | ^~ 2023-09-08T22:04:03,141 Box2D/Box2D_wrap.cpp:16430:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,141 16430 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-08T22:04:03,142 | ^~~~~~~~ 2023-09-08T22:04:03,142 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetType(PyObject*, PyObject*)’: 2023-09-08T22:04:03,143 Box2D/Box2D_wrap.cpp:16471:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,144 16471 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,144 | ^~ 2023-09-08T22:04:03,145 Box2D/Box2D_wrap.cpp:16471:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,145 16471 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,146 | ^~~~~~~~ 2023-09-08T22:04:03,147 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetBodyA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,147 Box2D/Box2D_wrap.cpp:16479:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,148 16479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,148 | ^~ 2023-09-08T22:04:03,149 Box2D/Box2D_wrap.cpp:16479:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,150 16479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,150 | ^~~~~~~~ 2023-09-08T22:04:03,151 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetBodyB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,151 Box2D/Box2D_wrap.cpp:16487:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,152 16487 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,153 | ^~ 2023-09-08T22:04:03,154 Box2D/Box2D_wrap.cpp:16487:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,154 16487 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,155 | ^~~~~~~~ 2023-09-08T22:04:03,156 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetAnchorA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,156 Box2D/Box2D_wrap.cpp:16495:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,157 16495 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,158 | ^~ 2023-09-08T22:04:03,158 Box2D/Box2D_wrap.cpp:16495:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,159 16495 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,160 | ^~~~~~~~ 2023-09-08T22:04:03,160 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetAnchorB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,161 Box2D/Box2D_wrap.cpp:16504:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,162 16504 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,163 | ^~ 2023-09-08T22:04:03,163 Box2D/Box2D_wrap.cpp:16504:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,164 16504 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,164 | ^~~~~~~~ 2023-09-08T22:04:03,165 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:03,165 Box2D/Box2D_wrap.cpp:16538:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,166 16538 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,167 | ^~ 2023-09-08T22:04:03,167 Box2D/Box2D_wrap.cpp:16538:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,168 16538 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,168 | ^~~~ 2023-09-08T22:04:03,169 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-08T22:04:03,169 Box2D/Box2D_wrap.cpp:16558:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,170 16558 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,171 | ^~ 2023-09-08T22:04:03,171 Box2D/Box2D_wrap.cpp:16558:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,172 16558 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,173 | ^~~~ 2023-09-08T22:04:03,173 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext(PyObject*, PyObject*)’: 2023-09-08T22:04:03,174 Box2D/Box2D_wrap.cpp:16578:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,175 16578 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Joint___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:03,175 | ^~ 2023-09-08T22:04:03,176 Box2D/Box2D_wrap.cpp:16578:92: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,177 16578 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Joint___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-08T22:04:03,177 | ^~ 2023-09-08T22:04:03,178 Box2D/Box2D_wrap.cpp:16580:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,179 16580 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:03,179 | ^~ 2023-09-08T22:04:03,180 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,181 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:03,182 | ^~~~ 2023-09-08T22:04:03,182 Box2D/Box2D_wrap.cpp:16580:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:03,183 16580 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-08T22:04:03,184 | ^~~~~~~~~ 2023-09-08T22:04:03,185 Box2D/Box2D_wrap.cpp:16582:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,185 16582 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:03,185 | ^~ 2023-09-08T22:04:03,186 Box2D/Box2D_wrap.cpp:1122:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,187 1122 | #define SWIG_fail goto fail 2023-09-08T22:04:03,187 | ^~~~ 2023-09-08T22:04:03,188 Box2D/Box2D_wrap.cpp:16582:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-08T22:04:03,188 16582 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-08T22:04:03,189 | ^~~~~~~~~ 2023-09-08T22:04:03,189 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetUserData(PyObject*, PyObject*)’: 2023-09-08T22:04:03,190 Box2D/Box2D_wrap.cpp:16631:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,191 16631 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,191 | ^~ 2023-09-08T22:04:03,192 Box2D/Box2D_wrap.cpp:16631:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,192 16631 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-08T22:04:03,193 | ^~~~~~~~ 2023-09-08T22:04:03,194 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJointDef_length_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,195 Box2D/Box2D_wrap.cpp:16760:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,195 16760 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-08T22:04:03,196 | ^~ 2023-09-08T22:04:03,197 Box2D/Box2D_wrap.cpp:16760:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,198 16760 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-08T22:04:03,198 | ^~~~~~~~ 2023-09-08T22:04:03,199 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJointDef_frequencyHz_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,200 Box2D/Box2D_wrap.cpp:16778:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,201 16778 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-08T22:04:03,201 | ^~ 2023-09-08T22:04:03,202 Box2D/Box2D_wrap.cpp:16778:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,203 16778 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-08T22:04:03,204 | ^~~~~~~~ 2023-09-08T22:04:03,204 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJointDef_dampingRatio_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,205 Box2D/Box2D_wrap.cpp:16796:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,206 16796 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-08T22:04:03,207 | ^~ 2023-09-08T22:04:03,208 Box2D/Box2D_wrap.cpp:16796:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,208 16796 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-08T22:04:03,209 | ^~~~~~~~ 2023-09-08T22:04:03,209 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,210 Box2D/Box2D_wrap.cpp:16803:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,211 16803 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-08T22:04:03,211 | ^~ 2023-09-08T22:04:03,212 Box2D/Box2D_wrap.cpp:16803:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,212 16803 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-08T22:04:03,213 | ^~~~~~~~ 2023-09-08T22:04:03,213 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceJointDef(PyObject*, PyObject*)’: 2023-09-08T22:04:03,214 Box2D/Box2D_wrap.cpp:16811:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,214 16811 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,215 | ^~ 2023-09-08T22:04:03,215 Box2D/Box2D_wrap.cpp:16811:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,216 16811 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,217 | ^~~~~~~~ 2023-09-08T22:04:03,218 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,218 Box2D/Box2D_wrap.cpp:16829:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,219 16829 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,220 | ^~ 2023-09-08T22:04:03,221 Box2D/Box2D_wrap.cpp:16829:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,221 16829 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,222 | ^~~~~~~~ 2023-09-08T22:04:03,223 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,223 Box2D/Box2D_wrap.cpp:16838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,224 16838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,225 | ^~ 2023-09-08T22:04:03,225 Box2D/Box2D_wrap.cpp:16838:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,226 16838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,227 | ^~~~~~~~ 2023-09-08T22:04:03,228 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint___GetLength(PyObject*, PyObject*)’: 2023-09-08T22:04:03,228 Box2D/Box2D_wrap.cpp:16858:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,229 16858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,230 | ^~ 2023-09-08T22:04:03,231 Box2D/Box2D_wrap.cpp:16858:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,232 16858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,232 | ^~~~~~~~ 2023-09-08T22:04:03,233 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint___GetFrequency(PyObject*, PyObject*)’: 2023-09-08T22:04:03,233 Box2D/Box2D_wrap.cpp:16877:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,234 16877 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,235 | ^~ 2023-09-08T22:04:03,235 Box2D/Box2D_wrap.cpp:16877:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,236 16877 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,236 | ^~~~~~~~ 2023-09-08T22:04:03,237 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint___GetDampingRatio(PyObject*, PyObject*)’: 2023-09-08T22:04:03,237 Box2D/Box2D_wrap.cpp:16897:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,238 16897 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,238 | ^~ 2023-09-08T22:04:03,239 Box2D/Box2D_wrap.cpp:16897:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,240 16897 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,241 | ^~~~~~~~ 2023-09-08T22:04:03,241 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,242 Box2D/Box2D_wrap.cpp:16906:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,243 16906 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,243 | ^~ 2023-09-08T22:04:03,244 Box2D/Box2D_wrap.cpp:16906:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,245 16906 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-08T22:04:03,246 | ^~~~~~~~ 2023-09-08T22:04:03,247 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJointDef_maxForce_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,247 Box2D/Box2D_wrap.cpp:17018:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,248 17018 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-08T22:04:03,249 | ^~ 2023-09-08T22:04:03,249 Box2D/Box2D_wrap.cpp:17018:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,250 17018 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-08T22:04:03,251 | ^~~~~~~~ 2023-09-08T22:04:03,251 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJointDef_maxTorque_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,252 Box2D/Box2D_wrap.cpp:17036:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,253 17036 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-08T22:04:03,254 | ^~ 2023-09-08T22:04:03,254 Box2D/Box2D_wrap.cpp:17036:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,255 17036 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-08T22:04:03,255 | ^~~~~~~~ 2023-09-08T22:04:03,256 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,257 Box2D/Box2D_wrap.cpp:17043:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,257 17043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-08T22:04:03,258 | ^~ 2023-09-08T22:04:03,258 Box2D/Box2D_wrap.cpp:17043:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,259 17043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-08T22:04:03,259 | ^~~~~~~~ 2023-09-08T22:04:03,260 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2FrictionJointDef(PyObject*, PyObject*)’: 2023-09-08T22:04:03,261 Box2D/Box2D_wrap.cpp:17051:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,261 17051 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,262 | ^~ 2023-09-08T22:04:03,263 Box2D/Box2D_wrap.cpp:17051:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,263 17051 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,264 | ^~~~~~~~ 2023-09-08T22:04:03,265 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,266 Box2D/Box2D_wrap.cpp:17069:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,267 17069 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,267 | ^~ 2023-09-08T22:04:03,268 Box2D/Box2D_wrap.cpp:17069:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,269 17069 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,270 | ^~~~~~~~ 2023-09-08T22:04:03,270 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,271 Box2D/Box2D_wrap.cpp:17078:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,272 17078 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,272 | ^~ 2023-09-08T22:04:03,273 Box2D/Box2D_wrap.cpp:17078:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,274 17078 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,275 | ^~~~~~~~ 2023-09-08T22:04:03,275 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint___GetMaxForce(PyObject*, PyObject*)’: 2023-09-08T22:04:03,276 Box2D/Box2D_wrap.cpp:17098:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,277 17098 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,278 | ^~ 2023-09-08T22:04:03,278 Box2D/Box2D_wrap.cpp:17098:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,279 17098 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,279 | ^~~~~~~~ 2023-09-08T22:04:03,280 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint___GetMaxTorque(PyObject*, PyObject*)’: 2023-09-08T22:04:03,281 Box2D/Box2D_wrap.cpp:17118:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,282 17118 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,283 | ^~ 2023-09-08T22:04:03,284 Box2D/Box2D_wrap.cpp:17118:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,285 17118 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,286 | ^~~~~~~~ 2023-09-08T22:04:03,286 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,287 Box2D/Box2D_wrap.cpp:17127:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,288 17127 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,288 | ^~ 2023-09-08T22:04:03,289 Box2D/Box2D_wrap.cpp:17127:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,290 17127 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-08T22:04:03,291 | ^~~~~~~~ 2023-09-08T22:04:03,291 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJointDef_joint1_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,292 Box2D/Box2D_wrap.cpp:17166:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,293 17166 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-08T22:04:03,294 | ^~ 2023-09-08T22:04:03,294 Box2D/Box2D_wrap.cpp:17166:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,295 17166 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-08T22:04:03,296 | ^~~~~~~~ 2023-09-08T22:04:03,296 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJointDef_joint2_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,297 Box2D/Box2D_wrap.cpp:17197:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,297 17197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-08T22:04:03,298 | ^~ 2023-09-08T22:04:03,299 Box2D/Box2D_wrap.cpp:17197:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,299 17197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-08T22:04:03,300 | ^~~~~~~~ 2023-09-08T22:04:03,301 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJointDef_ratio_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,302 Box2D/Box2D_wrap.cpp:17226:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,302 17226 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-08T22:04:03,303 | ^~ 2023-09-08T22:04:03,303 Box2D/Box2D_wrap.cpp:17226:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,304 17226 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-08T22:04:03,304 | ^~~~~~~~ 2023-09-08T22:04:03,305 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,306 Box2D/Box2D_wrap.cpp:17233:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,306 17233 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-08T22:04:03,307 | ^~ 2023-09-08T22:04:03,307 Box2D/Box2D_wrap.cpp:17233:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,308 17233 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-08T22:04:03,309 | ^~~~~~~~ 2023-09-08T22:04:03,309 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint_GetJoint1(PyObject*, PyObject*)’: 2023-09-08T22:04:03,310 Box2D/Box2D_wrap.cpp:17259:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,311 17259 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-08T22:04:03,311 | ^~ 2023-09-08T22:04:03,312 Box2D/Box2D_wrap.cpp:17259:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,312 17259 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-08T22:04:03,313 | ^~~~~~~~ 2023-09-08T22:04:03,314 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint_GetJoint2(PyObject*, PyObject*)’: 2023-09-08T22:04:03,315 Box2D/Box2D_wrap.cpp:17280:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,316 17280 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-08T22:04:03,316 | ^~ 2023-09-08T22:04:03,317 Box2D/Box2D_wrap.cpp:17280:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,318 17280 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-08T22:04:03,318 | ^~~~~~~~ 2023-09-08T22:04:03,319 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint___GetRatio(PyObject*, PyObject*)’: 2023-09-08T22:04:03,320 Box2D/Box2D_wrap.cpp:17311:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,320 17311 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-08T22:04:03,321 | ^~ 2023-09-08T22:04:03,322 Box2D/Box2D_wrap.cpp:17311:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,323 17311 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-08T22:04:03,323 | ^~~~~~~~ 2023-09-08T22:04:03,324 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,325 Box2D/Box2D_wrap.cpp:17319:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,326 17319 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-08T22:04:03,326 | ^~ 2023-09-08T22:04:03,327 Box2D/Box2D_wrap.cpp:17319:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,327 17319 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-08T22:04:03,328 | ^~~~~~~~ 2023-09-08T22:04:03,328 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_linearOffset_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,329 Box2D/Box2D_wrap.cpp:17379:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,329 17379 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,330 | ^~ 2023-09-08T22:04:03,330 Box2D/Box2D_wrap.cpp:17379:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,331 17379 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,331 | ^~~~~~~~ 2023-09-08T22:04:03,332 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_angularOffset_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,333 Box2D/Box2D_wrap.cpp:17395:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,333 17395 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,334 | ^~ 2023-09-08T22:04:03,335 Box2D/Box2D_wrap.cpp:17395:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,336 17395 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,336 | ^~~~~~~~ 2023-09-08T22:04:03,337 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_maxForce_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,338 Box2D/Box2D_wrap.cpp:17411:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,339 17411 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,339 | ^~ 2023-09-08T22:04:03,340 Box2D/Box2D_wrap.cpp:17411:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,341 17411 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,341 | ^~~~~~~~ 2023-09-08T22:04:03,342 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_maxTorque_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,343 Box2D/Box2D_wrap.cpp:17427:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,343 17427 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,344 | ^~ 2023-09-08T22:04:03,345 Box2D/Box2D_wrap.cpp:17427:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,346 17427 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,346 | ^~~~~~~~ 2023-09-08T22:04:03,347 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_correctionFactor_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,348 Box2D/Box2D_wrap.cpp:17443:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,348 17443 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,348 | ^~ 2023-09-08T22:04:03,349 Box2D/Box2D_wrap.cpp:17443:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,350 17443 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-08T22:04:03,350 | ^~~~~~~~ 2023-09-08T22:04:03,351 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetLinearOffset(PyObject*, PyObject*)’: 2023-09-08T22:04:03,351 Box2D/Box2D_wrap.cpp:17486:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,352 17486 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-08T22:04:03,352 | ^~ 2023-09-08T22:04:03,353 Box2D/Box2D_wrap.cpp:17486:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,353 17486 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-08T22:04:03,354 | ^~~~~~~~ 2023-09-08T22:04:03,355 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetAngularOffset(PyObject*, PyObject*)’: 2023-09-08T22:04:03,355 Box2D/Box2D_wrap.cpp:17506:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,356 17506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-08T22:04:03,357 | ^~ 2023-09-08T22:04:03,357 Box2D/Box2D_wrap.cpp:17506:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,358 17506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-08T22:04:03,359 | ^~~~~~~~ 2023-09-08T22:04:03,359 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetMaxForce(PyObject*, PyObject*)’: 2023-09-08T22:04:03,360 Box2D/Box2D_wrap.cpp:17526:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,361 17526 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-08T22:04:03,361 | ^~ 2023-09-08T22:04:03,362 Box2D/Box2D_wrap.cpp:17526:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,362 17526 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-08T22:04:03,363 | ^~~~~~~~ 2023-09-08T22:04:03,364 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetMaxTorque(PyObject*, PyObject*)’: 2023-09-08T22:04:03,364 Box2D/Box2D_wrap.cpp:17545:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,365 17545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-08T22:04:03,366 | ^~ 2023-09-08T22:04:03,367 Box2D/Box2D_wrap.cpp:17545:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,368 17545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-08T22:04:03,368 | ^~~~~~~~ 2023-09-08T22:04:03,373 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef_target_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,373 Box2D/Box2D_wrap.cpp:17589:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,374 17589 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,375 | ^~ 2023-09-08T22:04:03,375 Box2D/Box2D_wrap.cpp:17589:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,376 17589 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,376 | ^~~~~~~~ 2023-09-08T22:04:03,377 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef_maxForce_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,378 Box2D/Box2D_wrap.cpp:17605:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,378 17605 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,379 | ^~ 2023-09-08T22:04:03,379 Box2D/Box2D_wrap.cpp:17605:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,380 17605 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,381 | ^~~~~~~~ 2023-09-08T22:04:03,381 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef_frequencyHz_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,382 Box2D/Box2D_wrap.cpp:17621:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,383 17621 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,384 | ^~ 2023-09-08T22:04:03,385 Box2D/Box2D_wrap.cpp:17621:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,385 17621 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,386 | ^~~~~~~~ 2023-09-08T22:04:03,387 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef_dampingRatio_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,387 Box2D/Box2D_wrap.cpp:17637:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,388 17637 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,389 | ^~ 2023-09-08T22:04:03,389 Box2D/Box2D_wrap.cpp:17637:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,390 17637 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,391 | ^~~~~~~~ 2023-09-08T22:04:03,392 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,392 Box2D/Box2D_wrap.cpp:17644:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,393 17644 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,394 | ^~ 2023-09-08T22:04:03,395 Box2D/Box2D_wrap.cpp:17644:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,395 17644 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-08T22:04:03,396 | ^~~~~~~~ 2023-09-08T22:04:03,396 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetTarget(PyObject*, PyObject*)’: 2023-09-08T22:04:03,397 Box2D/Box2D_wrap.cpp:17687:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,398 17687 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,398 | ^~ 2023-09-08T22:04:03,399 Box2D/Box2D_wrap.cpp:17687:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,399 17687 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,400 | ^~~~~~~~ 2023-09-08T22:04:03,400 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetMaxForce(PyObject*, PyObject*)’: 2023-09-08T22:04:03,401 Box2D/Box2D_wrap.cpp:17706:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,402 17706 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,402 | ^~ 2023-09-08T22:04:03,403 Box2D/Box2D_wrap.cpp:17706:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,403 17706 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,404 | ^~~~~~~~ 2023-09-08T22:04:03,405 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetFrequency(PyObject*, PyObject*)’: 2023-09-08T22:04:03,406 Box2D/Box2D_wrap.cpp:17725:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,406 17725 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,407 | ^~ 2023-09-08T22:04:03,408 Box2D/Box2D_wrap.cpp:17725:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,409 17725 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,409 | ^~~~~~~~ 2023-09-08T22:04:03,410 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetDampingRatio(PyObject*, PyObject*)’: 2023-09-08T22:04:03,411 Box2D/Box2D_wrap.cpp:17744:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,411 17744 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,412 | ^~ 2023-09-08T22:04:03,413 Box2D/Box2D_wrap.cpp:17744:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,413 17744 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,414 | ^~~~~~~~ 2023-09-08T22:04:03,415 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,416 Box2D/Box2D_wrap.cpp:17752:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,417 17752 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,418 | ^~ 2023-09-08T22:04:03,418 Box2D/Box2D_wrap.cpp:17752:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,419 17752 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-08T22:04:03,419 | ^~~~~~~~ 2023-09-08T22:04:03,441 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJointDef_enableLimit_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,441 Box2D/Box2D_wrap.cpp:17915:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,442 17915 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-08T22:04:03,443 | ^~ 2023-09-08T22:04:03,443 Box2D/Box2D_wrap.cpp:17915:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,444 17915 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-08T22:04:03,445 | ^~~~~~~~ 2023-09-08T22:04:03,450 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJointDef_enableMotor_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,451 Box2D/Box2D_wrap.cpp:17969:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,451 17969 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-08T22:04:03,452 | ^~ 2023-09-08T22:04:03,453 Box2D/Box2D_wrap.cpp:17969:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,454 17969 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-08T22:04:03,454 | ^~~~~~~~ 2023-09-08T22:04:03,458 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,459 Box2D/Box2D_wrap.cpp:18012:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,460 18012 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-08T22:04:03,460 | ^~ 2023-09-08T22:04:03,461 Box2D/Box2D_wrap.cpp:18012:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,462 18012 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-08T22:04:03,463 | ^~~~~~~~ 2023-09-08T22:04:03,463 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PrismaticJointDef(PyObject*, PyObject*)’: 2023-09-08T22:04:03,464 Box2D/Box2D_wrap.cpp:18020:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,465 18020 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,466 | ^~ 2023-09-08T22:04:03,466 Box2D/Box2D_wrap.cpp:18020:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,467 18020 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,468 | ^~~~~~~~ 2023-09-08T22:04:03,469 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint_GetReferenceAngle(PyObject*, PyObject*)’: 2023-09-08T22:04:03,470 Box2D/Box2D_wrap.cpp:18065:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,471 18065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,472 | ^~ 2023-09-08T22:04:03,472 Box2D/Box2D_wrap.cpp:18065:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,473 18065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,473 | ^~~~~~~~ 2023-09-08T22:04:03,474 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetJointTranslation(PyObject*, PyObject*)’: 2023-09-08T22:04:03,474 Box2D/Box2D_wrap.cpp:18074:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,475 18074 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,475 | ^~ 2023-09-08T22:04:03,476 Box2D/Box2D_wrap.cpp:18074:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,476 18074 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,477 | ^~~~~~~~ 2023-09-08T22:04:03,477 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetJointSpeed(PyObject*, PyObject*)’: 2023-09-08T22:04:03,478 Box2D/Box2D_wrap.cpp:18083:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,479 18083 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,479 | ^~ 2023-09-08T22:04:03,480 Box2D/Box2D_wrap.cpp:18083:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,481 18083 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,481 | ^~~~~~~~ 2023-09-08T22:04:03,482 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___IsLimitEnabled(PyObject*, PyObject*)’: 2023-09-08T22:04:03,483 Box2D/Box2D_wrap.cpp:18092:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,483 18092 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,484 | ^~ 2023-09-08T22:04:03,485 Box2D/Box2D_wrap.cpp:18092:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,486 18092 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,486 | ^~~~~~~~ 2023-09-08T22:04:03,487 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetLowerLimit(PyObject*, PyObject*)’: 2023-09-08T22:04:03,488 Box2D/Box2D_wrap.cpp:18112:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,488 18112 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,489 | ^~ 2023-09-08T22:04:03,490 Box2D/Box2D_wrap.cpp:18112:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,490 18112 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,491 | ^~~~~~~~ 2023-09-08T22:04:03,492 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetUpperLimit(PyObject*, PyObject*)’: 2023-09-08T22:04:03,493 Box2D/Box2D_wrap.cpp:18121:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,493 18121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,494 | ^~ 2023-09-08T22:04:03,494 Box2D/Box2D_wrap.cpp:18121:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,495 18121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,496 | ^~~~~~~~ 2023-09-08T22:04:03,496 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___IsMotorEnabled(PyObject*, PyObject*)’: 2023-09-08T22:04:03,497 Box2D/Box2D_wrap.cpp:18143:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,497 18143 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,498 | ^~ 2023-09-08T22:04:03,498 Box2D/Box2D_wrap.cpp:18143:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,499 18143 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,500 | ^~~~~~~~ 2023-09-08T22:04:03,500 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetMotorSpeed(PyObject*, PyObject*)’: 2023-09-08T22:04:03,501 Box2D/Box2D_wrap.cpp:18174:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,501 18174 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,502 | ^~ 2023-09-08T22:04:03,503 Box2D/Box2D_wrap.cpp:18174:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,504 18174 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,504 | ^~~~~~~~ 2023-09-08T22:04:03,505 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetMaxMotorForce(PyObject*, PyObject*)’: 2023-09-08T22:04:03,506 Box2D/Box2D_wrap.cpp:18194:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,507 18194 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,507 | ^~ 2023-09-08T22:04:03,508 Box2D/Box2D_wrap.cpp:18194:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,509 18194 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,509 | ^~~~~~~~ 2023-09-08T22:04:03,510 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,511 Box2D/Box2D_wrap.cpp:18215:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,511 18215 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,512 | ^~ 2023-09-08T22:04:03,513 Box2D/Box2D_wrap.cpp:18215:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,514 18215 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-08T22:04:03,514 | ^~~~~~~~ 2023-09-08T22:04:03,515 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PrismaticJoint(PyObject*, PyObject*)’: 2023-09-08T22:04:03,516 Box2D/Box2D_wrap.cpp:18223:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,516 18223 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,517 | ^~ 2023-09-08T22:04:03,517 Box2D/Box2D_wrap.cpp:18223:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,518 18223 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,519 | ^~~~~~~~ 2023-09-08T22:04:03,542 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJointDef_lengthA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,543 Box2D/Box2D_wrap.cpp:18410:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,543 18410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-08T22:04:03,544 | ^~ 2023-09-08T22:04:03,545 Box2D/Box2D_wrap.cpp:18410:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,545 18410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-08T22:04:03,546 | ^~~~~~~~ 2023-09-08T22:04:03,546 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJointDef_lengthB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,547 Box2D/Box2D_wrap.cpp:18428:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,548 18428 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-08T22:04:03,548 | ^~ 2023-09-08T22:04:03,549 Box2D/Box2D_wrap.cpp:18428:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,550 18428 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-08T22:04:03,551 | ^~~~~~~~ 2023-09-08T22:04:03,551 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJointDef_ratio_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,552 Box2D/Box2D_wrap.cpp:18446:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,553 18446 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-08T22:04:03,554 | ^~ 2023-09-08T22:04:03,554 Box2D/Box2D_wrap.cpp:18446:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,555 18446 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-08T22:04:03,556 | ^~~~~~~~ 2023-09-08T22:04:03,556 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,557 Box2D/Box2D_wrap.cpp:18453:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,558 18453 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-08T22:04:03,558 | ^~ 2023-09-08T22:04:03,559 Box2D/Box2D_wrap.cpp:18453:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,560 18453 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-08T22:04:03,561 | ^~~~~~~~ 2023-09-08T22:04:03,562 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PulleyJointDef(PyObject*, PyObject*)’: 2023-09-08T22:04:03,562 Box2D/Box2D_wrap.cpp:18461:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,563 18461 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,563 | ^~ 2023-09-08T22:04:03,564 Box2D/Box2D_wrap.cpp:18461:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,565 18461 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,565 | ^~~~~~~~ 2023-09-08T22:04:03,566 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___GetLengthA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,566 Box2D/Box2D_wrap.cpp:18497:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,567 18497 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,567 | ^~ 2023-09-08T22:04:03,568 Box2D/Box2D_wrap.cpp:18497:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,568 18497 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,569 | ^~~~~~~~ 2023-09-08T22:04:03,570 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___GetLengthB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,570 Box2D/Box2D_wrap.cpp:18505:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,571 18505 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,572 | ^~ 2023-09-08T22:04:03,572 Box2D/Box2D_wrap.cpp:18505:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,573 18505 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,574 | ^~~~~~~~ 2023-09-08T22:04:03,575 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___GetRatio(PyObject*, PyObject*)’: 2023-09-08T22:04:03,576 Box2D/Box2D_wrap.cpp:18513:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,576 18513 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,577 | ^~ 2023-09-08T22:04:03,578 Box2D/Box2D_wrap.cpp:18513:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,579 18513 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,579 | ^~~~~~~~ 2023-09-08T22:04:03,580 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint_GetCurrentLengthA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,581 Box2D/Box2D_wrap.cpp:18521:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,581 18521 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,582 | ^~ 2023-09-08T22:04:03,583 Box2D/Box2D_wrap.cpp:18521:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,583 18521 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,584 | ^~~~~~~~ 2023-09-08T22:04:03,585 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint_GetCurrentLengthB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,586 Box2D/Box2D_wrap.cpp:18530:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,587 18530 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,587 | ^~ 2023-09-08T22:04:03,588 Box2D/Box2D_wrap.cpp:18530:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,588 18530 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,589 | ^~~~~~~~ 2023-09-08T22:04:03,589 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,590 Box2D/Box2D_wrap.cpp:18539:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,590 18539 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,591 | ^~ 2023-09-08T22:04:03,592 Box2D/Box2D_wrap.cpp:18539:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,592 18539 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-08T22:04:03,593 | ^~~~~~~~ 2023-09-08T22:04:03,597 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_referenceAngle_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,598 Box2D/Box2D_wrap.cpp:18651:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,598 18651 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,599 | ^~ 2023-09-08T22:04:03,600 Box2D/Box2D_wrap.cpp:18651:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,601 18651 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,601 | ^~~~~~~~ 2023-09-08T22:04:03,602 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_enableLimit_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,603 Box2D/Box2D_wrap.cpp:18669:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,604 18669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,604 | ^~ 2023-09-08T22:04:03,605 Box2D/Box2D_wrap.cpp:18669:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,606 18669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,606 | ^~~~~~~~ 2023-09-08T22:04:03,607 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_lowerAngle_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,608 Box2D/Box2D_wrap.cpp:18687:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,609 18687 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,609 | ^~ 2023-09-08T22:04:03,610 Box2D/Box2D_wrap.cpp:18687:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,611 18687 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,612 | ^~~~~~~~ 2023-09-08T22:04:03,613 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_upperAngle_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,613 Box2D/Box2D_wrap.cpp:18705:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,614 18705 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,615 | ^~ 2023-09-08T22:04:03,615 Box2D/Box2D_wrap.cpp:18705:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,616 18705 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,616 | ^~~~~~~~ 2023-09-08T22:04:03,617 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_enableMotor_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,617 Box2D/Box2D_wrap.cpp:18723:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,618 18723 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,619 | ^~ 2023-09-08T22:04:03,619 Box2D/Box2D_wrap.cpp:18723:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,620 18723 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,621 | ^~~~~~~~ 2023-09-08T22:04:03,621 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_motorSpeed_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,622 Box2D/Box2D_wrap.cpp:18741:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,623 18741 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,624 | ^~ 2023-09-08T22:04:03,624 Box2D/Box2D_wrap.cpp:18741:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,625 18741 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,626 | ^~~~~~~~ 2023-09-08T22:04:03,626 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_maxMotorTorque_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,627 Box2D/Box2D_wrap.cpp:18759:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,628 18759 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,628 | ^~ 2023-09-08T22:04:03,629 Box2D/Box2D_wrap.cpp:18759:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,630 18759 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,630 | ^~~~~~~~ 2023-09-08T22:04:03,631 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,632 Box2D/Box2D_wrap.cpp:18766:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,632 18766 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,633 | ^~ 2023-09-08T22:04:03,634 Box2D/Box2D_wrap.cpp:18766:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,634 18766 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-08T22:04:03,635 | ^~~~~~~~ 2023-09-08T22:04:03,635 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RevoluteJointDef(PyObject*, PyObject*)’: 2023-09-08T22:04:03,636 Box2D/Box2D_wrap.cpp:18774:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,636 18774 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,637 | ^~ 2023-09-08T22:04:03,637 Box2D/Box2D_wrap.cpp:18774:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,638 18774 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-08T22:04:03,638 | ^~~~~~~~ 2023-09-08T22:04:03,639 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,639 Box2D/Box2D_wrap.cpp:18792:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,640 18792 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,640 | ^~ 2023-09-08T22:04:03,641 Box2D/Box2D_wrap.cpp:18792:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,642 18792 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,642 | ^~~~~~~~ 2023-09-08T22:04:03,643 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,644 Box2D/Box2D_wrap.cpp:18801:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,645 18801 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,645 | ^~ 2023-09-08T22:04:03,646 Box2D/Box2D_wrap.cpp:18801:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,647 18801 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,647 | ^~~~~~~~ 2023-09-08T22:04:03,648 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint_GetReferenceAngle(PyObject*, PyObject*)’: 2023-09-08T22:04:03,649 Box2D/Box2D_wrap.cpp:18810:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,650 18810 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,650 | ^~ 2023-09-08T22:04:03,651 Box2D/Box2D_wrap.cpp:18810:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,652 18810 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,652 | ^~~~~~~~ 2023-09-08T22:04:03,653 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetJointAngle(PyObject*, PyObject*)’: 2023-09-08T22:04:03,654 Box2D/Box2D_wrap.cpp:18819:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,654 18819 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,655 | ^~ 2023-09-08T22:04:03,656 Box2D/Box2D_wrap.cpp:18819:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,657 18819 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,657 | ^~~~~~~~ 2023-09-08T22:04:03,658 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetJointSpeed(PyObject*, PyObject*)’: 2023-09-08T22:04:03,658 Box2D/Box2D_wrap.cpp:18828:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,659 18828 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,659 | ^~ 2023-09-08T22:04:03,660 Box2D/Box2D_wrap.cpp:18828:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,660 18828 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,661 | ^~~~~~~~ 2023-09-08T22:04:03,661 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___IsLimitEnabled(PyObject*, PyObject*)’: 2023-09-08T22:04:03,662 Box2D/Box2D_wrap.cpp:18837:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,662 18837 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,663 | ^~ 2023-09-08T22:04:03,664 Box2D/Box2D_wrap.cpp:18837:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,664 18837 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,665 | ^~~~~~~~ 2023-09-08T22:04:03,666 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetLowerLimit(PyObject*, PyObject*)’: 2023-09-08T22:04:03,667 Box2D/Box2D_wrap.cpp:18857:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,667 18857 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,668 | ^~ 2023-09-08T22:04:03,668 Box2D/Box2D_wrap.cpp:18857:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,669 18857 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,670 | ^~~~~~~~ 2023-09-08T22:04:03,671 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetUpperLimit(PyObject*, PyObject*)’: 2023-09-08T22:04:03,671 Box2D/Box2D_wrap.cpp:18866:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,672 18866 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,672 | ^~ 2023-09-08T22:04:03,673 Box2D/Box2D_wrap.cpp:18866:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,674 18866 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,675 | ^~~~~~~~ 2023-09-08T22:04:03,675 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___IsMotorEnabled(PyObject*, PyObject*)’: 2023-09-08T22:04:03,676 Box2D/Box2D_wrap.cpp:18888:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,677 18888 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,678 | ^~ 2023-09-08T22:04:03,679 Box2D/Box2D_wrap.cpp:18888:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,679 18888 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,680 | ^~~~~~~~ 2023-09-08T22:04:03,680 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetMotorSpeed(PyObject*, PyObject*)’: 2023-09-08T22:04:03,681 Box2D/Box2D_wrap.cpp:18919:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,681 18919 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,682 | ^~ 2023-09-08T22:04:03,682 Box2D/Box2D_wrap.cpp:18919:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,683 18919 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,684 | ^~~~~~~~ 2023-09-08T22:04:03,684 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint_GetMaxMotorTorque(PyObject*, PyObject*)’: 2023-09-08T22:04:03,685 Box2D/Box2D_wrap.cpp:18939:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,685 18939 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,686 | ^~ 2023-09-08T22:04:03,687 Box2D/Box2D_wrap.cpp:18939:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,687 18939 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,688 | ^~~~~~~~ 2023-09-08T22:04:03,689 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,689 Box2D/Box2D_wrap.cpp:18960:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,690 18960 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,691 | ^~ 2023-09-08T22:04:03,692 Box2D/Box2D_wrap.cpp:18960:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,692 18960 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-08T22:04:03,693 | ^~~~~~~~ 2023-09-08T22:04:03,694 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJointDef_localAnchorA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,694 Box2D/Box2D_wrap.cpp:19004:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,695 19004 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-08T22:04:03,696 | ^~ 2023-09-08T22:04:03,696 Box2D/Box2D_wrap.cpp:19004:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,697 19004 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-08T22:04:03,698 | ^~~~~~~~ 2023-09-08T22:04:03,699 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJointDef_localAnchorB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,699 Box2D/Box2D_wrap.cpp:19027:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,700 19027 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-08T22:04:03,701 | ^~ 2023-09-08T22:04:03,701 Box2D/Box2D_wrap.cpp:19027:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,702 19027 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-08T22:04:03,703 | ^~~~~~~~ 2023-09-08T22:04:03,703 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJointDef_maxLength_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,704 Box2D/Box2D_wrap.cpp:19043:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,704 19043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-08T22:04:03,705 | ^~ 2023-09-08T22:04:03,705 Box2D/Box2D_wrap.cpp:19043:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,706 19043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-08T22:04:03,706 | ^~~~~~~~ 2023-09-08T22:04:03,707 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,708 Box2D/Box2D_wrap.cpp:19050:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,708 19050 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-08T22:04:03,709 | ^~ 2023-09-08T22:04:03,710 Box2D/Box2D_wrap.cpp:19050:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,710 19050 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-08T22:04:03,711 | ^~~~~~~~ 2023-09-08T22:04:03,712 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,713 Box2D/Box2D_wrap.cpp:19076:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,714 19076 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,715 | ^~ 2023-09-08T22:04:03,715 Box2D/Box2D_wrap.cpp:19076:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,716 19076 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,717 | ^~~~~~~~ 2023-09-08T22:04:03,717 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,718 Box2D/Box2D_wrap.cpp:19085:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,719 19085 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,719 | ^~ 2023-09-08T22:04:03,720 Box2D/Box2D_wrap.cpp:19085:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,721 19085 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,722 | ^~~~~~~~ 2023-09-08T22:04:03,723 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint___GetMaxLength(PyObject*, PyObject*)’: 2023-09-08T22:04:03,723 Box2D/Box2D_wrap.cpp:19104:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,724 19104 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,724 | ^~ 2023-09-08T22:04:03,725 Box2D/Box2D_wrap.cpp:19104:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,725 19104 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,726 | ^~~~~~~~ 2023-09-08T22:04:03,726 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint___GetLimitState(PyObject*, PyObject*)’: 2023-09-08T22:04:03,727 Box2D/Box2D_wrap.cpp:19112:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,728 19112 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,728 | ^~ 2023-09-08T22:04:03,729 Box2D/Box2D_wrap.cpp:19112:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,729 19112 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,730 | ^~~~~~~~ 2023-09-08T22:04:03,731 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,731 Box2D/Box2D_wrap.cpp:19121:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,732 19121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,732 | ^~ 2023-09-08T22:04:03,733 Box2D/Box2D_wrap.cpp:19121:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,734 19121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-08T22:04:03,735 | ^~~~~~~~ 2023-09-08T22:04:03,735 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_localAnchorA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,736 Box2D/Box2D_wrap.cpp:19190:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,737 19190 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,738 | ^~ 2023-09-08T22:04:03,738 Box2D/Box2D_wrap.cpp:19190:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,739 19190 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,740 | ^~~~~~~~ 2023-09-08T22:04:03,740 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_localAnchorB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,741 Box2D/Box2D_wrap.cpp:19213:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,742 19213 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,743 | ^~ 2023-09-08T22:04:03,743 Box2D/Box2D_wrap.cpp:19213:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,744 19213 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,745 | ^~~~~~~~ 2023-09-08T22:04:03,745 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_referenceAngle_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,746 Box2D/Box2D_wrap.cpp:19229:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,747 19229 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,747 | ^~ 2023-09-08T22:04:03,748 Box2D/Box2D_wrap.cpp:19229:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,748 19229 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,749 | ^~~~~~~~ 2023-09-08T22:04:03,749 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_frequencyHz_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,750 Box2D/Box2D_wrap.cpp:19245:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,751 19245 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,751 | ^~ 2023-09-08T22:04:03,752 Box2D/Box2D_wrap.cpp:19245:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,752 19245 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,753 | ^~~~~~~~ 2023-09-08T22:04:03,754 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_dampingRatio_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,754 Box2D/Box2D_wrap.cpp:19261:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,755 19261 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,756 | ^~ 2023-09-08T22:04:03,756 Box2D/Box2D_wrap.cpp:19261:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,757 19261 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,757 | ^~~~~~~~ 2023-09-08T22:04:03,758 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,759 Box2D/Box2D_wrap.cpp:19268:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,760 19268 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,760 | ^~ 2023-09-08T22:04:03,761 Box2D/Box2D_wrap.cpp:19268:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,762 19268 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-08T22:04:03,762 | ^~~~~~~~ 2023-09-08T22:04:03,763 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,763 Box2D/Box2D_wrap.cpp:19294:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,764 19294 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,765 | ^~ 2023-09-08T22:04:03,765 Box2D/Box2D_wrap.cpp:19294:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,766 19294 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,767 | ^~~~~~~~ 2023-09-08T22:04:03,768 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,768 Box2D/Box2D_wrap.cpp:19303:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,769 19303 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,769 | ^~ 2023-09-08T22:04:03,770 Box2D/Box2D_wrap.cpp:19303:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,770 19303 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,771 | ^~~~~~~~ 2023-09-08T22:04:03,771 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetReferenceAngle(PyObject*, PyObject*)’: 2023-09-08T22:04:03,772 Box2D/Box2D_wrap.cpp:19312:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,773 19312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,773 | ^~ 2023-09-08T22:04:03,774 Box2D/Box2D_wrap.cpp:19312:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,775 19312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,776 | ^~~~~~~~ 2023-09-08T22:04:03,776 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetFrequency(PyObject*, PyObject*)’: 2023-09-08T22:04:03,777 Box2D/Box2D_wrap.cpp:19330:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,778 19330 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,779 | ^~ 2023-09-08T22:04:03,779 Box2D/Box2D_wrap.cpp:19330:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,780 19330 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,781 | ^~~~~~~~ 2023-09-08T22:04:03,781 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetDampingRatio(PyObject*, PyObject*)’: 2023-09-08T22:04:03,782 Box2D/Box2D_wrap.cpp:19348:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,783 19348 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,783 | ^~ 2023-09-08T22:04:03,784 Box2D/Box2D_wrap.cpp:19348:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,785 19348 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,785 | ^~~~~~~~ 2023-09-08T22:04:03,786 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,786 Box2D/Box2D_wrap.cpp:19356:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,787 19356 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,788 | ^~ 2023-09-08T22:04:03,789 Box2D/Box2D_wrap.cpp:19356:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,789 19356 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-08T22:04:03,790 | ^~~~~~~~ 2023-09-08T22:04:03,790 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_localAnchorA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,791 Box2D/Box2D_wrap.cpp:19434:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,791 19434 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,792 | ^~ 2023-09-08T22:04:03,793 Box2D/Box2D_wrap.cpp:19434:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,793 19434 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,794 | ^~~~~~~~ 2023-09-08T22:04:03,795 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_localAnchorB_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,795 Box2D/Box2D_wrap.cpp:19457:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,796 19457 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,796 | ^~ 2023-09-08T22:04:03,797 Box2D/Box2D_wrap.cpp:19457:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,798 19457 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,798 | ^~~~~~~~ 2023-09-08T22:04:03,799 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_localAxisA_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,800 Box2D/Box2D_wrap.cpp:19480:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,800 19480 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,801 | ^~ 2023-09-08T22:04:03,802 Box2D/Box2D_wrap.cpp:19480:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,802 19480 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,803 | ^~~~~~~~ 2023-09-08T22:04:03,804 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_enableMotor_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,804 Box2D/Box2D_wrap.cpp:19496:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,805 19496 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,806 | ^~ 2023-09-08T22:04:03,806 Box2D/Box2D_wrap.cpp:19496:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,807 19496 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,808 | ^~~~~~~~ 2023-09-08T22:04:03,808 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_maxMotorTorque_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,809 Box2D/Box2D_wrap.cpp:19512:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,810 19512 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,810 | ^~ 2023-09-08T22:04:03,811 Box2D/Box2D_wrap.cpp:19512:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,812 19512 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,812 | ^~~~~~~~ 2023-09-08T22:04:03,813 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_motorSpeed_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,813 Box2D/Box2D_wrap.cpp:19528:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,814 19528 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,814 | ^~ 2023-09-08T22:04:03,815 Box2D/Box2D_wrap.cpp:19528:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,815 19528 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,816 | ^~~~~~~~ 2023-09-08T22:04:03,816 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_frequencyHz_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,817 Box2D/Box2D_wrap.cpp:19544:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,818 19544 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,818 | ^~ 2023-09-08T22:04:03,819 Box2D/Box2D_wrap.cpp:19544:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,819 19544 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,820 | ^~~~~~~~ 2023-09-08T22:04:03,821 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_dampingRatio_get(PyObject*, PyObject*)’: 2023-09-08T22:04:03,822 Box2D/Box2D_wrap.cpp:19560:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,823 19560 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,823 | ^~ 2023-09-08T22:04:03,824 Box2D/Box2D_wrap.cpp:19560:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,825 19560 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,825 | ^~~~~~~~ 2023-09-08T22:04:03,826 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,827 Box2D/Box2D_wrap.cpp:19567:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,827 19567 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,828 | ^~ 2023-09-08T22:04:03,829 Box2D/Box2D_wrap.cpp:19567:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,829 19567 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-08T22:04:03,830 | ^~~~~~~~ 2023-09-08T22:04:03,831 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,832 Box2D/Box2D_wrap.cpp:19593:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,832 19593 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,833 | ^~ 2023-09-08T22:04:03,833 Box2D/Box2D_wrap.cpp:19593:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,834 19593 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,835 | ^~~~~~~~ 2023-09-08T22:04:03,835 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-08T22:04:03,835 Box2D/Box2D_wrap.cpp:19602:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,836 19602 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,837 | ^~ 2023-09-08T22:04:03,837 Box2D/Box2D_wrap.cpp:19602:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,838 19602 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,838 | ^~~~~~~~ 2023-09-08T22:04:03,839 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint_GetLocalAxisA(PyObject*, PyObject*)’: 2023-09-08T22:04:03,839 Box2D/Box2D_wrap.cpp:19611:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,840 19611 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,841 | ^~ 2023-09-08T22:04:03,841 Box2D/Box2D_wrap.cpp:19611:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,842 19611 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,843 | ^~~~~~~~ 2023-09-08T22:04:03,844 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetJointTranslation(PyObject*, PyObject*)’: 2023-09-08T22:04:03,844 Box2D/Box2D_wrap.cpp:19620:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,845 19620 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,846 | ^~ 2023-09-08T22:04:03,847 Box2D/Box2D_wrap.cpp:19620:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,847 19620 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,848 | ^~~~~~~~ 2023-09-08T22:04:03,849 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetJointSpeed(PyObject*, PyObject*)’: 2023-09-08T22:04:03,849 Box2D/Box2D_wrap.cpp:19629:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,850 19629 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,851 | ^~ 2023-09-08T22:04:03,851 Box2D/Box2D_wrap.cpp:19629:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,852 19629 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,853 | ^~~~~~~~ 2023-09-08T22:04:03,853 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___IsMotorEnabled(PyObject*, PyObject*)’: 2023-09-08T22:04:03,854 Box2D/Box2D_wrap.cpp:19637:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,855 19637 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,855 | ^~ 2023-09-08T22:04:03,856 Box2D/Box2D_wrap.cpp:19637:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,856 19637 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,857 | ^~~~~~~~ 2023-09-08T22:04:03,857 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetMotorSpeed(PyObject*, PyObject*)’: 2023-09-08T22:04:03,858 Box2D/Box2D_wrap.cpp:19666:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,859 19666 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,859 | ^~ 2023-09-08T22:04:03,860 Box2D/Box2D_wrap.cpp:19666:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,860 19666 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,861 | ^~~~~~~~ 2023-09-08T22:04:03,861 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetMaxMotorTorque(PyObject*, PyObject*)’: 2023-09-08T22:04:03,862 Box2D/Box2D_wrap.cpp:19685:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,863 19685 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,864 | ^~ 2023-09-08T22:04:03,864 Box2D/Box2D_wrap.cpp:19685:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,865 19685 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,866 | ^~~~~~~~ 2023-09-08T22:04:03,867 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetSpringFrequencyHz(PyObject*, PyObject*)’: 2023-09-08T22:04:03,867 Box2D/Box2D_wrap.cpp:19717:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,868 19717 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,869 | ^~ 2023-09-08T22:04:03,869 Box2D/Box2D_wrap.cpp:19717:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,870 19717 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,871 | ^~~~~~~~ 2023-09-08T22:04:03,871 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetSpringDampingRatio(PyObject*, PyObject*)’: 2023-09-08T22:04:03,872 Box2D/Box2D_wrap.cpp:19737:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,872 19737 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,873 | ^~ 2023-09-08T22:04:03,874 Box2D/Box2D_wrap.cpp:19737:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,874 19737 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,875 | ^~~~~~~~ 2023-09-08T22:04:03,876 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___hash__(PyObject*, PyObject*)’: 2023-09-08T22:04:03,876 Box2D/Box2D_wrap.cpp:19746:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-08T22:04:03,877 19746 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,877 | ^~ 2023-09-08T22:04:03,878 Box2D/Box2D_wrap.cpp:19746:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2023-09-08T22:04:03,878 19746 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-08T22:04:03,879 | ^~~~~~~~ 2023-09-08T22:05:08,796 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/Shapes/b2ChainShape.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2ChainShape.o -I. -Wno-unused 2023-09-08T22:05:10,706 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/Shapes/b2CircleShape.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2CircleShape.o -I. -Wno-unused 2023-09-08T22:05:11,989 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/Shapes/b2EdgeShape.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2EdgeShape.o -I. -Wno-unused 2023-09-08T22:05:13,295 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/Shapes/b2PolygonShape.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2PolygonShape.o -I. -Wno-unused 2023-09-08T22:05:15,005 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/b2BroadPhase.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2BroadPhase.o -I. -Wno-unused 2023-09-08T22:05:16,369 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/b2CollideCircle.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2CollideCircle.o -I. -Wno-unused 2023-09-08T22:05:17,680 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/b2CollideEdge.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2CollideEdge.o -I. -Wno-unused 2023-09-08T22:05:19,577 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/b2CollidePolygon.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2CollidePolygon.o -I. -Wno-unused 2023-09-08T22:05:21,084 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/b2Collision.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2Collision.o -I. -Wno-unused 2023-09-08T22:05:22,817 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/b2Distance.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2Distance.o -I. -Wno-unused 2023-09-08T22:05:24,631 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/b2DynamicTree.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2DynamicTree.o -I. -Wno-unused 2023-09-08T22:05:25,561 Box2D/Collision/b2DynamicTree.cpp: In constructor ‘b2DynamicTree::b2DynamicTree()’: 2023-09-08T22:05:25,562 Box2D/Collision/b2DynamicTree.cpp:32:15: warning: ‘void* memset(void*, int, size_t)’ clearing an object of non-trivial type ‘struct b2TreeNode’; use assignment or value-initialization instead [-Wclass-memaccess] 2023-09-08T22:05:25,562 32 | memset(m_nodes, 0, m_nodeCapacity * sizeof(b2TreeNode)); 2023-09-08T22:05:25,563 | ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-08T22:05:25,563 In file included from Box2D/Collision/b2DynamicTree.cpp:19: 2023-09-08T22:05:25,564 ./Box2D/Collision/b2DynamicTree.h:28:8: note: ‘struct b2TreeNode’ declared here 2023-09-08T22:05:25,565 28 | struct b2TreeNode 2023-09-08T22:05:25,565 | ^~~~~~~~~~ 2023-09-08T22:05:26,890 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Collision/b2TimeOfImpact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2TimeOfImpact.o -I. -Wno-unused 2023-09-08T22:05:28,918 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Common/b2BlockAllocator.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2BlockAllocator.o -I. -Wno-unused 2023-09-08T22:05:30,593 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Common/b2Draw.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2Draw.o -I. -Wno-unused 2023-09-08T22:05:32,663 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Common/b2Math.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2Math.o -I. -Wno-unused 2023-09-08T22:05:33,934 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Common/b2Settings.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2Settings.o -I. -Wno-unused 2023-09-08T22:05:35,035 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Common/b2StackAllocator.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2StackAllocator.o -I. -Wno-unused 2023-09-08T22:05:36,090 In file included from ./Box2D/Common/b2StackAllocator.h:22, 2023-09-08T22:05:36,090 from Box2D/Common/b2StackAllocator.cpp:19: 2023-09-08T22:05:36,091 Box2D/Common/b2StackAllocator.cpp: In destructor ‘b2StackAllocator::~b2StackAllocator()’: 2023-09-08T22:05:36,092 ./Box2D/Common/b2Settings.h:31:76: warning: ‘throw’ will always call ‘terminate’ [-Wterminate] 2023-09-08T22:05:36,092 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2023-09-08T22:05:36,093 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-08T22:05:36,094 Box2D/Common/b2StackAllocator.cpp:32:9: note: in expansion of macro ‘b2Assert’ 2023-09-08T22:05:36,095 32 | b2Assert(m_index == 0); 2023-09-08T22:05:36,096 | ^~~~~~~~ 2023-09-08T22:05:36,096 ./Box2D/Common/b2Settings.h:31:76: note: in C++11 destructors default to ‘noexcept’ 2023-09-08T22:05:36,097 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2023-09-08T22:05:36,097 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-08T22:05:36,098 Box2D/Common/b2StackAllocator.cpp:32:9: note: in expansion of macro ‘b2Assert’ 2023-09-08T22:05:36,098 32 | b2Assert(m_index == 0); 2023-09-08T22:05:36,099 | ^~~~~~~~ 2023-09-08T22:05:36,099 ./Box2D/Common/b2Settings.h:31:76: warning: ‘throw’ will always call ‘terminate’ [-Wterminate] 2023-09-08T22:05:36,099 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2023-09-08T22:05:36,100 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-08T22:05:36,100 Box2D/Common/b2StackAllocator.cpp:33:9: note: in expansion of macro ‘b2Assert’ 2023-09-08T22:05:36,101 33 | b2Assert(m_entryCount == 0); 2023-09-08T22:05:36,101 | ^~~~~~~~ 2023-09-08T22:05:36,102 ./Box2D/Common/b2Settings.h:31:76: note: in C++11 destructors default to ‘noexcept’ 2023-09-08T22:05:36,103 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2023-09-08T22:05:36,103 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-08T22:05:36,104 Box2D/Common/b2StackAllocator.cpp:33:9: note: in expansion of macro ‘b2Assert’ 2023-09-08T22:05:36,104 33 | b2Assert(m_entryCount == 0); 2023-09-08T22:05:36,105 | ^~~~~~~~ 2023-09-08T22:05:36,393 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Common/b2Timer.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2Timer.o -I. -Wno-unused 2023-09-08T22:05:37,489 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2ChainAndCircleContact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.o -I. -Wno-unused 2023-09-08T22:05:39,211 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.o -I. -Wno-unused 2023-09-08T22:05:40,941 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2CircleContact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2CircleContact.o -I. -Wno-unused 2023-09-08T22:05:42,653 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2Contact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2Contact.o -I. -Wno-unused 2023-09-08T22:05:44,705 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2ContactSolver.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2ContactSolver.o -I. -Wno-unused 2023-09-08T22:05:47,517 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.o -I. -Wno-unused 2023-09-08T22:05:49,244 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.o -I. -Wno-unused 2023-09-08T22:05:50,933 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.o -I. -Wno-unused 2023-09-08T22:05:52,631 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Contacts/b2PolygonContact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2PolygonContact.o -I. -Wno-unused 2023-09-08T22:05:54,332 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2DistanceJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2DistanceJoint.o -I. -Wno-unused 2023-09-08T22:05:56,350 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2FrictionJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2FrictionJoint.o -I. -Wno-unused 2023-09-08T22:05:58,309 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2GearJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2GearJoint.o -I. -Wno-unused 2023-09-08T22:06:00,542 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2Joint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2Joint.o -I. -Wno-unused 2023-09-08T22:06:02,422 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2MotorJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2MotorJoint.o -I. -Wno-unused 2023-09-08T22:06:04,419 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2MouseJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2MouseJoint.o -I. -Wno-unused 2023-09-08T22:06:06,353 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2PrismaticJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2PrismaticJoint.o -I. -Wno-unused 2023-09-08T22:06:08,822 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2PulleyJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2PulleyJoint.o -I. -Wno-unused 2023-09-08T22:06:10,971 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2RevoluteJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2RevoluteJoint.o -I. -Wno-unused 2023-09-08T22:06:13,269 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2RopeJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2RopeJoint.o -I. -Wno-unused 2023-09-08T22:06:15,232 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2WeldJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2WeldJoint.o -I. -Wno-unused 2023-09-08T22:06:17,317 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/Joints/b2WheelJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2WheelJoint.o -I. -Wno-unused 2023-09-08T22:06:19,451 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/b2Body.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2Body.o -I. -Wno-unused 2023-09-08T22:06:21,844 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/b2ContactManager.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2ContactManager.o -I. -Wno-unused 2023-09-08T22:06:24,373 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/b2Fixture.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2Fixture.o -I. -Wno-unused 2023-09-08T22:06:26,461 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/b2Island.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2Island.o -I. -Wno-unused 2023-09-08T22:06:28,751 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/b2World.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2World.o -I. -Wno-unused 2023-09-08T22:06:32,582 arm-linux-gnueabihf-gcc -Wsign-compare -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -g -fwrapv -O2 -fPIC -I/usr/include/python3.11 -c Box2D/Dynamics/b2WorldCallbacks.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2WorldCallbacks.o -I. -Wno-unused 2023-09-08T22:06:34,203 arm-linux-gnueabihf-g++ -shared -Wl,-O1 -Wl,-Bsymbolic-functions -g -fwrapv -O2 build/temp.linux-armv7l-cpython-311/Box2D/Box2D_wrap.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2ChainShape.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2CircleShape.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2EdgeShape.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2PolygonShape.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2BroadPhase.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2CollideCircle.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2CollideEdge.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2CollidePolygon.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2Collision.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2Distance.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2DynamicTree.o build/temp.linux-armv7l-cpython-311/Box2D/Collision/b2TimeOfImpact.o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2BlockAllocator.o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2Draw.o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2Math.o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2Settings.o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2StackAllocator.o build/temp.linux-armv7l-cpython-311/Box2D/Common/b2Timer.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2CircleContact.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2Contact.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2ContactSolver.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2PolygonContact.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2DistanceJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2FrictionJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2GearJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2Joint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2MotorJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2MouseJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2PrismaticJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2PulleyJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2RevoluteJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2RopeJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2WeldJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2WheelJoint.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2Body.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2ContactManager.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2Fixture.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2Island.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2World.o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/b2WorldCallbacks.o -L/usr/lib/arm-linux-gnueabihf -o build/lib.linux-armv7l-cpython-311/Box2D/_Box2D.cpython-311-arm-linux-gnueabihf.so 2023-09-08T22:06:35,008 /usr/local/lib/python3.11/dist-packages/setuptools/_distutils/cmd.py:66: SetuptoolsDeprecationWarning: setup.py install is deprecated. 2023-09-08T22:06:35,009 !! 2023-09-08T22:06:35,010 ******************************************************************************** 2023-09-08T22:06:35,010 Please avoid running ``setup.py`` directly. 2023-09-08T22:06:35,011 Instead, use pypa/build, pypa/installer or other 2023-09-08T22:06:35,012 standards-based tools. 2023-09-08T22:06:35,013 See https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html for details. 2023-09-08T22:06:35,013 ******************************************************************************** 2023-09-08T22:06:35,014 !! 2023-09-08T22:06:35,015 self.initialize_options() 2023-09-08T22:06:35,037 installing to build/bdist.linux-armv7l/wheel 2023-09-08T22:06:35,037 running install 2023-09-08T22:06:35,062 running install_lib 2023-09-08T22:06:35,092 creating build/bdist.linux-armv7l 2023-09-08T22:06:35,093 creating build/bdist.linux-armv7l/wheel 2023-09-08T22:06:35,095 creating build/bdist.linux-armv7l/wheel/Box2D 2023-09-08T22:06:35,097 copying build/lib.linux-armv7l-cpython-311/Box2D/_Box2D.cpython-311-arm-linux-gnueabihf.so -> build/bdist.linux-armv7l/wheel/Box2D 2023-09-08T22:06:35,195 creating build/bdist.linux-armv7l/wheel/Box2D/b2 2023-09-08T22:06:35,197 copying build/lib.linux-armv7l-cpython-311/Box2D/b2/__init__.py -> build/bdist.linux-armv7l/wheel/Box2D/b2 2023-09-08T22:06:35,199 copying build/lib.linux-armv7l-cpython-311/Box2D/Box2D.py -> build/bdist.linux-armv7l/wheel/Box2D 2023-09-08T22:06:35,206 copying build/lib.linux-armv7l-cpython-311/Box2D/__init__.py -> build/bdist.linux-armv7l/wheel/Box2D 2023-09-08T22:06:35,208 running install_egg_info 2023-09-08T22:06:35,271 running egg_info 2023-09-08T22:06:35,296 writing library/box2d_py.egg-info/PKG-INFO 2023-09-08T22:06:35,299 writing dependency_links to library/box2d_py.egg-info/dependency_links.txt 2023-09-08T22:06:35,301 writing top-level names to library/box2d_py.egg-info/top_level.txt 2023-09-08T22:06:35,338 reading manifest file 'library/box2d_py.egg-info/SOURCES.txt' 2023-09-08T22:06:35,387 reading manifest template 'MANIFEST.in' 2023-09-08T22:06:35,388 warning: no files found matching 'INSTALL' 2023-09-08T22:06:35,388 warning: no files found matching 'MANIFEST' 2023-09-08T22:06:35,389 warning: no files found matching 'README' 2023-09-08T22:06:35,389 warning: no files found matching 'distribute_setup.py' 2023-09-08T22:06:35,864 warning: no files found matching '*.py' under directory 'Box2D' 2023-09-08T22:06:36,084 warning: no files found matching '*.c' under directory 'Box2D' 2023-09-08T22:06:36,135 adding license file 'LICENSE' 2023-09-08T22:06:36,158 writing manifest file 'library/box2d_py.egg-info/SOURCES.txt' 2023-09-08T22:06:36,161 Copying library/box2d_py.egg-info to build/bdist.linux-armv7l/wheel/box2d_py-2.3.1-py3.11.egg-info 2023-09-08T22:06:36,171 running install_scripts 2023-09-08T22:06:36,231 creating build/bdist.linux-armv7l/wheel/box2d_py-2.3.1.dist-info/WHEEL 2023-09-08T22:06:36,233 creating '/tmp/pip-wheel-_mri9ku_/box2d_py-2.3.1-cp311-cp311-linux_armv7l.whl' and adding 'build/bdist.linux-armv7l/wheel' to it 2023-09-08T22:06:36,265 adding 'Box2D/Box2D.py' 2023-09-08T22:06:37,318 adding 'Box2D/_Box2D.cpython-311-arm-linux-gnueabihf.so' 2023-09-08T22:06:37,369 adding 'Box2D/__init__.py' 2023-09-08T22:06:37,371 adding 'Box2D/b2/__init__.py' 2023-09-08T22:06:37,373 adding 'box2d_py-2.3.1.dist-info/LICENSE' 2023-09-08T22:06:37,374 adding 'box2d_py-2.3.1.dist-info/METADATA' 2023-09-08T22:06:37,375 adding 'box2d_py-2.3.1.dist-info/WHEEL' 2023-09-08T22:06:37,376 adding 'box2d_py-2.3.1.dist-info/top_level.txt' 2023-09-08T22:06:37,377 adding 'box2d_py-2.3.1.dist-info/RECORD' 2023-09-08T22:06:37,402 removing build/bdist.linux-armv7l/wheel 2023-09-08T22:06:37,560 Building wheel for box2d-py (setup.py): finished with status 'done' 2023-09-08T22:06:37,590 Created wheel for box2d-py: filename=box2d_py-2.3.1-cp311-cp311-linux_armv7l.whl size=2264232 sha256=ac4c9d1a44d2a93fcc4c86aeda8776aa08a68e9d7ff1ca1cadf958806c3c27c1 2023-09-08T22:06:37,591 Stored in directory: /tmp/pip-ephem-wheel-cache-hb60qvne/wheels/7c/39/89/c270dd7d574a381f38e6b5cb2573c22f4e303bdb00db0d3440 2023-09-08T22:06:37,601 Successfully built box2d-py 2023-09-08T22:06:37,664 Removed build tracker: '/tmp/pip-build-tracker-2riw3syt'