2023-09-09T03:23:54,482 Created temporary directory: /tmp/pip-build-tracker-y8h5nyyd 2023-09-09T03:23:54,484 Initialized build tracking at /tmp/pip-build-tracker-y8h5nyyd 2023-09-09T03:23:54,484 Created build tracker: /tmp/pip-build-tracker-y8h5nyyd 2023-09-09T03:23:54,484 Entered build tracker: /tmp/pip-build-tracker-y8h5nyyd 2023-09-09T03:23:54,485 Created temporary directory: /tmp/pip-wheel-4_7xn8cl 2023-09-09T03:23:54,488 Created temporary directory: /tmp/pip-ephem-wheel-cache-bynfroql 2023-09-09T03:23:54,510 Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple 2023-09-09T03:23:54,514 2 location(s) to search for versions of box2d: 2023-09-09T03:23:54,514 * https://pypi.org/simple/box2d/ 2023-09-09T03:23:54,514 * https://www.piwheels.org/simple/box2d/ 2023-09-09T03:23:54,515 Fetching project page and analyzing links: https://pypi.org/simple/box2d/ 2023-09-09T03:23:54,516 Getting page https://pypi.org/simple/box2d/ 2023-09-09T03:23:54,517 Found index url https://pypi.org/simple/ 2023-09-09T03:23:54,736 Fetched page https://pypi.org/simple/box2d/ as application/vnd.pypi.simple.v1+json 2023-09-09T03:23:54,742 Skipping link: unsupported archive format: .egg: https://files.pythonhosted.org/packages/81/53/bb55e2c7b497e81f5ebbe44b6ce9012ecb5a99136e32f89025f1c6dfe499/Box2D-2.0.2b1-py2.4-linux-i686.egg (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,743 Skipping link: unsupported archive format: .egg: https://files.pythonhosted.org/packages/9b/c9/fd21043c6ac0a5c0fef3511980e6d32b395e9e7f64747954875b520efa00/Box2D-2.0.2b1-py2.5-linux-i686.egg (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,743 Skipping link: unsupported archive format: .egg: https://files.pythonhosted.org/packages/f2/4e/7c40b6361ddd04bfb2484b8eabfe31af70cd1b4c62f6cf4543f9b3a6911c/Box2D-2.0.2b1-py2.5-macosx-10.3-i386.egg (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,744 Skipping link: unsupported archive format: .egg: https://files.pythonhosted.org/packages/f2/10/251f58b16d2d7e97594d1684fb7d2bf97ea6fba5c93e06b2b0e2daaa9451/Box2D-2.0.2b1-py2.6-macosx-10.3-i386.egg (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,744 Skipping link: unsupported archive format: .exe: https://files.pythonhosted.org/packages/b2/66/a5c4566d2fa07387fd94a85718baee4002b4d23bd44b727db8e2fa1a47bc/Box2D-2.0.2b1.win32-py2.4.exe (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,745 Skipping link: unsupported archive format: .exe: https://files.pythonhosted.org/packages/f6/03/7f22c4be5d6d890bd37f21e9276ffb59d7fe5703e0aa7eea5429fa6f53fc/Box2D-2.0.2b1.win32-py2.5.exe (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,745 Skipping link: unsupported archive format: .exe: https://files.pythonhosted.org/packages/0c/14/98b10ef5261a9f496d39ffaad61a6c3d8c7049f29543f8a3b6280db3e4af/Box2D-2.0.2b1.win32-py2.6.exe (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,746 Found link https://files.pythonhosted.org/packages/ef/0b/2983c22dc78f47a82cc4dd765b148d0849dd1f482257f4b99ea2e455dc99/Box2D-2.0.2b1.zip (from https://pypi.org/simple/box2d/), version: 2.0.2b1 2023-09-09T03:23:54,747 Skipping link: unsupported archive format: .egg: https://files.pythonhosted.org/packages/11/39/88bfdc818f95f6187a26b3fddbebfdae179154a71b4bbcc770407eda9cb1/Box2D-2.3b0-py2.7-win32.egg (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,747 Skipping link: unsupported archive format: .exe: https://files.pythonhosted.org/packages/11/cb/e1d5458417e6025b67510789a25ff6af4a8d1a08ebe3bc0111fe7dbe1ad1/Box2D-2.3b0.win32-py2.7.exe (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,748 Found link https://files.pythonhosted.org/packages/7f/d1/6ba672ea28720869b64e2af8d273efb501642ddb80a8cede04db81599d58/Box2D-2.3b0.zip (from https://pypi.org/simple/box2d/), version: 2.3b0 2023-09-09T03:23:54,749 Found link https://files.pythonhosted.org/packages/cc/7b/ddb96fea1fa5b24f8929714ef483f64c33e9649e7aae066e5f5023ea426a/Box2D-2.3.2.tar.gz (from https://pypi.org/simple/box2d/), version: 2.3.2 2023-09-09T03:23:54,749 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/72/f6/5651732d411ab7786517e1ad1fda6c621306204c5e9d1b59355286e55e86/Box2D-2.3.10-cp27-cp27m-win32.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,750 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/52/4a/3e20a02957f48750efe0967c98908390ce911808925dd59218e75f7c0a28/Box2D-2.3.10-cp35-cp35m-macosx_10_6_intel.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,751 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/cb/92/c145fe96e5c47dbb3ab70bcd7ff9cc536aa617e5d294c3f467a1a1f303a7/Box2D-2.3.10-cp35-cp35m-manylinux1_i686.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,751 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/89/8e/524bac8b658db8a3a23bfa50df33123e3ab74eb98af1362ab279e1995879/Box2D-2.3.10-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,752 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/5d/a6/825cdbc0de7edb637328d95b9ac2793714e15900ba4a055df73d6f2590b7/Box2D-2.3.10-cp36-cp36m-macosx_10_9_x86_64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,752 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/1c/9e/da67ddb43f29634ee05b85bff5a1bf5f418c72169331b1abdc307ddadbe6/Box2D-2.3.10-cp36-cp36m-manylinux1_i686.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,753 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/a9/0b/d48d42dd9e19ce83a3fb4eee074e785b6c6ea612a2244dc2ef69427d338b/Box2D-2.3.10-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,753 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/30/7b/91ebadf3d7ffaf934781141e3b0dcdd97c8e9edac3653727647a6d3c4291/Box2D-2.3.10-cp36-cp36m-win32.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,754 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/10/30/c6a4b95df8f92e56efc4415f9331bf402c54899637b0c9f9de4c6badecc0/Box2D-2.3.10-cp36-cp36m-win_amd64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,754 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/bd/dc/0ce0b594ef0b54591ab8d87a501ad59e638bad34d664a58fd7a6ec780015/Box2D-2.3.10-cp37-cp37m-macosx_10_9_x86_64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,755 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/17/d4/d9748c9981791e5cfca3fc755e01078a496e0817e4196a6166c6a1a805d1/Box2D-2.3.10-cp37-cp37m-manylinux1_i686.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,755 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/22/1b/ce95bb5d1807d4d85af8d0c90050add1a77124459f8097791f0c39136d53/Box2D-2.3.10-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,756 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/7f/69/83eff7e98ff9cc1248976a8602d1b7729d0cf2c55932be82277b47f29fdf/Box2D-2.3.10-cp37-cp37m-win32.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,757 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/f0/fe/143cc8dcbee290eac1d7b89a6ce470de2f6569bc24a8de31c1b80a15957c/Box2D-2.3.10-cp37-cp37m-win_amd64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,757 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/73/04/c9bc6ccbf9126ef52510d717e9be48124f7db3b910cd39fe5b7394c3a7f8/Box2D-2.3.10-cp38-cp38-macosx_10_9_x86_64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,758 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/4e/9d/7f79ba35454c7ad907d2ba0548caad05dffb32db82760f19edeb2ec75de2/Box2D-2.3.10-cp38-cp38-manylinux1_i686.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,758 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/72/42/6a8e18a93f75c84fd065cc9b57a4117219fa3c5a002a80cab8f339883ec8/Box2D-2.3.10-cp38-cp38-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,759 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/ac/b8/7016a3b1ef7e3f9d8ec6da5a5e2d9fc04f69f36afb307cc5c641a48d11b9/Box2D-2.3.10-cp38-cp38-win32.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,760 Skipping link: No binaries permitted for box2d: https://files.pythonhosted.org/packages/6c/90/34166d73babf9010c06cf890c48c1155aec4d69125267e9777040e058ccd/Box2D-2.3.10-cp38-cp38-win_amd64.whl (from https://pypi.org/simple/box2d/) 2023-09-09T03:23:54,760 Fetching project page and analyzing links: https://www.piwheels.org/simple/box2d/ 2023-09-09T03:23:54,761 Getting page https://www.piwheels.org/simple/box2d/ 2023-09-09T03:23:54,762 Found index url https://www.piwheels.org/simple/ 2023-09-09T03:23:55,038 Fetched page https://www.piwheels.org/simple/box2d/ as text/html 2023-09-09T03:23:55,040 Skipping link: No binaries permitted for box2d: https://www.piwheels.org/simple/box2d/Box2D-2.3.2-cp39-cp39-linux_armv6l.whl#sha256=b02d25ac9d817f66f75f232f170a9ec44cd45abbb4cb72f192560cdc131271c5 (from https://www.piwheels.org/simple/box2d/) 2023-09-09T03:23:55,041 Skipping link: No binaries permitted for box2d: https://www.piwheels.org/simple/box2d/Box2D-2.3.2-cp39-cp39-linux_armv7l.whl#sha256=b02d25ac9d817f66f75f232f170a9ec44cd45abbb4cb72f192560cdc131271c5 (from https://www.piwheels.org/simple/box2d/) 2023-09-09T03:23:55,041 Skipping link: not a file: https://www.piwheels.org/simple/box2d/ 2023-09-09T03:23:55,042 Skipping link: not a file: https://pypi.org/simple/box2d/ 2023-09-09T03:23:55,061 Given no hashes to check 1 links for project 'box2d': discarding no candidates 2023-09-09T03:23:55,079 Collecting box2d==2.3.2 2023-09-09T03:23:55,081 Created temporary directory: /tmp/pip-unpack-4p3nerpe 2023-09-09T03:23:55,218 Downloading Box2D-2.3.2.tar.gz (427 kB) 2023-09-09T03:23:55,942 Added box2d==2.3.2 from https://files.pythonhosted.org/packages/cc/7b/ddb96fea1fa5b24f8929714ef483f64c33e9649e7aae066e5f5023ea426a/Box2D-2.3.2.tar.gz to build tracker '/tmp/pip-build-tracker-y8h5nyyd' 2023-09-09T03:23:55,944 Running setup.py (path:/tmp/pip-wheel-4_7xn8cl/box2d_4070c9aa46b24aec8a9c9881f98fd359/setup.py) egg_info for package box2d 2023-09-09T03:23:55,945 Created temporary directory: /tmp/pip-pip-egg-info-unptzlw4 2023-09-09T03:23:55,946 Preparing metadata (setup.py): started 2023-09-09T03:23:55,947 Running command python setup.py egg_info 2023-09-09T03:23:56,471 Using setuptools (version 68.1.2). 2023-09-09T03:23:56,472 running egg_info 2023-09-09T03:23:56,475 creating /tmp/pip-pip-egg-info-unptzlw4/Box2D.egg-info 2023-09-09T03:23:56,493 writing /tmp/pip-pip-egg-info-unptzlw4/Box2D.egg-info/PKG-INFO 2023-09-09T03:23:56,495 writing dependency_links to /tmp/pip-pip-egg-info-unptzlw4/Box2D.egg-info/dependency_links.txt 2023-09-09T03:23:56,497 writing top-level names to /tmp/pip-pip-egg-info-unptzlw4/Box2D.egg-info/top_level.txt 2023-09-09T03:23:56,499 writing manifest file '/tmp/pip-pip-egg-info-unptzlw4/Box2D.egg-info/SOURCES.txt' 2023-09-09T03:23:56,585 reading manifest file '/tmp/pip-pip-egg-info-unptzlw4/Box2D.egg-info/SOURCES.txt' 2023-09-09T03:23:56,586 reading manifest template 'MANIFEST.in' 2023-09-09T03:23:56,588 warning: no files found matching 'INSTALL' 2023-09-09T03:23:56,589 warning: no files found matching 'MANIFEST' 2023-09-09T03:23:56,590 warning: no files found matching 'README' 2023-09-09T03:23:56,591 warning: no files found matching 'distribute_setup.py' 2023-09-09T03:23:57,043 warning: no files found matching '*.py' under directory 'Box2D' 2023-09-09T03:23:57,236 warning: no files found matching '*.c' under directory 'Box2D' 2023-09-09T03:23:57,289 adding license file 'LICENSE' 2023-09-09T03:23:57,301 writing manifest file '/tmp/pip-pip-egg-info-unptzlw4/Box2D.egg-info/SOURCES.txt' 2023-09-09T03:23:57,380 Preparing metadata (setup.py): finished with status 'done' 2023-09-09T03:23:57,384 Source in /tmp/pip-wheel-4_7xn8cl/box2d_4070c9aa46b24aec8a9c9881f98fd359 has version 2.3.2, which satisfies requirement box2d==2.3.2 from https://files.pythonhosted.org/packages/cc/7b/ddb96fea1fa5b24f8929714ef483f64c33e9649e7aae066e5f5023ea426a/Box2D-2.3.2.tar.gz 2023-09-09T03:23:57,386 Removed box2d==2.3.2 from https://files.pythonhosted.org/packages/cc/7b/ddb96fea1fa5b24f8929714ef483f64c33e9649e7aae066e5f5023ea426a/Box2D-2.3.2.tar.gz from build tracker '/tmp/pip-build-tracker-y8h5nyyd' 2023-09-09T03:23:57,390 Created temporary directory: /tmp/pip-unpack-6j8wcidh 2023-09-09T03:23:57,392 Created temporary directory: /tmp/pip-unpack-tttnwlor 2023-09-09T03:23:57,395 Building wheels for collected packages: box2d 2023-09-09T03:23:57,399 Created temporary directory: /tmp/pip-wheel-x_0_gwee 2023-09-09T03:23:57,399 Building wheel for box2d (setup.py): started 2023-09-09T03:23:57,400 Destination directory: /tmp/pip-wheel-x_0_gwee 2023-09-09T03:23:57,401 Running command python setup.py bdist_wheel 2023-09-09T03:23:57,800 Using setuptools (version 68.1.2). 2023-09-09T03:23:58,130 running bdist_wheel 2023-09-09T03:23:58,211 running build 2023-09-09T03:23:58,211 running build_py 2023-09-09T03:23:58,231 creating build 2023-09-09T03:23:58,232 creating build/lib.linux-armv7l-cpython-311 2023-09-09T03:23:58,232 creating build/lib.linux-armv7l-cpython-311/Box2D 2023-09-09T03:23:58,234 copying library/Box2D/__init__.py -> build/lib.linux-armv7l-cpython-311/Box2D 2023-09-09T03:23:58,235 copying library/Box2D/Box2D.py -> build/lib.linux-armv7l-cpython-311/Box2D 2023-09-09T03:23:58,243 creating build/lib.linux-armv7l-cpython-311/Box2D/b2 2023-09-09T03:23:58,244 copying library/Box2D/b2/__init__.py -> build/lib.linux-armv7l-cpython-311/Box2D/b2 2023-09-09T03:23:58,246 running build_ext 2023-09-09T03:23:58,253 building 'Box2D._Box2D' extension 2023-09-09T03:23:58,253 swigging Box2D/Box2D.i to Box2D/Box2D_wrap.cpp 2023-09-09T03:23:58,254 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-09T03:23:58,846 Box2D/Common/b2Math.h:67: Warning 302: Identifier 'b2Vec2' redefined by %extend (ignored), 2023-09-09T03:23:58,847 Box2D/Box2D_math.i:47: Warning 302: %extend definition of 'b2Vec2'. 2023-09-09T03:23:58,852 Box2D/Common/b2Math.h:158: Warning 302: Identifier 'b2Vec3' redefined by %extend (ignored), 2023-09-09T03:23:58,853 Box2D/Box2D_math.i:168: Warning 302: %extend definition of 'b2Vec3'. 2023-09-09T03:23:58,858 Box2D/Common/b2Math.h:197: Warning 302: Identifier 'b2Mat22' redefined by %extend (ignored), 2023-09-09T03:23:58,859 Box2D/Box2D_math.i:301: Warning 302: %extend definition of 'b2Mat22'. 2023-09-09T03:23:58,864 Box2D/Common/b2Math.h:271: Warning 302: Identifier 'b2Mat33' redefined by %extend (ignored), 2023-09-09T03:23:58,865 Box2D/Box2D_math.i:372: Warning 302: %extend definition of 'b2Mat33'. 2023-09-09T03:23:59,047 Box2D/Collision/b2DynamicTree.h:44: Warning 312: Nested union not currently supported (ignored). 2023-09-09T03:23:59,775 Box2D/Common/b2Settings.h:144: Warning 506: Can't wrap varargs with keyword arguments enabled 2023-09-09T03:23:59,825 Box2D/Common/b2Math.h:91: Warning 509: Overloaded method b2Vec2::operator ()(int32) effectively ignored, 2023-09-09T03:23:59,826 Box2D/Common/b2Math.h:85: Warning 509: as it is shadowed by b2Vec2::operator ()(int32) const. 2023-09-09T03:24:04,219 creating build/temp.linux-armv7l-cpython-311 2023-09-09T03:24:04,219 creating build/temp.linux-armv7l-cpython-311/Box2D 2023-09-09T03:24:04,220 creating build/temp.linux-armv7l-cpython-311/Box2D/Collision 2023-09-09T03:24:04,221 creating build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes 2023-09-09T03:24:04,222 creating build/temp.linux-armv7l-cpython-311/Box2D/Common 2023-09-09T03:24:04,223 creating build/temp.linux-armv7l-cpython-311/Box2D/Dynamics 2023-09-09T03:24:04,224 creating build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts 2023-09-09T03:24:04,224 creating build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints 2023-09-09T03:24:04,225 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-09T03:24:07,123 Box2D/Box2D_wrap.cpp: In function ‘PyObject* b2GetPointStates(const b2Manifold*, const b2Manifold*)’: 2023-09-09T03:24:07,124 Box2D/Box2D_wrap.cpp:4109:13: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,124 4109 | if (state1[i]==b2_nullState && state1_length==0) 2023-09-09T03:24:07,125 | ^~ 2023-09-09T03:24:07,125 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-09T03:24:07,126 4111 | if (state2_length > -1) 2023-09-09T03:24:07,126 | ^~ 2023-09-09T03:24:07,127 Box2D/Box2D_wrap.cpp:4113:13: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,128 4113 | if (state2[i]==b2_nullState && state2_length==0) 2023-09-09T03:24:07,128 | ^~ 2023-09-09T03:24:07,129 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-09T03:24:07,129 4115 | if (state1_length > -1) 2023-09-09T03:24:07,130 | ^~ 2023-09-09T03:24:07,314 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Random__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,315 Box2D/Box2D_wrap.cpp:5656:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,316 5656 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-09T03:24:07,316 | ^~ 2023-09-09T03:24:07,317 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-09T03:24:07,317 5656 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-09T03:24:07,318 | ^~~~~~ 2023-09-09T03:24:07,319 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Random(PyObject*, PyObject*)’: 2023-09-09T03:24:07,319 Box2D/Box2D_wrap.cpp:5664:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,320 5664 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Random", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,321 | ^~ 2023-09-09T03:24:07,321 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-09T03:24:07,322 5664 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Random", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,322 | ^~ 2023-09-09T03:24:07,323 Box2D/Box2D_wrap.cpp:5667:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,324 5667 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,324 | ^~ 2023-09-09T03:24:07,325 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-09T03:24:07,325 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,326 | ^~~~ 2023-09-09T03:24:07,327 Box2D/Box2D_wrap.cpp:5667:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,327 5667 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,328 | ^~~~~~~~~ 2023-09-09T03:24:07,330 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Distance__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,330 Box2D/Box2D_wrap.cpp:5704:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,331 5704 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-09T03:24:07,332 | ^~ 2023-09-09T03:24:07,332 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-09T03:24:07,333 5704 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-09T03:24:07,334 | ^~~~ 2023-09-09T03:24:07,334 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Distance(PyObject*, PyObject*)’: 2023-09-09T03:24:07,335 Box2D/Box2D_wrap.cpp:5712:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,335 5712 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2Distance", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:07,336 | ^~ 2023-09-09T03:24:07,336 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-09T03:24:07,337 5712 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2Distance", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:07,337 | ^~ 2023-09-09T03:24:07,338 Box2D/Box2D_wrap.cpp:5715:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,339 5715 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,339 | ^~ 2023-09-09T03:24:07,340 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-09T03:24:07,341 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,341 | ^~~~ 2023-09-09T03:24:07,342 Box2D/Box2D_wrap.cpp:5715:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,342 5715 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,343 | ^~~~~~~~~ 2023-09-09T03:24:07,344 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_fixtureA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,345 Box2D/Box2D_wrap.cpp:5758:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,346 5758 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,346 | ^~ 2023-09-09T03:24:07,347 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-09T03:24:07,348 5758 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,348 | ^~~~~~~~ 2023-09-09T03:24:07,349 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_fixtureB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,349 Box2D/Box2D_wrap.cpp:5776:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,350 5776 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,351 | ^~ 2023-09-09T03:24:07,351 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-09T03:24:07,352 5776 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,352 | ^~~~~~~~ 2023-09-09T03:24:07,354 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_normal_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,355 Box2D/Box2D_wrap.cpp:5799:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,356 5799 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,356 | ^~ 2023-09-09T03:24:07,357 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-09T03:24:07,357 5799 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,358 | ^~~~~~~~ 2023-09-09T03:24:07,360 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_position_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,360 Box2D/Box2D_wrap.cpp:5822:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,361 5822 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,362 | ^~ 2023-09-09T03:24:07,362 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-09T03:24:07,363 5822 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,364 | ^~~~~~~~ 2023-09-09T03:24:07,364 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint_state_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,365 Box2D/Box2D_wrap.cpp:5838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,365 5838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,366 | ^~ 2023-09-09T03:24:07,367 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-09T03:24:07,367 5838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,368 | ^~~~~~~~ 2023-09-09T03:24:07,368 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactPoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:07,369 Box2D/Box2D_wrap.cpp:5845:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,370 5845 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,370 | ^~ 2023-09-09T03:24:07,371 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-09T03:24:07,372 5845 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactPoint, 0 | 0 ); 2023-09-09T03:24:07,372 | ^~~~~~~~ 2023-09-09T03:24:07,374 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2TimeOfImpact__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,375 Box2D/Box2D_wrap.cpp:5893:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,375 5893 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:07,376 | ^~ 2023-09-09T03:24:07,377 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-09T03:24:07,377 5893 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:07,377 | ^~~~ 2023-09-09T03:24:07,378 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2TimeOfImpact(PyObject*, PyObject*)’: 2023-09-09T03:24:07,378 Box2D/Box2D_wrap.cpp:5901:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,379 5901 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2TimeOfImpact", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:07,379 | ^~ 2023-09-09T03:24:07,380 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-09T03:24:07,380 5901 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2TimeOfImpact", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:07,381 | ^~ 2023-09-09T03:24:07,381 Box2D/Box2D_wrap.cpp:5903:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,382 5903 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 7) { 2023-09-09T03:24:07,383 | ^~ 2023-09-09T03:24:07,383 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-09T03:24:07,384 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,385 | ^~~~ 2023-09-09T03:24:07,385 Box2D/Box2D_wrap.cpp:5903:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,386 5903 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 7) { 2023-09-09T03:24:07,386 | ^~~~~~~~~ 2023-09-09T03:24:07,387 Box2D/Box2D_wrap.cpp:5905:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,388 5905 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,388 | ^~ 2023-09-09T03:24:07,389 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-09T03:24:07,389 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,390 | ^~~~ 2023-09-09T03:24:07,391 Box2D/Box2D_wrap.cpp:5905:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,391 5905 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,392 | ^~~~~~~~~ 2023-09-09T03:24:07,393 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AssertException___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:07,393 Box2D/Box2D_wrap.cpp:5911:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,394 5911 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AssertException, 0 | 0 ); 2023-09-09T03:24:07,394 | ^~ 2023-09-09T03:24:07,395 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-09T03:24:07,396 5911 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AssertException, 0 | 0 ); 2023-09-09T03:24:07,396 | ^~~~~~~~ 2023-09-09T03:24:07,397 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2AssertException(PyObject*, PyObject*)’: 2023-09-09T03:24:07,397 Box2D/Box2D_wrap.cpp:5925:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,398 5925 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:07,398 | ^~ 2023-09-09T03:24:07,399 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-09T03:24:07,399 5925 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:07,400 | ^~~~~~~~ 2023-09-09T03:24:07,401 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Alloc(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,401 Box2D/Box2D_wrap.cpp:5943:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,401 5943 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Alloc", kwnames, &obj0)) SWIG_fail; ecode1 = SWIG_AsVal_int(obj0, &val1); 2023-09-09T03:24:07,402 | ^~ 2023-09-09T03:24:07,402 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-09T03:24:07,403 5943 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Alloc", kwnames, &obj0)) SWIG_fail; ecode1 = SWIG_AsVal_int(obj0, &val1); 2023-09-09T03:24:07,404 | ^~~~~~ 2023-09-09T03:24:07,404 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Free(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,405 Box2D/Box2D_wrap.cpp:5951:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,405 5951 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Free", kwnames, &obj0)) SWIG_fail; { arg1 = obj0; 2023-09-09T03:24:07,406 | ^~ 2023-09-09T03:24:07,406 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-09T03:24:07,407 5951 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Free", kwnames, &obj0)) SWIG_fail; { arg1 = obj0; 2023-09-09T03:24:07,408 | ^ 2023-09-09T03:24:07,408 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_major_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,409 Box2D/Box2D_wrap.cpp:5974:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,409 5974 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-09T03:24:07,410 | ^~ 2023-09-09T03:24:07,410 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-09T03:24:07,411 5974 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-09T03:24:07,412 | ^~~~~~~~ 2023-09-09T03:24:07,412 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_minor_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,413 Box2D/Box2D_wrap.cpp:5990:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,413 5990 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-09T03:24:07,414 | ^~ 2023-09-09T03:24:07,415 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-09T03:24:07,415 5990 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-09T03:24:07,416 | ^~~~~~~~ 2023-09-09T03:24:07,416 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_revision_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,417 Box2D/Box2D_wrap.cpp:6006:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,417 6006 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-09T03:24:07,418 | ^~ 2023-09-09T03:24:07,418 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-09T03:24:07,419 6006 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-09T03:24:07,420 | ^~~~~~~~ 2023-09-09T03:24:07,420 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:07,421 Box2D/Box2D_wrap.cpp:6013:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,421 6013 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-09T03:24:07,422 | ^~ 2023-09-09T03:24:07,423 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-09T03:24:07,423 6013 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2023-09-09T03:24:07,424 | ^~~~~~~~ 2023-09-09T03:24:07,424 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Version(PyObject*, PyObject*)’: 2023-09-09T03:24:07,425 Box2D/Box2D_wrap.cpp:6020:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,426 6020 | if (!SWIG_Python_UnpackTuple(args, "new_b2Version", 0, 0, 0)) SWIG_fail; { try { result = (b2Version *)new b2Version(); } 2023-09-09T03:24:07,426 | ^~ 2023-09-09T03:24:07,427 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-09T03:24:07,428 6020 | if (!SWIG_Python_UnpackTuple(args, "new_b2Version", 0, 0, 0)) SWIG_fail; { try { result = (b2Version *)new b2Version(); } 2023-09-09T03:24:07,428 | ^ 2023-09-09T03:24:07,429 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec2__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,429 Box2D/Box2D_wrap.cpp:6068:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,430 6068 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-09T03:24:07,431 | ^~ 2023-09-09T03:24:07,431 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-09T03:24:07,432 6068 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-09T03:24:07,433 | ^~~~~~ 2023-09-09T03:24:07,433 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_Set(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,434 Box2D/Box2D_wrap.cpp:6086:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,435 6086 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2_Set", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:07,435 | ^~ 2023-09-09T03:24:07,436 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-09T03:24:07,436 6086 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2_Set", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:07,437 | ^ 2023-09-09T03:24:07,437 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___call____SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,438 Box2D/Box2D_wrap.cpp:6105:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,438 6105 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-09T03:24:07,439 | ^~ 2023-09-09T03:24:07,439 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-09T03:24:07,440 6105 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-09T03:24:07,441 | ^ 2023-09-09T03:24:07,441 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___call____SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,442 Box2D/Box2D_wrap.cpp:6115:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,442 6115 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-09T03:24:07,443 | ^~ 2023-09-09T03:24:07,443 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-09T03:24:07,444 6115 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-09T03:24:07,444 | ^ 2023-09-09T03:24:07,445 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___call__(PyObject*, PyObject*)’: 2023-09-09T03:24:07,446 Box2D/Box2D_wrap.cpp:6124:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,446 6124 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2___call__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:07,447 | ^~ 2023-09-09T03:24:07,447 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-09T03:24:07,448 6124 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2___call__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:07,449 | ^~ 2023-09-09T03:24:07,449 Box2D/Box2D_wrap.cpp:6126:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,450 6126 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-09T03:24:07,450 | ^~ 2023-09-09T03:24:07,451 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-09T03:24:07,452 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,452 | ^~~~ 2023-09-09T03:24:07,453 Box2D/Box2D_wrap.cpp:6126:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,454 6126 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-09T03:24:07,454 | ^~~~~~~~~ 2023-09-09T03:24:07,455 Box2D/Box2D_wrap.cpp:6128:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,456 6128 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,456 | ^~ 2023-09-09T03:24:07,457 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-09T03:24:07,457 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,458 | ^~~~ 2023-09-09T03:24:07,458 Box2D/Box2D_wrap.cpp:6128:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,459 6128 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,459 | ^~~~~~~~~ 2023-09-09T03:24:07,460 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___add_vector(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,460 Box2D/Box2D_wrap.cpp:6134:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,461 6134 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,461 | ^~ 2023-09-09T03:24:07,462 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-09T03:24:07,463 6134 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,463 | ^ 2023-09-09T03:24:07,464 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___sub_vector(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,465 Box2D/Box2D_wrap.cpp:6151:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,465 6151 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,466 | ^~ 2023-09-09T03:24:07,467 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-09T03:24:07,467 6151 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,468 | ^ 2023-09-09T03:24:07,469 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___mul_float(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,469 Box2D/Box2D_wrap.cpp:6168:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,470 6168 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,470 | ^~ 2023-09-09T03:24:07,471 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-09T03:24:07,472 6168 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,473 | ^ 2023-09-09T03:24:07,473 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_x_set(PyObject*, PyObject*)’: 2023-09-09T03:24:07,474 Box2D/Box2D_wrap.cpp:6211:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,475 6211 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_x_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,475 | ^~ 2023-09-09T03:24:07,476 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-09T03:24:07,477 6211 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_x_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,477 | ^ 2023-09-09T03:24:07,478 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_y_set(PyObject*, PyObject*)’: 2023-09-09T03:24:07,478 Box2D/Box2D_wrap.cpp:6226:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,479 6226 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_y_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,479 | ^~ 2023-09-09T03:24:07,480 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-09T03:24:07,480 6226 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_y_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,481 | ^ 2023-09-09T03:24:07,481 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec2(PyObject*, PyObject*)’: 2023-09-09T03:24:07,482 Box2D/Box2D_wrap.cpp:6265:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,482 6265 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec2", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,483 | ^~ 2023-09-09T03:24:07,483 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-09T03:24:07,484 6265 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec2", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,485 | ^~ 2023-09-09T03:24:07,485 Box2D/Box2D_wrap.cpp:6268:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,486 6268 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-09T03:24:07,487 | ^~ 2023-09-09T03:24:07,487 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-09T03:24:07,488 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,489 | ^~~~ 2023-09-09T03:24:07,490 Box2D/Box2D_wrap.cpp:6268:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,490 6268 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-09T03:24:07,491 | ^~~~~~~~~ 2023-09-09T03:24:07,492 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_cross__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,492 Box2D/Box2D_wrap.cpp:6276:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,493 6276 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-09T03:24:07,494 | ^~ 2023-09-09T03:24:07,494 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-09T03:24:07,495 6276 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2023-09-09T03:24:07,496 | ^ 2023-09-09T03:24:07,497 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_cross(PyObject*, PyObject*)’: 2023-09-09T03:24:07,497 Box2D/Box2D_wrap.cpp:6302:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,498 6302 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2_cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-09T03:24:07,499 | ^~ 2023-09-09T03:24:07,499 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-09T03:24:07,500 6302 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2_cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-09T03:24:07,501 | ^~ 2023-09-09T03:24:07,501 Box2D/Box2D_wrap.cpp:6304:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,502 6304 | if (!_v) goto check_1; return _wrap_b2Vec2_cross__SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-09T03:24:07,503 | ^~ 2023-09-09T03:24:07,503 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-09T03:24:07,504 6304 | if (!_v) goto check_1; return _wrap_b2Vec2_cross__SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-09T03:24:07,505 | ^~~~~~ 2023-09-09T03:24:07,505 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___getitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,506 Box2D/Box2D_wrap.cpp:6312:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,507 6312 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,507 | ^~ 2023-09-09T03:24:07,508 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-09T03:24:07,509 6312 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,509 | ^ 2023-09-09T03:24:07,510 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___setitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,511 Box2D/Box2D_wrap.cpp:6324:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,511 6324 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:07,512 | ^~ 2023-09-09T03:24:07,513 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-09T03:24:07,513 6324 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:07,514 | ^ 2023-09-09T03:24:07,515 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___equ(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,515 Box2D/Box2D_wrap.cpp:6336:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,516 6336 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,517 | ^~ 2023-09-09T03:24:07,517 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-09T03:24:07,518 6336 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,519 | ^ 2023-09-09T03:24:07,519 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_dot(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,520 Box2D/Box2D_wrap.cpp:6353:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,521 6353 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2_dot", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,521 | ^~ 2023-09-09T03:24:07,522 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-09T03:24:07,522 6353 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2_dot", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,523 | ^ 2023-09-09T03:24:07,524 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___truediv__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,524 Box2D/Box2D_wrap.cpp:6370:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,525 6370 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,525 | ^~ 2023-09-09T03:24:07,526 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-09T03:24:07,526 6370 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,527 | ^ 2023-09-09T03:24:07,527 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___div__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,528 Box2D/Box2D_wrap.cpp:6382:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,529 6382 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,529 | ^~ 2023-09-09T03:24:07,530 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-09T03:24:07,530 6382 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,531 | ^ 2023-09-09T03:24:07,532 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___mul__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,533 Box2D/Box2D_wrap.cpp:6394:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,533 6394 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,534 | ^~ 2023-09-09T03:24:07,535 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-09T03:24:07,536 6394 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,536 | ^ 2023-09-09T03:24:07,537 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___add__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,538 Box2D/Box2D_wrap.cpp:6406:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,538 6406 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,539 | ^~ 2023-09-09T03:24:07,540 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-09T03:24:07,540 6406 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,541 | ^ 2023-09-09T03:24:07,542 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___sub__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,542 Box2D/Box2D_wrap.cpp:6424:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,543 6424 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,543 | ^~ 2023-09-09T03:24:07,544 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-09T03:24:07,544 6424 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,545 | ^ 2023-09-09T03:24:07,545 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___rmul__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,546 Box2D/Box2D_wrap.cpp:6442:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,547 6442 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,547 | ^~ 2023-09-09T03:24:07,548 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-09T03:24:07,548 6442 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,549 | ^ 2023-09-09T03:24:07,550 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___rdiv__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,551 Box2D/Box2D_wrap.cpp:6454:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,551 6454 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,552 | ^~ 2023-09-09T03:24:07,552 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-09T03:24:07,553 6454 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,554 | ^ 2023-09-09T03:24:07,554 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___div_float(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,555 Box2D/Box2D_wrap.cpp:6466:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,556 6466 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,556 | ^~ 2023-09-09T03:24:07,557 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-09T03:24:07,557 6466 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,558 | ^ 2023-09-09T03:24:07,559 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_Set(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,559 Box2D/Box2D_wrap.cpp:6513:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,560 6513 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Vec3_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2023-09-09T03:24:07,561 | ^~ 2023-09-09T03:24:07,562 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-09T03:24:07,562 6513 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Vec3_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2023-09-09T03:24:07,563 | ^ 2023-09-09T03:24:07,563 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___add_vector(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,564 Box2D/Box2D_wrap.cpp:6535:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,564 6535 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,565 | ^~ 2023-09-09T03:24:07,566 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-09T03:24:07,566 6535 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,567 | ^ 2023-09-09T03:24:07,567 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___sub_vector(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,568 Box2D/Box2D_wrap.cpp:6553:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,568 6553 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,569 | ^~ 2023-09-09T03:24:07,570 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-09T03:24:07,570 6553 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,571 | ^ 2023-09-09T03:24:07,572 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___mul_float(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,573 Box2D/Box2D_wrap.cpp:6571:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,573 6571 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,574 | ^~ 2023-09-09T03:24:07,575 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-09T03:24:07,575 6571 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,576 | ^ 2023-09-09T03:24:07,576 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_x_set(PyObject*, PyObject*)’: 2023-09-09T03:24:07,577 Box2D/Box2D_wrap.cpp:6580:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,578 6580 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_x_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,578 | ^~ 2023-09-09T03:24:07,579 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-09T03:24:07,580 6580 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_x_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,581 | ^ 2023-09-09T03:24:07,581 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_y_set(PyObject*, PyObject*)’: 2023-09-09T03:24:07,582 Box2D/Box2D_wrap.cpp:6595:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,582 6595 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_y_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,583 | ^~ 2023-09-09T03:24:07,583 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-09T03:24:07,584 6595 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_y_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,585 | ^ 2023-09-09T03:24:07,585 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_z_set(PyObject*, PyObject*)’: 2023-09-09T03:24:07,586 Box2D/Box2D_wrap.cpp:6610:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,586 6610 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_z_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,587 | ^~ 2023-09-09T03:24:07,587 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-09T03:24:07,588 6610 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_z_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:07,588 | ^ 2023-09-09T03:24:07,589 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec3(PyObject*, PyObject*)’: 2023-09-09T03:24:07,589 Box2D/Box2D_wrap.cpp:6664:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,590 6664 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec3", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,591 | ^~ 2023-09-09T03:24:07,591 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-09T03:24:07,592 6664 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec3", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,592 | ^~ 2023-09-09T03:24:07,593 Box2D/Box2D_wrap.cpp:6671:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,594 6671 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,594 | ^~ 2023-09-09T03:24:07,595 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-09T03:24:07,595 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,596 | ^~~~ 2023-09-09T03:24:07,597 Box2D/Box2D_wrap.cpp:6671:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,597 6671 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,598 | ^~~~~~~~~ 2023-09-09T03:24:07,599 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_cross(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,599 Box2D/Box2D_wrap.cpp:6678:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,600 6678 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3_cross", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,600 | ^~ 2023-09-09T03:24:07,601 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-09T03:24:07,602 6678 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3_cross", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,603 | ^ 2023-09-09T03:24:07,603 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___getitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,604 Box2D/Box2D_wrap.cpp:6697:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,605 6697 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,605 | ^~ 2023-09-09T03:24:07,606 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-09T03:24:07,606 6697 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,607 | ^ 2023-09-09T03:24:07,607 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___setitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,608 Box2D/Box2D_wrap.cpp:6709:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,608 6709 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec3___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:07,609 | ^~ 2023-09-09T03:24:07,609 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-09T03:24:07,610 6709 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec3___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:07,611 | ^ 2023-09-09T03:24:07,611 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___truediv__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,612 Box2D/Box2D_wrap.cpp:6740:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,613 6740 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,613 | ^~ 2023-09-09T03:24:07,614 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-09T03:24:07,614 6740 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,615 | ^ 2023-09-09T03:24:07,616 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___div__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,616 Box2D/Box2D_wrap.cpp:6752:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,617 6752 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,618 | ^~ 2023-09-09T03:24:07,618 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-09T03:24:07,619 6752 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,620 | ^ 2023-09-09T03:24:07,620 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___mul__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,621 Box2D/Box2D_wrap.cpp:6764:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,622 6764 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,623 | ^~ 2023-09-09T03:24:07,623 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-09T03:24:07,624 6764 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,624 | ^ 2023-09-09T03:24:07,625 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___add__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,625 Box2D/Box2D_wrap.cpp:6776:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,626 6776 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,626 | ^~ 2023-09-09T03:24:07,627 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-09T03:24:07,627 6776 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,628 | ^ 2023-09-09T03:24:07,628 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___sub__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,629 Box2D/Box2D_wrap.cpp:6795:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,630 6795 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,630 | ^~ 2023-09-09T03:24:07,631 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-09T03:24:07,632 6795 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,632 | ^ 2023-09-09T03:24:07,633 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___rmul__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,634 Box2D/Box2D_wrap.cpp:6814:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,635 6814 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,635 | ^~ 2023-09-09T03:24:07,636 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-09T03:24:07,637 6814 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,638 | ^ 2023-09-09T03:24:07,638 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___rdiv__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,639 Box2D/Box2D_wrap.cpp:6826:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,640 6826 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,640 | ^~ 2023-09-09T03:24:07,641 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-09T03:24:07,642 6826 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,643 | ^ 2023-09-09T03:24:07,644 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___div_float(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,644 Box2D/Box2D_wrap.cpp:6838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,645 6838 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,645 | ^~ 2023-09-09T03:24:07,646 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-09T03:24:07,646 6838 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,647 | ^ 2023-09-09T03:24:07,647 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat22__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,648 Box2D/Box2D_wrap.cpp:6864:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,648 6864 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2023-09-09T03:24:07,649 | ^~ 2023-09-09T03:24:07,649 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-09T03:24:07,650 6864 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2023-09-09T03:24:07,651 | ^ 2023-09-09T03:24:07,661 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___GetInverse(PyObject*, PyObject*)’: 2023-09-09T03:24:07,662 Box2D/Box2D_wrap.cpp:6940:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,662 6940 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-09T03:24:07,663 | ^~ 2023-09-09T03:24:07,664 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-09T03:24:07,665 6940 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-09T03:24:07,665 | ^~~~~~~~ 2023-09-09T03:24:07,671 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22_col1_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,672 Box2D/Box2D_wrap.cpp:6982:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,673 6982 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-09T03:24:07,674 | ^~ 2023-09-09T03:24:07,674 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-09T03:24:07,675 6982 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-09T03:24:07,676 | ^~~~~~~~ 2023-09-09T03:24:07,678 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22_col2_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,678 Box2D/Box2D_wrap.cpp:7004:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,679 7004 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-09T03:24:07,680 | ^~ 2023-09-09T03:24:07,680 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-09T03:24:07,681 7004 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2023-09-09T03:24:07,682 | ^~~~~~~~ 2023-09-09T03:24:07,683 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat22(PyObject*, PyObject*)’: 2023-09-09T03:24:07,683 Box2D/Box2D_wrap.cpp:7022:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,684 7022 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat22", 0, 4, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,684 | ^~ 2023-09-09T03:24:07,685 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-09T03:24:07,686 7022 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat22", 0, 4, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,686 | ^~ 2023-09-09T03:24:07,687 Box2D/Box2D_wrap.cpp:7025:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,688 7025 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2023-09-09T03:24:07,688 | ^~ 2023-09-09T03:24:07,689 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-09T03:24:07,689 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,690 | ^~~~ 2023-09-09T03:24:07,690 Box2D/Box2D_wrap.cpp:7025:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,691 7025 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2023-09-09T03:24:07,691 | ^~~~~~~~~ 2023-09-09T03:24:07,692 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___SetAngle(PyObject*, PyObject*)’: 2023-09-09T03:24:07,693 Box2D/Box2D_wrap.cpp:7048:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,694 7048 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___SetAngle", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:07,694 | ^~ 2023-09-09T03:24:07,695 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-09T03:24:07,696 7048 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___SetAngle", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:07,696 | ^~ 2023-09-09T03:24:07,697 Box2D/Box2D_wrap.cpp:7050:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,698 7050 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:07,698 | ^~ 2023-09-09T03:24:07,699 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-09T03:24:07,700 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,700 | ^~~~ 2023-09-09T03:24:07,701 Box2D/Box2D_wrap.cpp:7050:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,702 7050 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:07,702 | ^~~~~~~~~ 2023-09-09T03:24:07,703 Box2D/Box2D_wrap.cpp:7052:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,704 7052 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,705 | ^~ 2023-09-09T03:24:07,706 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-09T03:24:07,706 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,707 | ^~~~ 2023-09-09T03:24:07,707 Box2D/Box2D_wrap.cpp:7052:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,708 7052 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,708 | ^~~~~~~~~ 2023-09-09T03:24:07,709 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___mul__(PyObject*, PyObject*)’: 2023-09-09T03:24:07,709 Box2D/Box2D_wrap.cpp:7086:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,710 7086 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___mul__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-09T03:24:07,711 | ^~ 2023-09-09T03:24:07,711 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-09T03:24:07,712 7086 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___mul__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-09T03:24:07,712 | ^~ 2023-09-09T03:24:07,713 Box2D/Box2D_wrap.cpp:7088:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,713 7088 | if (!_v) goto check_1; return _wrap_b2Mat22___mul____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-09T03:24:07,714 | ^~ 2023-09-09T03:24:07,715 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-09T03:24:07,715 7088 | if (!_v) goto check_1; return _wrap_b2Mat22___mul____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-09T03:24:07,716 | ^~~~~~ 2023-09-09T03:24:07,716 Box2D/Box2D_wrap.cpp:7090:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,717 7090 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: Py_INCREF(Py_NotImplemented); 2023-09-09T03:24:07,718 | ^~ 2023-09-09T03:24:07,718 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-09T03:24:07,719 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,720 | ^~~~ 2023-09-09T03:24:07,720 Box2D/Box2D_wrap.cpp:7090:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,721 7090 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: Py_INCREF(Py_NotImplemented); 2023-09-09T03:24:07,721 | ^~~~~~~~~ 2023-09-09T03:24:07,722 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat33__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,723 Box2D/Box2D_wrap.cpp:7162:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,724 7162 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2023-09-09T03:24:07,724 | ^~ 2023-09-09T03:24:07,725 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-09T03:24:07,726 7162 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2023-09-09T03:24:07,727 | ^ 2023-09-09T03:24:07,748 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col1_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,749 Box2D/Box2D_wrap.cpp:7282:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,749 7282 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-09T03:24:07,750 | ^~ 2023-09-09T03:24:07,751 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-09T03:24:07,751 7282 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-09T03:24:07,752 | ^~~~~~~~ 2023-09-09T03:24:07,755 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col2_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,755 Box2D/Box2D_wrap.cpp:7305:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,756 7305 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-09T03:24:07,757 | ^~ 2023-09-09T03:24:07,757 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-09T03:24:07,758 7305 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-09T03:24:07,758 | ^~~~~~~~ 2023-09-09T03:24:07,765 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col3_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,766 Box2D/Box2D_wrap.cpp:7328:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,766 7328 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-09T03:24:07,767 | ^~ 2023-09-09T03:24:07,768 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-09T03:24:07,768 7328 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2023-09-09T03:24:07,769 | ^~~~~~~~ 2023-09-09T03:24:07,770 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat33(PyObject*, PyObject*)’: 2023-09-09T03:24:07,771 Box2D/Box2D_wrap.cpp:7346:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,772 7346 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat33", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,772 | ^~ 2023-09-09T03:24:07,773 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-09T03:24:07,774 7346 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat33", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,774 | ^~ 2023-09-09T03:24:07,775 Box2D/Box2D_wrap.cpp:7349:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,776 7349 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,777 | ^~ 2023-09-09T03:24:07,777 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-09T03:24:07,778 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,779 | ^~~~ 2023-09-09T03:24:07,779 Box2D/Box2D_wrap.cpp:7349:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,780 7349 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,781 | ^~~~~~~~~ 2023-09-09T03:24:07,793 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Rot(PyObject*, PyObject*)’: 2023-09-09T03:24:07,794 Box2D/Box2D_wrap.cpp:7454:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,794 7454 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Rot", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,795 | ^~ 2023-09-09T03:24:07,795 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-09T03:24:07,796 7454 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Rot", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,796 | ^~ 2023-09-09T03:24:07,797 Box2D/Box2D_wrap.cpp:7457:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,797 7457 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,798 | ^~ 2023-09-09T03:24:07,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-09T03:24:07,799 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,800 | ^~~~ 2023-09-09T03:24:07,800 Box2D/Box2D_wrap.cpp:7457:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,801 7457 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,801 | ^~~~~~~~~ 2023-09-09T03:24:07,822 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Transform(PyObject*, PyObject*)’: 2023-09-09T03:24:07,822 Box2D/Box2D_wrap.cpp:7591:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,823 7591 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Transform", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,824 | ^~ 2023-09-09T03:24:07,824 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-09T03:24:07,825 7591 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Transform", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:07,826 | ^~ 2023-09-09T03:24:07,826 Box2D/Box2D_wrap.cpp:7593:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,827 7593 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-09T03:24:07,827 | ^~ 2023-09-09T03:24:07,828 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-09T03:24:07,829 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,829 | ^~~~ 2023-09-09T03:24:07,830 Box2D/Box2D_wrap.cpp:7593:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,831 7593 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2023-09-09T03:24:07,832 | ^~~~~~~~~ 2023-09-09T03:24:07,832 Box2D/Box2D_wrap.cpp:7595:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,833 7595 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,834 | ^~ 2023-09-09T03:24:07,835 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-09T03:24:07,835 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,836 | ^~~~ 2023-09-09T03:24:07,836 Box2D/Box2D_wrap.cpp:7595:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,837 7595 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,837 | ^~~~~~~~~ 2023-09-09T03:24:07,838 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform_position_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,839 Box2D/Box2D_wrap.cpp:7642:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,839 7642 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-09T03:24:07,840 | ^~ 2023-09-09T03:24:07,840 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-09T03:24:07,841 7642 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-09T03:24:07,842 | ^~~~~~~~ 2023-09-09T03:24:07,842 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform_q_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,843 Box2D/Box2D_wrap.cpp:7659:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,843 7659 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-09T03:24:07,844 | ^~ 2023-09-09T03:24:07,845 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-09T03:24:07,846 7659 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-09T03:24:07,846 | ^~~~~~~~ 2023-09-09T03:24:07,847 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:07,848 Box2D/Box2D_wrap.cpp:7666:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,849 7666 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-09T03:24:07,849 | ^~ 2023-09-09T03:24:07,850 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-09T03:24:07,851 7666 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-09T03:24:07,851 | ^~~~~~~~ 2023-09-09T03:24:07,852 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform___get_rotation_matrix(PyObject*, PyObject*)’: 2023-09-09T03:24:07,853 Box2D/Box2D_wrap.cpp:7674:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,853 7674 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-09T03:24:07,854 | ^~ 2023-09-09T03:24:07,855 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-09T03:24:07,855 7674 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2023-09-09T03:24:07,856 | ^~~~~~~~ 2023-09-09T03:24:07,857 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_GetTransform__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,857 Box2D/Box2D_wrap.cpp:7721:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,858 7721 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-09T03:24:07,859 | ^~ 2023-09-09T03:24:07,859 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-09T03:24:07,860 7721 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-09T03:24:07,860 | ^~~~ 2023-09-09T03:24:07,866 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_localCenter_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,867 Box2D/Box2D_wrap.cpp:7765:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,867 7765 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-09T03:24:07,868 | ^~ 2023-09-09T03:24:07,868 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-09T03:24:07,869 7765 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-09T03:24:07,870 | ^~~~~~~~ 2023-09-09T03:24:07,872 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_c0_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,873 Box2D/Box2D_wrap.cpp:7787:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,874 7787 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-09T03:24:07,874 | ^~ 2023-09-09T03:24:07,875 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-09T03:24:07,876 7787 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-09T03:24:07,877 | ^~~~~~~~ 2023-09-09T03:24:07,878 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_c_get(PyObject*, PyObject*)’: 2023-09-09T03:24:07,879 Box2D/Box2D_wrap.cpp:7809:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,880 7809 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-09T03:24:07,881 | ^~ 2023-09-09T03:24:07,881 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-09T03:24:07,882 7809 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2023-09-09T03:24:07,882 | ^~~~~~~~ 2023-09-09T03:24:07,892 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_GetTransform(PyObject*, PyObject*)’: 2023-09-09T03:24:07,893 Box2D/Box2D_wrap.cpp:7878:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,893 7878 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Sweep_GetTransform", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:07,894 | ^~ 2023-09-09T03:24:07,895 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-09T03:24:07,896 7878 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Sweep_GetTransform", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:07,897 | ^~ 2023-09-09T03:24:07,897 Box2D/Box2D_wrap.cpp:7880:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,898 7880 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:07,898 | ^~ 2023-09-09T03:24:07,899 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-09T03:24:07,899 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,900 | ^~~~ 2023-09-09T03:24:07,901 Box2D/Box2D_wrap.cpp:7880:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,901 7880 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:07,902 | ^~~~~~~~~ 2023-09-09T03:24:07,902 Box2D/Box2D_wrap.cpp:7882:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,903 7882 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,903 | ^~ 2023-09-09T03:24:07,904 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-09T03:24:07,904 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:07,905 | ^~~~ 2023-09-09T03:24:07,906 Box2D/Box2D_wrap.cpp:7882:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:07,906 7882 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:07,907 | ^~~~~~~~~ 2023-09-09T03:24:07,908 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Sweep(PyObject*, PyObject*)’: 2023-09-09T03:24:07,908 Box2D/Box2D_wrap.cpp:7887:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,909 7887 | if (!SWIG_Python_UnpackTuple(args, "new_b2Sweep", 0, 0, 0)) SWIG_fail; { try { result = (b2Sweep *)new b2Sweep(); } 2023-09-09T03:24:07,910 | ^~ 2023-09-09T03:24:07,911 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-09T03:24:07,911 7887 | if (!SWIG_Python_UnpackTuple(args, "new_b2Sweep", 0, 0, 0)) SWIG_fail; { try { result = (b2Sweep *)new b2Sweep(); } 2023-09-09T03:24:07,912 | ^ 2023-09-09T03:24:07,913 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,914 Box2D/Box2D_wrap.cpp:7961:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,914 7961 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2023-09-09T03:24:07,915 | ^~ 2023-09-09T03:24:07,916 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-09T03:24:07,916 7961 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2023-09-09T03:24:07,917 | ^ 2023-09-09T03:24:07,918 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,919 Box2D/Box2D_wrap.cpp:7977:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,920 7977 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-09T03:24:07,920 | ^~ 2023-09-09T03:24:07,921 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-09T03:24:07,921 7977 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2023-09-09T03:24:07,922 | ^~~~~~ 2023-09-09T03:24:07,923 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,924 Box2D/Box2D_wrap.cpp:7993:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,924 7993 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-09T03:24:07,925 | ^~ 2023-09-09T03:24:07,925 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-09T03:24:07,926 7993 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-09T03:24:07,926 | ^~~~ 2023-09-09T03:24:07,929 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,929 Box2D/Box2D_wrap.cpp:8012:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,930 8012 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-09T03:24:07,931 | ^~ 2023-09-09T03:24:07,931 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-09T03:24:07,932 8012 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-09T03:24:07,933 | ^~~~ 2023-09-09T03:24:07,934 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceSquared(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:07,935 Box2D/Box2D_wrap.cpp:8032:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,936 8032 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2DistanceSquared", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,937 | ^~ 2023-09-09T03:24:07,937 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-09T03:24:07,938 8032 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2DistanceSquared", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:07,939 | ^ 2023-09-09T03:24:07,946 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Dot(PyObject*, PyObject*)’: 2023-09-09T03:24:07,947 Box2D/Box2D_wrap.cpp:8079:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,947 8079 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Dot", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-09T03:24:07,948 | ^~ 2023-09-09T03:24:07,949 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-09T03:24:07,949 8079 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Dot", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-09T03:24:07,950 | ^~ 2023-09-09T03:24:07,951 Box2D/Box2D_wrap.cpp:8081:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,952 8081 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:07,952 | ^~ 2023-09-09T03:24:07,953 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-09T03:24:07,953 8081 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:07,954 | ^ 2023-09-09T03:24:07,954 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_3(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,955 Box2D/Box2D_wrap.cpp:8090:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,955 8090 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2023-09-09T03:24:07,956 | ^~ 2023-09-09T03:24:07,956 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-09T03:24:07,957 8090 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2023-09-09T03:24:07,958 | ^ 2023-09-09T03:24:07,959 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross(PyObject*, PyObject*)’: 2023-09-09T03:24:07,959 Box2D/Box2D_wrap.cpp:8115:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,960 8115 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-09T03:24:07,960 | ^~ 2023-09-09T03:24:07,961 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-09T03:24:07,962 8115 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2023-09-09T03:24:07,962 | ^~ 2023-09-09T03:24:07,963 Box2D/Box2D_wrap.cpp:8117:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,963 8117 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:07,964 | ^~ 2023-09-09T03:24:07,964 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-09T03:24:07,965 8117 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:07,966 | ^ 2023-09-09T03:24:07,967 Box2D/Box2D_wrap.cpp:8121:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,967 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-09T03:24:07,968 | ^~ 2023-09-09T03:24:07,968 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-09T03:24:07,969 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-09T03:24:07,970 | ^ 2023-09-09T03:24:07,970 Box2D/Box2D_wrap.cpp:8124:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,971 8124 | if (!_v) goto check_3; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:07,972 | ^~ 2023-09-09T03:24:07,972 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-09T03:24:07,973 8124 | if (!_v) goto check_3; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:07,974 | ^ 2023-09-09T03:24:07,975 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,975 Box2D/Box2D_wrap.cpp:8166:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,976 8166 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat33, 0 | 0); 2023-09-09T03:24:07,976 | ^~ 2023-09-09T03:24:07,977 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-09T03:24:07,977 8166 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat33, 0 | 0); 2023-09-09T03:24:07,978 | ^~~~ 2023-09-09T03:24:07,984 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_3(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,985 Box2D/Box2D_wrap.cpp:8207:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,985 8207 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-09T03:24:07,986 | ^~ 2023-09-09T03:24:07,986 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-09T03:24:07,987 8207 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-09T03:24:07,987 | ^~~~ 2023-09-09T03:24:07,988 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,989 Box2D/Box2D_wrap.cpp:8223:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,989 8223 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-09T03:24:07,990 | ^~ 2023-09-09T03:24:07,991 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-09T03:24:07,991 8223 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-09T03:24:07,992 | ^~~~ 2023-09-09T03:24:07,993 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_4(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,994 Box2D/Box2D_wrap.cpp:8239:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,994 8239 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-09T03:24:07,995 | ^~ 2023-09-09T03:24:07,995 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-09T03:24:07,996 8239 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-09T03:24:07,997 | ^~~~ 2023-09-09T03:24:07,997 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT__SWIG_3(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:07,998 Box2D/Box2D_wrap.cpp:8258:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:07,999 8258 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-09T03:24:08,000 | ^~ 2023-09-09T03:24:08,000 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-09T03:24:08,001 8258 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Rot, 0 | 0); 2023-09-09T03:24:08,002 | ^~~~ 2023-09-09T03:24:08,003 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul__SWIG_5(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:08,003 Box2D/Box2D_wrap.cpp:8277:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,004 8277 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Transform, 0 | 0); 2023-09-09T03:24:08,004 | ^~ 2023-09-09T03:24:08,005 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-09T03:24:08,005 8277 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Transform, 0 | 0); 2023-09-09T03:24:08,006 | ^~~~ 2023-09-09T03:24:08,008 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT__SWIG_4(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:08,009 Box2D/Box2D_wrap.cpp:8297:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,009 8297 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Transform, 0 | 0); 2023-09-09T03:24:08,010 | ^~ 2023-09-09T03:24:08,010 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-09T03:24:08,011 8297 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Transform, 0 | 0); 2023-09-09T03:24:08,012 | ^~~~ 2023-09-09T03:24:08,016 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul(PyObject*, PyObject*)’: 2023-09-09T03:24:08,017 Box2D/Box2D_wrap.cpp:8333:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,017 8333 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mul", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-09T03:24:08,018 | ^~ 2023-09-09T03:24:08,019 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-09T03:24:08,019 8333 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mul", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-09T03:24:08,020 | ^~ 2023-09-09T03:24:08,021 Box2D/Box2D_wrap.cpp:8335:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,021 8335 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:08,022 | ^~ 2023-09-09T03:24:08,022 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-09T03:24:08,023 8335 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:08,024 | ^ 2023-09-09T03:24:08,025 Box2D/Box2D_wrap.cpp:8339:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,025 8339 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2023-09-09T03:24:08,026 | ^~ 2023-09-09T03:24:08,026 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-09T03:24:08,027 8339 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2023-09-09T03:24:08,028 | ^ 2023-09-09T03:24:08,029 Box2D/Box2D_wrap.cpp:8346:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,029 8346 | if (!_v) goto check_4; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Rot, SWIG_POINTER_NO_NULL | 0); 2023-09-09T03:24:08,030 | ^~ 2023-09-09T03:24:08,030 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-09T03:24:08,031 8346 | if (!_v) goto check_4; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Rot, SWIG_POINTER_NO_NULL | 0); 2023-09-09T03:24:08,031 | ^ 2023-09-09T03:24:08,032 Box2D/Box2D_wrap.cpp:8353:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,032 8353 | if (!_v) goto check_6; return _wrap_b2Mul__SWIG_5(self, argc, argv);} check_6: if (argc == 2) { 2023-09-09T03:24:08,033 | ^~ 2023-09-09T03:24:08,033 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-09T03:24:08,034 8353 | if (!_v) goto check_6; return _wrap_b2Mul__SWIG_5(self, argc, argv);} check_6: if (argc == 2) { 2023-09-09T03:24:08,034 | ^~~~~~ 2023-09-09T03:24:08,035 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT(PyObject*, PyObject*)’: 2023-09-09T03:24:08,035 Box2D/Box2D_wrap.cpp:8378:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,036 8378 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2MulT", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-09T03:24:08,036 | ^~ 2023-09-09T03:24:08,037 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-09T03:24:08,037 8378 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2MulT", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2023-09-09T03:24:08,038 | ^~ 2023-09-09T03:24:08,038 Box2D/Box2D_wrap.cpp:8380:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,039 8380 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:08,040 | ^~ 2023-09-09T03:24:08,040 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-09T03:24:08,041 8380 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:08,042 | ^ 2023-09-09T03:24:08,043 Box2D/Box2D_wrap.cpp:8384:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,043 8384 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2023-09-09T03:24:08,044 | ^~ 2023-09-09T03:24:08,045 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-09T03:24:08,045 8384 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2023-09-09T03:24:08,046 | ^ 2023-09-09T03:24:08,046 Box2D/Box2D_wrap.cpp:8389:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,047 8389 | if (!_v) goto check_3; return _wrap_b2MulT__SWIG_2(self, argc, argv);} check_3: if (argc == 2) { int _v = 0; { 2023-09-09T03:24:08,048 | ^~ 2023-09-09T03:24:08,049 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-09T03:24:08,049 8389 | if (!_v) goto check_3; return _wrap_b2MulT__SWIG_2(self, argc, argv);} check_3: if (argc == 2) { int _v = 0; { 2023-09-09T03:24:08,050 | ^~~~~~ 2023-09-09T03:24:08,051 Box2D/Box2D_wrap.cpp:8391:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,051 8391 | if (!_v) goto check_4; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:08,052 | ^~ 2023-09-09T03:24:08,053 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-09T03:24:08,053 8391 | if (!_v) goto check_4; { { _v = (PySequence_Check(argv[1]) || 2023-09-09T03:24:08,054 | ^ 2023-09-09T03:24:08,054 Box2D/Box2D_wrap.cpp:8395:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,055 8395 | if (!_v) goto check_5; return _wrap_b2MulT__SWIG_4(self, argc, argv);} check_5: if (argc == 2) { 2023-09-09T03:24:08,055 | ^~ 2023-09-09T03:24:08,056 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-09T03:24:08,056 8395 | if (!_v) goto check_5; return _wrap_b2MulT__SWIG_4(self, argc, argv);} check_5: if (argc == 2) { 2023-09-09T03:24:08,057 | ^~~~~~ 2023-09-09T03:24:08,057 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Abs__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:08,058 Box2D/Box2D_wrap.cpp:8419:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,059 8419 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-09T03:24:08,059 | ^~ 2023-09-09T03:24:08,060 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-09T03:24:08,061 8419 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2023-09-09T03:24:08,061 | ^~~~ 2023-09-09T03:24:08,062 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Abs(PyObject*, PyObject*)’: 2023-09-09T03:24:08,063 Box2D/Box2D_wrap.cpp:8429:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,063 8429 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Abs", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { int _v = 0; { { 2023-09-09T03:24:08,064 | ^~ 2023-09-09T03:24:08,065 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-09T03:24:08,065 8429 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Abs", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { int _v = 0; { { 2023-09-09T03:24:08,066 | ^~ 2023-09-09T03:24:08,066 Box2D/Box2D_wrap.cpp:8431:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,067 8431 | if (!_v) goto check_1; return _wrap_b2Abs__SWIG_1(self, argc, argv);} check_1: if (argc == 1) { 2023-09-09T03:24:08,068 | ^~ 2023-09-09T03:24:08,068 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-09T03:24:08,069 8431 | if (!_v) goto check_1; return _wrap_b2Abs__SWIG_1(self, argc, argv);} check_1: if (argc == 1) { 2023-09-09T03:24:08,070 | ^~~~~~ 2023-09-09T03:24:08,070 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Min(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,071 Box2D/Box2D_wrap.cpp:8438:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,072 8438 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Min", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2023-09-09T03:24:08,073 | ^~ 2023-09-09T03:24:08,073 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-09T03:24:08,074 8438 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Min", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2023-09-09T03:24:08,074 | ^ 2023-09-09T03:24:08,075 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Max(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,075 Box2D/Box2D_wrap.cpp:8462:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,076 8462 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Max", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2023-09-09T03:24:08,076 | ^~ 2023-09-09T03:24:08,077 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-09T03:24:08,077 8462 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Max", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2023-09-09T03:24:08,078 | ^ 2023-09-09T03:24:08,078 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Clamp(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,079 Box2D/Box2D_wrap.cpp:8487:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,080 8487 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Clamp", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:08,080 | ^~ 2023-09-09T03:24:08,081 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-09T03:24:08,081 8487 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Clamp", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:08,082 | ^ 2023-09-09T03:24:08,083 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature_indexA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,084 Box2D/Box2D_wrap.cpp:8550:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,084 8550 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,085 | ^~ 2023-09-09T03:24:08,086 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-09T03:24:08,087 8550 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,087 | ^~~~~~~~ 2023-09-09T03:24:08,088 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature_indexB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,088 Box2D/Box2D_wrap.cpp:8568:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,089 8568 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,090 | ^~ 2023-09-09T03:24:08,091 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-09T03:24:08,091 8568 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,092 | ^~~~~~~~ 2023-09-09T03:24:08,093 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature_typeA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,094 Box2D/Box2D_wrap.cpp:8586:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,094 8586 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,095 | ^~ 2023-09-09T03:24:08,095 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-09T03:24:08,096 8586 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,096 | ^~~~~~~~ 2023-09-09T03:24:08,097 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature_typeB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,097 Box2D/Box2D_wrap.cpp:8604:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,098 8604 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,098 | ^~ 2023-09-09T03:24:08,099 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-09T03:24:08,100 8604 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,100 | ^~~~~~~~ 2023-09-09T03:24:08,101 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFeature___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,101 Box2D/Box2D_wrap.cpp:8611:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,102 8611 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,102 | ^~ 2023-09-09T03:24:08,103 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-09T03:24:08,104 8611 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFeature, 0 | 0 ); 2023-09-09T03:24:08,104 | ^~~~~~~~ 2023-09-09T03:24:08,105 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactFeature(PyObject*, PyObject*)’: 2023-09-09T03:24:08,106 Box2D/Box2D_wrap.cpp:8625:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,107 8625 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:08,107 | ^~ 2023-09-09T03:24:08,108 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-09T03:24:08,109 8625 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:08,109 | ^~~~~~~~ 2023-09-09T03:24:08,110 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactID_key_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,111 Box2D/Box2D_wrap.cpp:8672:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,111 8672 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2023-09-09T03:24:08,112 | ^~ 2023-09-09T03:24:08,113 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-09T03:24:08,113 8672 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2023-09-09T03:24:08,114 | ^~~~~~~~ 2023-09-09T03:24:08,115 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactID___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,116 Box2D/Box2D_wrap.cpp:8679:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,116 8679 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2023-09-09T03:24:08,117 | ^~ 2023-09-09T03:24:08,117 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-09T03:24:08,118 8679 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2023-09-09T03:24:08,118 | ^~~~~~~~ 2023-09-09T03:24:08,119 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2ContactID(PyObject*, PyObject*)’: 2023-09-09T03:24:08,119 Box2D/Box2D_wrap.cpp:8686:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,120 8686 | if (!SWIG_Python_UnpackTuple(args, "new_b2ContactID", 0, 0, 0)) SWIG_fail; { try { result = (b2ContactID *)new b2ContactID(); } 2023-09-09T03:24:08,120 | ^~ 2023-09-09T03:24:08,121 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-09T03:24:08,122 8686 | if (!SWIG_Python_UnpackTuple(args, "new_b2ContactID", 0, 0, 0)) SWIG_fail; { try { result = (b2ContactID *)new b2ContactID(); } 2023-09-09T03:24:08,122 | ^ 2023-09-09T03:24:08,123 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ManifoldPoint_localPoint_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,123 Box2D/Box2D_wrap.cpp:8726:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,124 8726 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-09T03:24:08,125 | ^~ 2023-09-09T03:24:08,126 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-09T03:24:08,126 8726 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-09T03:24:08,127 | ^~~~~~~~ 2023-09-09T03:24:08,128 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ManifoldPoint_normalImpulse_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,128 Box2D/Box2D_wrap.cpp:8742:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,129 8742 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-09T03:24:08,130 | ^~ 2023-09-09T03:24:08,131 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-09T03:24:08,131 8742 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-09T03:24:08,132 | ^~~~~~~~ 2023-09-09T03:24:08,132 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ManifoldPoint_tangentImpulse_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,133 Box2D/Box2D_wrap.cpp:8758:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,134 8758 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-09T03:24:08,134 | ^~ 2023-09-09T03:24:08,135 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-09T03:24:08,136 8758 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-09T03:24:08,137 | ^~~~~~~~ 2023-09-09T03:24:08,138 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ManifoldPoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,138 Box2D/Box2D_wrap.cpp:8784:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,139 8784 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-09T03:24:08,139 | ^~ 2023-09-09T03:24:08,140 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-09T03:24:08,140 8784 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ManifoldPoint, 0 | 0 ); 2023-09-09T03:24:08,141 | ^~~~~~~~ 2023-09-09T03:24:08,142 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_localNormal_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,143 Box2D/Box2D_wrap.cpp:8832:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,143 8832 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,144 | ^~ 2023-09-09T03:24:08,145 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-09T03:24:08,145 8832 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,146 | ^~~~~~~~ 2023-09-09T03:24:08,149 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_localPoint_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,149 Box2D/Box2D_wrap.cpp:8855:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,150 8855 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,151 | ^~ 2023-09-09T03:24:08,152 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-09T03:24:08,152 8855 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,153 | ^~~~~~~~ 2023-09-09T03:24:08,154 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_type__get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,154 Box2D/Box2D_wrap.cpp:8871:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,155 8871 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,155 | ^~ 2023-09-09T03:24:08,156 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-09T03:24:08,157 8871 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,157 | ^~~~~~~~ 2023-09-09T03:24:08,158 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_pointCount_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,159 Box2D/Box2D_wrap.cpp:8887:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,159 8887 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,160 | ^~ 2023-09-09T03:24:08,161 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-09T03:24:08,161 8887 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,162 | ^~~~~~~~ 2023-09-09T03:24:08,163 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,163 Box2D/Box2D_wrap.cpp:8894:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,164 8894 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,165 | ^~ 2023-09-09T03:24:08,165 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-09T03:24:08,165 8894 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2023-09-09T03:24:08,166 | ^~~~~~~~ 2023-09-09T03:24:08,167 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Manifold(PyObject*, PyObject*)’: 2023-09-09T03:24:08,167 Box2D/Box2D_wrap.cpp:8914:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,168 8914 | if (!SWIG_Python_UnpackTuple(args, "new_b2Manifold", 0, 0, 0)) SWIG_fail; { try { result = (b2Manifold *)new b2Manifold(); } 2023-09-09T03:24:08,168 | ^~ 2023-09-09T03:24:08,169 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-09T03:24:08,169 8914 | if (!SWIG_Python_UnpackTuple(args, "new_b2Manifold", 0, 0, 0)) SWIG_fail; { try { result = (b2Manifold *)new b2Manifold(); } 2023-09-09T03:24:08,170 | ^ 2023-09-09T03:24:08,177 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WorldManifold_normal_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,178 Box2D/Box2D_wrap.cpp:8985:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,178 8985 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WorldManifold, 0 | 0 ); 2023-09-09T03:24:08,179 | ^~ 2023-09-09T03:24:08,180 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-09T03:24:08,181 8985 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WorldManifold, 0 | 0 ); 2023-09-09T03:24:08,181 | ^~~~~~~~ 2023-09-09T03:24:08,182 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WorldManifold___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,183 Box2D/Box2D_wrap.cpp:8992:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,183 8992 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WorldManifold, 0 | 0 ); 2023-09-09T03:24:08,184 | ^~ 2023-09-09T03:24:08,184 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-09T03:24:08,185 8992 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WorldManifold, 0 | 0 ); 2023-09-09T03:24:08,186 | ^~~~~~~~ 2023-09-09T03:24:08,190 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ClipVertex_v_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,191 Box2D/Box2D_wrap.cpp:9048:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,192 9048 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-09T03:24:08,193 | ^~ 2023-09-09T03:24:08,193 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-09T03:24:08,194 9048 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-09T03:24:08,194 | ^~~~~~~~ 2023-09-09T03:24:08,195 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ClipVertex_id_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,195 Box2D/Box2D_wrap.cpp:9066:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,196 9066 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-09T03:24:08,197 | ^~ 2023-09-09T03:24:08,197 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-09T03:24:08,197 9066 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-09T03:24:08,198 | ^~~~~~~~ 2023-09-09T03:24:08,199 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ClipVertex___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,199 Box2D/Box2D_wrap.cpp:9074:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,200 9074 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-09T03:24:08,200 | ^~ 2023-09-09T03:24:08,201 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-09T03:24:08,202 9074 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2023-09-09T03:24:08,202 | ^~~~~~~~ 2023-09-09T03:24:08,207 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastInput_p1_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,207 Box2D/Box2D_wrap.cpp:9121:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,208 9121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-09T03:24:08,209 | ^~ 2023-09-09T03:24:08,209 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-09T03:24:08,210 9121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-09T03:24:08,211 | ^~~~~~~~ 2023-09-09T03:24:08,213 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastInput_p2_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,214 Box2D/Box2D_wrap.cpp:9144:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,214 9144 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-09T03:24:08,215 | ^~ 2023-09-09T03:24:08,216 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-09T03:24:08,216 9144 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-09T03:24:08,217 | ^~~~~~~~ 2023-09-09T03:24:08,218 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastInput_maxFraction_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,219 Box2D/Box2D_wrap.cpp:9160:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,219 9160 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-09T03:24:08,220 | ^~ 2023-09-09T03:24:08,221 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-09T03:24:08,221 9160 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-09T03:24:08,222 | ^~~~~~~~ 2023-09-09T03:24:08,222 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastInput___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,223 Box2D/Box2D_wrap.cpp:9167:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,223 9167 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-09T03:24:08,224 | ^~ 2023-09-09T03:24:08,224 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-09T03:24:08,225 9167 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastInput, 0 | 0 ); 2023-09-09T03:24:08,226 | ^~~~~~~~ 2023-09-09T03:24:08,230 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastOutput_normal_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,230 Box2D/Box2D_wrap.cpp:9215:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,231 9215 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-09T03:24:08,232 | ^~ 2023-09-09T03:24:08,232 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-09T03:24:08,233 9215 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-09T03:24:08,233 | ^~~~~~~~ 2023-09-09T03:24:08,234 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastOutput_fraction_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,235 Box2D/Box2D_wrap.cpp:9231:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,235 9231 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-09T03:24:08,236 | ^~ 2023-09-09T03:24:08,236 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-09T03:24:08,237 9231 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-09T03:24:08,238 | ^~~~~~~~ 2023-09-09T03:24:08,238 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastOutput___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,239 Box2D/Box2D_wrap.cpp:9238:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,240 9238 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-09T03:24:08,240 | ^~ 2023-09-09T03:24:08,241 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-09T03:24:08,242 9238 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastOutput, 0 | 0 ); 2023-09-09T03:24:08,242 | ^~~~~~~~ 2023-09-09T03:24:08,244 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___GetCenter(PyObject*, PyObject*)’: 2023-09-09T03:24:08,244 Box2D/Box2D_wrap.cpp:9277:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,245 9277 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-09T03:24:08,246 | ^~ 2023-09-09T03:24:08,246 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-09T03:24:08,247 9277 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-09T03:24:08,248 | ^~~~~~~~ 2023-09-09T03:24:08,248 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___GetExtents(PyObject*, PyObject*)’: 2023-09-09T03:24:08,249 Box2D/Box2D_wrap.cpp:9286:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,249 9286 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-09T03:24:08,250 | ^~ 2023-09-09T03:24:08,250 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-09T03:24:08,251 9286 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-09T03:24:08,251 | ^~~~~~~~ 2023-09-09T03:24:08,256 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_Combine(PyObject*, PyObject*)’: 2023-09-09T03:24:08,256 Box2D/Box2D_wrap.cpp:9331:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,257 9331 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB_Combine", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:08,257 | ^~ 2023-09-09T03:24:08,258 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-09T03:24:08,258 9331 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB_Combine", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:08,259 | ^~ 2023-09-09T03:24:08,260 Box2D/Box2D_wrap.cpp:9333:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,260 9333 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:08,261 | ^~ 2023-09-09T03:24:08,261 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-09T03:24:08,262 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,263 | ^~~~ 2023-09-09T03:24:08,264 Box2D/Box2D_wrap.cpp:9333:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,264 9333 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:08,265 | ^~~~~~~~~ 2023-09-09T03:24:08,266 Box2D/Box2D_wrap.cpp:9335:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,266 9335 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,267 | ^~ 2023-09-09T03:24:08,268 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-09T03:24:08,268 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,269 | ^~~~ 2023-09-09T03:24:08,270 Box2D/Box2D_wrap.cpp:9335:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,270 9335 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,271 | ^~~~~~~~~ 2023-09-09T03:24:08,272 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_lowerBound_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,272 Box2D/Box2D_wrap.cpp:9388:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,273 9388 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-09T03:24:08,273 | ^~ 2023-09-09T03:24:08,274 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-09T03:24:08,274 9388 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-09T03:24:08,275 | ^~~~~~~~ 2023-09-09T03:24:08,278 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_upperBound_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,279 Box2D/Box2D_wrap.cpp:9410:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,279 9410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-09T03:24:08,280 | ^~ 2023-09-09T03:24:08,280 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-09T03:24:08,281 9410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2023-09-09T03:24:08,282 | ^~~~~~~~ 2023-09-09T03:24:08,286 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___contains__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,287 Box2D/Box2D_wrap.cpp:9440:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,287 9440 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB___contains__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:08,288 | ^~ 2023-09-09T03:24:08,288 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-09T03:24:08,289 9440 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB___contains__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:08,289 | ^~ 2023-09-09T03:24:08,290 Box2D/Box2D_wrap.cpp:9442:6: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,291 9442 | if (!_v) goto check_1; return _wrap_b2AABB___contains____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-09T03:24:08,291 | ^~ 2023-09-09T03:24:08,292 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-09T03:24:08,293 9442 | if (!_v) goto check_1; return _wrap_b2AABB___contains____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2023-09-09T03:24:08,293 | ^~~~~~ 2023-09-09T03:24:08,294 Box2D/Box2D_wrap.cpp:9444:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,295 9444 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,295 | ^~ 2023-09-09T03:24:08,296 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-09T03:24:08,297 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,297 | ^~~~ 2023-09-09T03:24:08,298 Box2D/Box2D_wrap.cpp:9444:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,299 9444 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,300 | ^~~~~~~~~ 2023-09-09T03:24:08,300 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2AABB(PyObject*, PyObject*)’: 2023-09-09T03:24:08,301 Box2D/Box2D_wrap.cpp:9463:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,301 9463 | if (!SWIG_Python_UnpackTuple(args, "new_b2AABB", 0, 0, 0)) SWIG_fail; { try { result = (b2AABB *)new b2AABB(); } 2023-09-09T03:24:08,302 | ^~ 2023-09-09T03:24:08,302 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-09T03:24:08,303 9463 | if (!SWIG_Python_UnpackTuple(args, "new_b2AABB", 0, 0, 0)) SWIG_fail; { try { result = (b2AABB *)new b2AABB(); } 2023-09-09T03:24:08,303 | ^ 2023-09-09T03:24:08,325 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TestOverlap__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:08,325 Box2D/Box2D_wrap.cpp:9662:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,326 9662 | if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2023-09-09T03:24:08,326 | ^~ 2023-09-09T03:24:08,327 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-09T03:24:08,327 9662 | if ((nobjs < 6) || (nobjs > 6)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2023-09-09T03:24:08,328 | ^~~~ 2023-09-09T03:24:08,332 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TestOverlap(PyObject*, PyObject*)’: 2023-09-09T03:24:08,333 Box2D/Box2D_wrap.cpp:9703:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,333 9703 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2TestOverlap", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:08,334 | ^~ 2023-09-09T03:24:08,335 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-09T03:24:08,336 9703 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2TestOverlap", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:08,337 | ^~ 2023-09-09T03:24:08,337 Box2D/Box2D_wrap.cpp:9706:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,338 9706 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,338 | ^~ 2023-09-09T03:24:08,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-09T03:24:08,340 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,340 | ^~~~ 2023-09-09T03:24:08,341 Box2D/Box2D_wrap.cpp:9706:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,342 9706 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,342 | ^~~~~~~~~ 2023-09-09T03:24:08,346 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Vec2Array_cast(PyObject*, PyObject*)’: 2023-09-09T03:24:08,347 Box2D/Box2D_wrap.cpp:9759:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,347 9759 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__b2Vec2Array, 0 | 0 ); 2023-09-09T03:24:08,348 | ^~ 2023-09-09T03:24:08,349 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-09T03:24:08,349 9759 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p__b2Vec2Array, 0 | 0 ); 2023-09-09T03:24:08,350 | ^~~~~~~~ 2023-09-09T03:24:08,350 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Vec2Array_frompointer(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,351 Box2D/Box2D_wrap.cpp:9768:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,351 9768 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:_b2Vec2Array_frompointer", kwnames, &obj0)) SWIG_fail; { 2023-09-09T03:24:08,352 | ^~ 2023-09-09T03:24:08,352 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-09T03:24:08,353 9768 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:_b2Vec2Array_frompointer", kwnames, &obj0)) SWIG_fail; { 2023-09-09T03:24:08,354 | ^ 2023-09-09T03:24:08,357 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_Set(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,358 Box2D/Box2D_wrap.cpp:9815:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,358 9815 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Color_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2023-09-09T03:24:08,359 | ^~ 2023-09-09T03:24:08,360 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-09T03:24:08,360 9815 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Color_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2023-09-09T03:24:08,361 | ^ 2023-09-09T03:24:08,361 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_r_set(PyObject*, PyObject*)’: 2023-09-09T03:24:08,362 Box2D/Box2D_wrap.cpp:9828:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,363 9828 | if (!SWIG_Python_UnpackTuple(args, "b2Color_r_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:08,363 | ^~ 2023-09-09T03:24:08,364 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-09T03:24:08,365 9828 | if (!SWIG_Python_UnpackTuple(args, "b2Color_r_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:08,365 | ^ 2023-09-09T03:24:08,366 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_g_set(PyObject*, PyObject*)’: 2023-09-09T03:24:08,367 Box2D/Box2D_wrap.cpp:9843:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,367 9843 | if (!SWIG_Python_UnpackTuple(args, "b2Color_g_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:08,368 | ^~ 2023-09-09T03:24:08,369 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-09T03:24:08,369 9843 | if (!SWIG_Python_UnpackTuple(args, "b2Color_g_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:08,370 | ^ 2023-09-09T03:24:08,371 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_b_set(PyObject*, PyObject*)’: 2023-09-09T03:24:08,371 Box2D/Box2D_wrap.cpp:9858:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,372 9858 | if (!SWIG_Python_UnpackTuple(args, "b2Color_b_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:08,373 | ^~ 2023-09-09T03:24:08,373 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-09T03:24:08,374 9858 | if (!SWIG_Python_UnpackTuple(args, "b2Color_b_set", 2, 2, swig_obj)) SWIG_fail; { 2023-09-09T03:24:08,374 | ^ 2023-09-09T03:24:08,378 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Color(PyObject*, PyObject*)’: 2023-09-09T03:24:08,378 Box2D/Box2D_wrap.cpp:9893:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,379 9893 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Color", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:08,379 | ^~ 2023-09-09T03:24:08,380 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-09T03:24:08,380 9893 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Color", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2023-09-09T03:24:08,381 | ^~ 2023-09-09T03:24:08,381 Box2D/Box2D_wrap.cpp:9896:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,382 9896 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:08,383 | ^~ 2023-09-09T03:24:08,383 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-09T03:24:08,384 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,384 | ^~~~ 2023-09-09T03:24:08,385 Box2D/Box2D_wrap.cpp:9896:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,386 9896 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:08,386 | ^~~~~~~~~ 2023-09-09T03:24:08,387 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___getitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,388 Box2D/Box2D_wrap.cpp:9911:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,388 9911 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,389 | ^~ 2023-09-09T03:24:08,389 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-09T03:24:08,390 9911 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,391 | ^ 2023-09-09T03:24:08,391 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___setitem__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,392 Box2D/Box2D_wrap.cpp:9923:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,393 9923 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Color___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:08,393 | ^~ 2023-09-09T03:24:08,394 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-09T03:24:08,395 9923 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Color___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2023-09-09T03:24:08,395 | ^ 2023-09-09T03:24:08,396 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___truediv__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,397 Box2D/Box2D_wrap.cpp:9935:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,397 9935 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,398 | ^~ 2023-09-09T03:24:08,398 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-09T03:24:08,399 9935 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,399 | ^ 2023-09-09T03:24:08,400 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___add__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,400 Box2D/Box2D_wrap.cpp:9947:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,401 9947 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,402 | ^~ 2023-09-09T03:24:08,402 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-09T03:24:08,403 9947 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,404 | ^ 2023-09-09T03:24:08,404 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___sub__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,405 Box2D/Box2D_wrap.cpp:9966:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,405 9966 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,406 | ^~ 2023-09-09T03:24:08,406 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-09T03:24:08,407 9966 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,408 | ^ 2023-09-09T03:24:08,408 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___div__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,409 Box2D/Box2D_wrap.cpp:9985:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,410 9985 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,410 | ^~ 2023-09-09T03:24:08,411 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-09T03:24:08,412 9985 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,412 | ^ 2023-09-09T03:24:08,413 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___rmul__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,414 Box2D/Box2D_wrap.cpp:9997:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,415 9997 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,415 | ^~ 2023-09-09T03:24:08,416 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-09T03:24:08,417 9997 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,417 | ^ 2023-09-09T03:24:08,418 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___mul__(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,418 Box2D/Box2D_wrap.cpp:10009:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,419 10009 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,419 | ^~ 2023-09-09T03:24:08,420 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-09T03:24:08,421 10009 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,421 | ^ 2023-09-09T03:24:08,422 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___isub(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,422 Box2D/Box2D_wrap.cpp:10021:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,423 10021 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___isub", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,423 | ^~ 2023-09-09T03:24:08,424 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-09T03:24:08,425 10021 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___isub", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,425 | ^ 2023-09-09T03:24:08,426 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___itruediv(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,427 Box2D/Box2D_wrap.cpp:10039:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,427 10039 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___itruediv", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,428 | ^~ 2023-09-09T03:24:08,429 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-09T03:24:08,429 10039 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___itruediv", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,430 | ^ 2023-09-09T03:24:08,431 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___idiv(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,431 Box2D/Box2D_wrap.cpp:10057:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,432 10057 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___idiv", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,433 | ^~ 2023-09-09T03:24:08,433 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-09T03:24:08,434 10057 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___idiv", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,435 | ^ 2023-09-09T03:24:08,435 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___imul(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,436 Box2D/Box2D_wrap.cpp:10075:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,437 10075 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___imul", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,437 | ^~ 2023-09-09T03:24:08,438 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-09T03:24:08,438 10075 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___imul", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,439 | ^ 2023-09-09T03:24:08,439 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___iadd(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,440 Box2D/Box2D_wrap.cpp:10093:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,440 10093 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___iadd", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,441 | ^~ 2023-09-09T03:24:08,441 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-09T03:24:08,442 10093 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___iadd", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,442 | ^ 2023-09-09T03:24:08,443 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___equ(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,444 Box2D/Box2D_wrap.cpp:10111:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,444 10111 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,445 | ^~ 2023-09-09T03:24:08,445 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-09T03:24:08,446 10111 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2023-09-09T03:24:08,446 | ^ 2023-09-09T03:24:08,449 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Draw(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,450 Box2D/Box2D_wrap.cpp:10145:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,451 10145 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2Draw", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:08,451 | ^~ 2023-09-09T03:24:08,452 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-09T03:24:08,453 10145 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2Draw", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:08,453 | ^~~~ 2023-09-09T03:24:08,505 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_convertVertices_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,505 Box2D/Box2D_wrap.cpp:10433:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,506 10433 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,507 | ^~ 2023-09-09T03:24:08,507 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-09T03:24:08,508 10433 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,509 | ^~~~~~~~ 2023-09-09T03:24:08,511 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_center_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,511 Box2D/Box2D_wrap.cpp:10456:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,512 10456 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,512 | ^~ 2023-09-09T03:24:08,513 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-09T03:24:08,513 10456 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,514 | ^~~~~~~~ 2023-09-09T03:24:08,517 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_offset_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,518 Box2D/Box2D_wrap.cpp:10479:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,518 10479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,519 | ^~ 2023-09-09T03:24:08,519 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-09T03:24:08,520 10479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,520 | ^~~~~~~~ 2023-09-09T03:24:08,521 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_zoom_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,522 Box2D/Box2D_wrap.cpp:10495:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,522 10495 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,523 | ^~ 2023-09-09T03:24:08,524 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-09T03:24:08,525 10495 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,525 | ^~~~~~~~ 2023-09-09T03:24:08,527 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_screenSize_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,527 Box2D/Box2D_wrap.cpp:10518:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,528 10518 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,529 | ^~ 2023-09-09T03:24:08,529 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-09T03:24:08,530 10518 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,531 | ^~~~~~~~ 2023-09-09T03:24:08,531 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_flipY_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,532 Box2D/Box2D_wrap.cpp:10534:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,533 10534 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,534 | ^~ 2023-09-09T03:24:08,534 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-09T03:24:08,535 10534 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,535 | ^~~~~~~~ 2023-09-09T03:24:08,536 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended_flipX_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,536 Box2D/Box2D_wrap.cpp:10550:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,537 10550 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,537 | ^~ 2023-09-09T03:24:08,538 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-09T03:24:08,539 10550 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,539 | ^~~~~~~~ 2023-09-09T03:24:08,587 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2DrawExtended(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:08,587 Box2D/Box2D_wrap.cpp:10820:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,588 10820 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DrawExtended", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:08,589 | ^~ 2023-09-09T03:24:08,589 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-09T03:24:08,590 10820 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DrawExtended", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:08,591 | ^~~~ 2023-09-09T03:24:08,591 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DrawExtended___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,592 Box2D/Box2D_wrap.cpp:10828:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,593 10828 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,594 | ^~ 2023-09-09T03:24:08,594 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-09T03:24:08,595 10828 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DrawExtended, 0 | 0 ); 2023-09-09T03:24:08,596 | ^~~~~~~~ 2023-09-09T03:24:08,597 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData_mass_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,598 Box2D/Box2D_wrap.cpp:10880:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,599 10880 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-09T03:24:08,600 | ^~ 2023-09-09T03:24:08,600 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-09T03:24:08,601 10880 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-09T03:24:08,602 | ^~~~~~~~ 2023-09-09T03:24:08,603 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData_center_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,604 Box2D/Box2D_wrap.cpp:10903:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,605 10903 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-09T03:24:08,606 | ^~ 2023-09-09T03:24:08,606 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-09T03:24:08,607 10903 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-09T03:24:08,607 | ^~~~~~~~ 2023-09-09T03:24:08,608 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData_I_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,608 Box2D/Box2D_wrap.cpp:10919:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,609 10919 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-09T03:24:08,609 | ^~ 2023-09-09T03:24:08,610 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-09T03:24:08,610 10919 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-09T03:24:08,611 | ^~~~~~~~ 2023-09-09T03:24:08,612 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,612 Box2D/Box2D_wrap.cpp:10926:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,613 10926 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-09T03:24:08,613 | ^~ 2023-09-09T03:24:08,614 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-09T03:24:08,615 10926 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2023-09-09T03:24:08,615 | ^~~~~~~~ 2023-09-09T03:24:08,616 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2MassData(PyObject*, PyObject*)’: 2023-09-09T03:24:08,617 Box2D/Box2D_wrap.cpp:10933:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,618 10933 | if (!SWIG_Python_UnpackTuple(args, "new_b2MassData", 0, 0, 0)) SWIG_fail; { try { result = (b2MassData *)new b2MassData(); } 2023-09-09T03:24:08,619 | ^~ 2023-09-09T03:24:08,619 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-09T03:24:08,620 10933 | if (!SWIG_Python_UnpackTuple(args, "new_b2MassData", 0, 0, 0)) SWIG_fail; { try { result = (b2MassData *)new b2MassData(); } 2023-09-09T03:24:08,621 | ^ 2023-09-09T03:24:08,622 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Shape___GetType(PyObject*, PyObject*)’: 2023-09-09T03:24:08,622 Box2D/Box2D_wrap.cpp:10964:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,623 10964 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2023-09-09T03:24:08,624 | ^~ 2023-09-09T03:24:08,624 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-09T03:24:08,625 10964 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2023-09-09T03:24:08,626 | ^~~~~~~~ 2023-09-09T03:24:08,646 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2CircleShape_pos_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,647 Box2D/Box2D_wrap.cpp:11117:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,648 11117 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2023-09-09T03:24:08,648 | ^~ 2023-09-09T03:24:08,649 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-09T03:24:08,649 11117 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2023-09-09T03:24:08,650 | ^~~~~~~~ 2023-09-09T03:24:08,651 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2CircleShape___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,651 Box2D/Box2D_wrap.cpp:11124:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,652 11124 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2023-09-09T03:24:08,652 | ^~ 2023-09-09T03:24:08,653 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-09T03:24:08,653 11124 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2023-09-09T03:24:08,654 | ^~~~~~~~ 2023-09-09T03:24:08,654 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2EdgeShape(PyObject*, PyObject*)’: 2023-09-09T03:24:08,655 Box2D/Box2D_wrap.cpp:11149:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,655 11149 | if (!SWIG_Python_UnpackTuple(args, "new_b2EdgeShape", 0, 0, 0)) SWIG_fail; { try { result = (b2EdgeShape *)new b2EdgeShape(); } 2023-09-09T03:24:08,656 | ^~ 2023-09-09T03:24:08,657 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-09T03:24:08,658 11149 | if (!SWIG_Python_UnpackTuple(args, "new_b2EdgeShape", 0, 0, 0)) SWIG_fail; { try { result = (b2EdgeShape *)new b2EdgeShape(); } 2023-09-09T03:24:08,658 | ^ 2023-09-09T03:24:08,665 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_vertex1_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,665 Box2D/Box2D_wrap.cpp:11197:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,666 11197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,667 | ^~ 2023-09-09T03:24:08,668 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-09T03:24:08,668 11197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,669 | ^~~~~~~~ 2023-09-09T03:24:08,671 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_vertex2_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,672 Box2D/Box2D_wrap.cpp:11220:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,672 11220 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,673 | ^~ 2023-09-09T03:24:08,674 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-09T03:24:08,674 11220 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,675 | ^~~~~~~~ 2023-09-09T03:24:08,677 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_vertex0_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,678 Box2D/Box2D_wrap.cpp:11243:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,679 11243 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,679 | ^~ 2023-09-09T03:24:08,680 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-09T03:24:08,680 11243 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,681 | ^~~~~~~~ 2023-09-09T03:24:08,684 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_vertex3_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,684 Box2D/Box2D_wrap.cpp:11266:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,685 11266 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,685 | ^~ 2023-09-09T03:24:08,686 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-09T03:24:08,686 11266 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,687 | ^~~~~~~~ 2023-09-09T03:24:08,688 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_hasVertex0_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,689 Box2D/Box2D_wrap.cpp:11282:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,689 11282 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,690 | ^~ 2023-09-09T03:24:08,690 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-09T03:24:08,691 11282 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,692 | ^~~~~~~~ 2023-09-09T03:24:08,693 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_hasVertex3_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,693 Box2D/Box2D_wrap.cpp:11298:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,694 11298 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,695 | ^~ 2023-09-09T03:24:08,695 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-09T03:24:08,696 11298 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,697 | ^~~~~~~~ 2023-09-09T03:24:08,697 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,698 Box2D/Box2D_wrap.cpp:11305:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,698 11305 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,699 | ^~ 2023-09-09T03:24:08,700 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-09T03:24:08,701 11305 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2023-09-09T03:24:08,701 | ^~~~~~~~ 2023-09-09T03:24:08,721 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_prevVertex_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,722 Box2D/Box2D_wrap.cpp:11448:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,722 11448 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,723 | ^~ 2023-09-09T03:24:08,724 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-09T03:24:08,724 11448 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,725 | ^~~~~~~~ 2023-09-09T03:24:08,727 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_nextVertex_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,728 Box2D/Box2D_wrap.cpp:11471:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,728 11471 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,729 | ^~ 2023-09-09T03:24:08,729 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-09T03:24:08,730 11471 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,730 | ^~~~~~~~ 2023-09-09T03:24:08,731 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_hasPrevVertex_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,732 Box2D/Box2D_wrap.cpp:11487:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,733 11487 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,734 | ^~ 2023-09-09T03:24:08,734 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-09T03:24:08,735 11487 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,736 | ^~~~~~~~ 2023-09-09T03:24:08,736 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_hasNextVertex_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,737 Box2D/Box2D_wrap.cpp:11503:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,737 11503 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,738 | ^~ 2023-09-09T03:24:08,739 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-09T03:24:08,739 11503 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,740 | ^~~~~~~~ 2023-09-09T03:24:08,740 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,741 Box2D/Box2D_wrap.cpp:11510:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,742 11510 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,742 | ^~ 2023-09-09T03:24:08,743 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-09T03:24:08,744 11510 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,745 | ^~~~~~~~ 2023-09-09T03:24:08,745 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape___get_vertices(PyObject*, PyObject*)’: 2023-09-09T03:24:08,746 Box2D/Box2D_wrap.cpp:11518:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,746 11518 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,747 | ^~ 2023-09-09T03:24:08,747 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-09T03:24:08,748 11518 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,748 | ^~~~~~~~ 2023-09-09T03:24:08,749 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape___get_count(PyObject*, PyObject*)’: 2023-09-09T03:24:08,750 Box2D/Box2D_wrap.cpp:11556:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,750 11556 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,751 | ^~ 2023-09-09T03:24:08,752 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-09T03:24:08,752 11556 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2023-09-09T03:24:08,753 | ^~~~~~~~ 2023-09-09T03:24:08,764 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_SetAsBox(PyObject*, PyObject*)’: 2023-09-09T03:24:08,764 Box2D/Box2D_wrap.cpp:11633:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,765 11633 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape_SetAsBox", 0, 5, argv))) SWIG_fail; --argc; if (argc == 3) { 2023-09-09T03:24:08,765 | ^~ 2023-09-09T03:24:08,766 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-09T03:24:08,767 11633 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape_SetAsBox", 0, 5, argv))) SWIG_fail; --argc; if (argc == 3) { 2023-09-09T03:24:08,767 | ^~ 2023-09-09T03:24:08,768 Box2D/Box2D_wrap.cpp:11635:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,769 11635 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 5) { 2023-09-09T03:24:08,769 | ^~ 2023-09-09T03:24:08,770 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-09T03:24:08,771 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,771 | ^~~~ 2023-09-09T03:24:08,772 Box2D/Box2D_wrap.cpp:11635:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,773 11635 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 5) { 2023-09-09T03:24:08,773 | ^~~~~~~~~ 2023-09-09T03:24:08,774 Box2D/Box2D_wrap.cpp:11637:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,775 11637 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,775 | ^~ 2023-09-09T03:24:08,776 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-09T03:24:08,777 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,777 | ^~~~ 2023-09-09T03:24:08,778 Box2D/Box2D_wrap.cpp:11637:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,778 11637 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,779 | ^~~~~~~~~ 2023-09-09T03:24:08,780 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_Validate(PyObject*, PyObject*)’: 2023-09-09T03:24:08,780 Box2D/Box2D_wrap.cpp:11643:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,780 11643 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,781 | ^~ 2023-09-09T03:24:08,782 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-09T03:24:08,782 11643 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,783 | ^~~~~~~~ 2023-09-09T03:24:08,783 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_centroid_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,784 Box2D/Box2D_wrap.cpp:11667:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,784 11667 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,785 | ^~ 2023-09-09T03:24:08,786 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-09T03:24:08,786 11667 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,787 | ^~~~~~~~ 2023-09-09T03:24:08,787 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_vertexCount_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,788 Box2D/Box2D_wrap.cpp:11683:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,789 11683 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,789 | ^~ 2023-09-09T03:24:08,790 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-09T03:24:08,791 11683 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,791 | ^~~~~~~~ 2023-09-09T03:24:08,792 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,793 Box2D/Box2D_wrap.cpp:11690:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,793 11690 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,794 | ^~ 2023-09-09T03:24:08,795 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-09T03:24:08,795 11690 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,796 | ^~~~~~~~ 2023-09-09T03:24:08,797 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___get_vertices(PyObject*, PyObject*)’: 2023-09-09T03:24:08,798 Box2D/Box2D_wrap.cpp:11698:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,799 11698 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,799 | ^~ 2023-09-09T03:24:08,800 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-09T03:24:08,800 11698 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,801 | ^~~~~~~~ 2023-09-09T03:24:08,801 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___get_normals(PyObject*, PyObject*)’: 2023-09-09T03:24:08,802 Box2D/Box2D_wrap.cpp:11706:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,802 11706 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,803 | ^~ 2023-09-09T03:24:08,803 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-09T03:24:08,804 11706 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,804 | ^~~~~~~~ 2023-09-09T03:24:08,804 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_set_vertex(PyObject*, PyObject*)’: 2023-09-09T03:24:08,805 Box2D/Box2D_wrap.cpp:11776:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,806 11776 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2023-09-09T03:24:08,806 | ^~ 2023-09-09T03:24:08,807 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-09T03:24:08,807 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,808 | ^~~~ 2023-09-09T03:24:08,809 Box2D/Box2D_wrap.cpp:11776:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,809 11776 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2023-09-09T03:24:08,810 | ^~~~~~~~~ 2023-09-09T03:24:08,811 Box2D/Box2D_wrap.cpp:11778:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,811 11778 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,812 | ^~ 2023-09-09T03:24:08,812 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-09T03:24:08,813 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,813 | ^~~~ 2023-09-09T03:24:08,814 Box2D/Box2D_wrap.cpp:11778:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,814 11778 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,815 | ^~~~~~~~~ 2023-09-09T03:24:08,816 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___set_vertices_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:08,816 Box2D/Box2D_wrap.cpp:11784:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,817 11784 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,818 | ^~ 2023-09-09T03:24:08,818 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-09T03:24:08,819 11784 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2023-09-09T03:24:08,819 | ^~~~ 2023-09-09T03:24:08,820 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___set_vertices_internal(PyObject*, PyObject*)’: 2023-09-09T03:24:08,821 Box2D/Box2D_wrap.cpp:11792:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,821 11792 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape___set_vertices_internal", 0, 3, argv))) SWIG_fail; --argc; 2023-09-09T03:24:08,822 | ^~ 2023-09-09T03:24:08,822 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-09T03:24:08,823 11792 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape___set_vertices_internal", 0, 3, argv))) SWIG_fail; --argc; 2023-09-09T03:24:08,823 | ^~ 2023-09-09T03:24:08,824 Box2D/Box2D_wrap.cpp:11794:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,824 11794 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:08,825 | ^~ 2023-09-09T03:24:08,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-09T03:24:08,826 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,827 | ^~~~ 2023-09-09T03:24:08,827 Box2D/Box2D_wrap.cpp:11794:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,828 11794 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:08,829 | ^~~~~~~~~ 2023-09-09T03:24:08,830 Box2D/Box2D_wrap.cpp:11796:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,830 11796 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,831 | ^~ 2023-09-09T03:24:08,831 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-09T03:24:08,832 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:08,833 | ^~~~ 2023-09-09T03:24:08,833 Box2D/Box2D_wrap.cpp:11796:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:08,834 11796 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:08,835 | ^~~~~~~~~ 2023-09-09T03:24:08,835 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_IsLeaf(PyObject*, PyObject*)’: 2023-09-09T03:24:08,836 Box2D/Box2D_wrap.cpp:11820:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,837 11820 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,837 | ^~ 2023-09-09T03:24:08,838 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-09T03:24:08,839 11820 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,840 | ^~~~~~~~ 2023-09-09T03:24:08,841 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_aabb_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,841 Box2D/Box2D_wrap.cpp:11838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,842 11838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,842 | ^~ 2023-09-09T03:24:08,843 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-09T03:24:08,844 11838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,844 | ^~~~~~~~ 2023-09-09T03:24:08,845 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_child1_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,845 Box2D/Box2D_wrap.cpp:11854:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,846 11854 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,846 | ^~ 2023-09-09T03:24:08,847 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-09T03:24:08,847 11854 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,848 | ^~~~~~~~ 2023-09-09T03:24:08,849 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_child2_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,849 Box2D/Box2D_wrap.cpp:11870:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,850 11870 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,850 | ^~ 2023-09-09T03:24:08,851 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-09T03:24:08,852 11870 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,853 | ^~~~~~~~ 2023-09-09T03:24:08,853 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_height_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,854 Box2D/Box2D_wrap.cpp:11886:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,855 11886 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,855 | ^~ 2023-09-09T03:24:08,856 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-09T03:24:08,857 11886 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2023-09-09T03:24:08,857 | ^~~~~~~~ 2023-09-09T03:24:08,858 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2TreeNode(PyObject*, PyObject*)’: 2023-09-09T03:24:08,859 Box2D/Box2D_wrap.cpp:11892:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,859 11892 | if (!SWIG_Python_UnpackTuple(args, "new_b2TreeNode", 0, 0, 0)) SWIG_fail; { try { result = (b2TreeNode *)new b2TreeNode(); } 2023-09-09T03:24:08,860 | ^~ 2023-09-09T03:24:08,861 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-09T03:24:08,861 11892 | if (!SWIG_Python_UnpackTuple(args, "new_b2TreeNode", 0, 0, 0)) SWIG_fail; { try { result = (b2TreeNode *)new b2TreeNode(); } 2023-09-09T03:24:08,862 | ^ 2023-09-09T03:24:08,863 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Pair(PyObject*, PyObject*)’: 2023-09-09T03:24:08,863 Box2D/Box2D_wrap.cpp:11952:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,864 11952 | if (!SWIG_Python_UnpackTuple(args, "new_b2Pair", 0, 0, 0)) SWIG_fail; { try { result = (b2Pair *)new b2Pair(); } 2023-09-09T03:24:08,864 | ^~ 2023-09-09T03:24:08,865 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-09T03:24:08,865 11952 | if (!SWIG_Python_UnpackTuple(args, "new_b2Pair", 0, 0, 0)) SWIG_fail; { try { result = (b2Pair *)new b2Pair(); } 2023-09-09T03:24:08,866 | ^ 2023-09-09T03:24:08,872 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetProxyCount(PyObject*, PyObject*)’: 2023-09-09T03:24:08,873 Box2D/Box2D_wrap.cpp:12049:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,874 12049 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,874 | ^~ 2023-09-09T03:24:08,875 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-09T03:24:08,875 12049 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,876 | ^~~~~~~~ 2023-09-09T03:24:08,876 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeHeight(PyObject*, PyObject*)’: 2023-09-09T03:24:08,877 Box2D/Box2D_wrap.cpp:12057:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,878 12057 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,878 | ^~ 2023-09-09T03:24:08,879 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-09T03:24:08,880 12057 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,880 | ^~~~~~~~ 2023-09-09T03:24:08,881 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeBalance(PyObject*, PyObject*)’: 2023-09-09T03:24:08,882 Box2D/Box2D_wrap.cpp:12065:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,882 12065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,883 | ^~ 2023-09-09T03:24:08,884 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-09T03:24:08,884 12065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,885 | ^~~~~~~~ 2023-09-09T03:24:08,886 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeQuality(PyObject*, PyObject*)’: 2023-09-09T03:24:08,886 Box2D/Box2D_wrap.cpp:12073:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,887 12073 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,888 | ^~ 2023-09-09T03:24:08,889 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-09T03:24:08,889 12073 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,890 | ^~~~~~~~ 2023-09-09T03:24:08,890 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,891 Box2D/Box2D_wrap.cpp:12098:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,891 12098 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,892 | ^~ 2023-09-09T03:24:08,892 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-09T03:24:08,893 12098 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2023-09-09T03:24:08,894 | ^~~~~~~~ 2023-09-09T03:24:08,902 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceProxy___get_vertex_count(PyObject*, PyObject*)’: 2023-09-09T03:24:08,903 Box2D/Box2D_wrap.cpp:12192:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,904 12192 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-09T03:24:08,904 | ^~ 2023-09-09T03:24:08,905 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-09T03:24:08,905 12192 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-09T03:24:08,906 | ^~~~~~~~ 2023-09-09T03:24:08,910 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceProxy_m_buffer_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,910 Box2D/Box2D_wrap.cpp:12226:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,911 12226 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-09T03:24:08,912 | ^~ 2023-09-09T03:24:08,912 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-09T03:24:08,913 12226 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-09T03:24:08,914 | ^~~~~~~~ 2023-09-09T03:24:08,915 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceProxy___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,915 Box2D/Box2D_wrap.cpp:12233:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,916 12233 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-09T03:24:08,917 | ^~ 2023-09-09T03:24:08,917 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-09T03:24:08,918 12233 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceProxy, 0 | 0 ); 2023-09-09T03:24:08,919 | ^~~~~~~~ 2023-09-09T03:24:08,930 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceInput_useRadii_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,931 Box2D/Box2D_wrap.cpp:12344:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,932 12344 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-09T03:24:08,932 | ^~ 2023-09-09T03:24:08,934 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-09T03:24:08,934 12344 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-09T03:24:08,935 | ^~~~~~~~ 2023-09-09T03:24:08,935 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceInput___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,936 Box2D/Box2D_wrap.cpp:12351:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,936 12351 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-09T03:24:08,937 | ^~ 2023-09-09T03:24:08,937 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-09T03:24:08,938 12351 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2023-09-09T03:24:08,938 | ^~~~~~~~ 2023-09-09T03:24:08,948 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceOutput_distance_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,949 Box2D/Box2D_wrap.cpp:12442:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,949 12442 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-09T03:24:08,950 | ^~ 2023-09-09T03:24:08,951 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-09T03:24:08,952 12442 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-09T03:24:08,952 | ^~~~~~~~ 2023-09-09T03:24:08,953 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceOutput_iterations_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,954 Box2D/Box2D_wrap.cpp:12458:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,954 12458 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-09T03:24:08,955 | ^~ 2023-09-09T03:24:08,956 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-09T03:24:08,957 12458 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-09T03:24:08,958 | ^~~~~~~~ 2023-09-09T03:24:08,958 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceOutput___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,959 Box2D/Box2D_wrap.cpp:12465:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,960 12465 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-09T03:24:08,960 | ^~ 2023-09-09T03:24:08,961 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-09T03:24:08,962 12465 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceOutput, 0 | 0 ); 2023-09-09T03:24:08,962 | ^~~~~~~~ 2023-09-09T03:24:08,963 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceOutput(PyObject*, PyObject*)’: 2023-09-09T03:24:08,964 Box2D/Box2D_wrap.cpp:12479:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,965 12479 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:08,965 | ^~ 2023-09-09T03:24:08,966 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-09T03:24:08,966 12479 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:08,967 | ^~~~~~~~ 2023-09-09T03:24:08,967 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_proxyA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,968 Box2D/Box2D_wrap.cpp:12508:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,968 12508 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,969 | ^~ 2023-09-09T03:24:08,969 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-09T03:24:08,970 12508 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,970 | ^~~~~~~~ 2023-09-09T03:24:08,971 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_proxyB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,972 Box2D/Box2D_wrap.cpp:12527:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,972 12527 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,973 | ^~ 2023-09-09T03:24:08,973 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-09T03:24:08,974 12527 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,974 | ^~~~~~~~ 2023-09-09T03:24:08,975 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_sweepA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,976 Box2D/Box2D_wrap.cpp:12545:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,976 12545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,977 | ^~ 2023-09-09T03:24:08,977 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-09T03:24:08,978 12545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,978 | ^~~~~~~~ 2023-09-09T03:24:08,979 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_sweepB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,980 Box2D/Box2D_wrap.cpp:12562:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,980 12562 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,981 | ^~ 2023-09-09T03:24:08,982 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-09T03:24:08,983 12562 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,983 | ^~~~~~~~ 2023-09-09T03:24:08,984 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_tMax_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,984 Box2D/Box2D_wrap.cpp:12578:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,985 12578 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,986 | ^~ 2023-09-09T03:24:08,986 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-09T03:24:08,987 12578 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,987 | ^~~~~~~~ 2023-09-09T03:24:08,988 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:08,988 Box2D/Box2D_wrap.cpp:12585:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,989 12585 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,990 | ^~ 2023-09-09T03:24:08,990 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-09T03:24:08,991 12585 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2023-09-09T03:24:08,991 | ^~~~~~~~ 2023-09-09T03:24:08,992 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2TOIInput(PyObject*, PyObject*)’: 2023-09-09T03:24:08,993 Box2D/Box2D_wrap.cpp:12592:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,993 12592 | if (!SWIG_Python_UnpackTuple(args, "new_b2TOIInput", 0, 0, 0)) SWIG_fail; { try { result = (b2TOIInput *)new b2TOIInput(); } 2023-09-09T03:24:08,994 | ^~ 2023-09-09T03:24:08,994 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-09T03:24:08,995 12592 | if (!SWIG_Python_UnpackTuple(args, "new_b2TOIInput", 0, 0, 0)) SWIG_fail; { try { result = (b2TOIInput *)new b2TOIInput(); } 2023-09-09T03:24:08,996 | ^ 2023-09-09T03:24:08,997 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIOutput_state_get(PyObject*, PyObject*)’: 2023-09-09T03:24:08,998 Box2D/Box2D_wrap.cpp:12625:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:08,998 12625 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-09T03:24:08,999 | ^~ 2023-09-09T03:24:09,000 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-09T03:24:09,000 12625 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-09T03:24:09,001 | ^~~~~~~~ 2023-09-09T03:24:09,002 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIOutput_t_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,003 Box2D/Box2D_wrap.cpp:12641:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,003 12641 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-09T03:24:09,004 | ^~ 2023-09-09T03:24:09,005 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-09T03:24:09,006 12641 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-09T03:24:09,007 | ^~~~~~~~ 2023-09-09T03:24:09,008 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIOutput___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,008 Box2D/Box2D_wrap.cpp:12648:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,009 12648 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-09T03:24:09,010 | ^~ 2023-09-09T03:24:09,010 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-09T03:24:09,011 12648 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2023-09-09T03:24:09,012 | ^~~~~~~~ 2023-09-09T03:24:09,012 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2TOIOutput(PyObject*, PyObject*)’: 2023-09-09T03:24:09,013 Box2D/Box2D_wrap.cpp:12655:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,013 12655 | if (!SWIG_Python_UnpackTuple(args, "new_b2TOIOutput", 0, 0, 0)) SWIG_fail; { try { result = (b2TOIOutput *)new b2TOIOutput(); } 2023-09-09T03:24:09,014 | ^~ 2023-09-09T03:24:09,014 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-09T03:24:09,015 12655 | if (!SWIG_Python_UnpackTuple(args, "new_b2TOIOutput", 0, 0, 0)) SWIG_fail; { try { result = (b2TOIOutput *)new b2TOIOutput(); } 2023-09-09T03:24:09,015 | ^ 2023-09-09T03:24:09,016 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2BodyDef(PyObject*, PyObject*)’: 2023-09-09T03:24:09,016 Box2D/Box2D_wrap.cpp:12678:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,017 12678 | if (!SWIG_Python_UnpackTuple(args, "new_b2BodyDef", 0, 0, 0)) SWIG_fail; { try { result = (b2BodyDef *)new b2BodyDef(); } 2023-09-09T03:24:09,018 | ^~ 2023-09-09T03:24:09,018 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-09T03:24:09,019 12678 | if (!SWIG_Python_UnpackTuple(args, "new_b2BodyDef", 0, 0, 0)) SWIG_fail; { try { result = (b2BodyDef *)new b2BodyDef(); } 2023-09-09T03:24:09,020 | ^ 2023-09-09T03:24:09,021 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_type_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,022 Box2D/Box2D_wrap.cpp:12693:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,022 12693 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,023 | ^~ 2023-09-09T03:24:09,024 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-09T03:24:09,024 12693 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,025 | ^~~~~~~~ 2023-09-09T03:24:09,026 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_position_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,026 Box2D/Box2D_wrap.cpp:12716:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,027 12716 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,028 | ^~ 2023-09-09T03:24:09,028 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-09T03:24:09,029 12716 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,030 | ^~~~~~~~ 2023-09-09T03:24:09,031 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angle_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,031 Box2D/Box2D_wrap.cpp:12732:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,032 12732 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,033 | ^~ 2023-09-09T03:24:09,033 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-09T03:24:09,033 12732 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,034 | ^~~~~~~~ 2023-09-09T03:24:09,035 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_linearVelocity_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,035 Box2D/Box2D_wrap.cpp:12755:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,036 12755 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,036 | ^~ 2023-09-09T03:24:09,037 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-09T03:24:09,037 12755 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,038 | ^~~~~~~~ 2023-09-09T03:24:09,038 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angularVelocity_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,039 Box2D/Box2D_wrap.cpp:12771:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,040 12771 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,040 | ^~ 2023-09-09T03:24:09,041 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-09T03:24:09,042 12771 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,042 | ^~~~~~~~ 2023-09-09T03:24:09,043 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_linearDamping_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,044 Box2D/Box2D_wrap.cpp:12787:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,045 12787 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,045 | ^~ 2023-09-09T03:24:09,046 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-09T03:24:09,047 12787 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,047 | ^~~~~~~~ 2023-09-09T03:24:09,048 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angularDamping_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,049 Box2D/Box2D_wrap.cpp:12803:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,049 12803 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,050 | ^~ 2023-09-09T03:24:09,051 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-09T03:24:09,051 12803 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,052 | ^~~~~~~~ 2023-09-09T03:24:09,053 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_allowSleep_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,054 Box2D/Box2D_wrap.cpp:12819:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,054 12819 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,055 | ^~ 2023-09-09T03:24:09,055 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-09T03:24:09,056 12819 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,056 | ^~~~~~~~ 2023-09-09T03:24:09,057 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_awake_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,057 Box2D/Box2D_wrap.cpp:12835:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,058 12835 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,058 | ^~ 2023-09-09T03:24:09,059 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-09T03:24:09,059 12835 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,060 | ^~~~~~~~ 2023-09-09T03:24:09,061 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_fixedRotation_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,061 Box2D/Box2D_wrap.cpp:12851:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,062 12851 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,063 | ^~ 2023-09-09T03:24:09,064 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-09T03:24:09,064 12851 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,065 | ^~~~~~~~ 2023-09-09T03:24:09,066 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_bullet_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,067 Box2D/Box2D_wrap.cpp:12867:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,067 12867 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,068 | ^~ 2023-09-09T03:24:09,069 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-09T03:24:09,069 12867 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,070 | ^~~~~~~~ 2023-09-09T03:24:09,071 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_active_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,071 Box2D/Box2D_wrap.cpp:12883:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,072 12883 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,073 | ^~ 2023-09-09T03:24:09,073 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-09T03:24:09,074 12883 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,075 | ^~~~~~~~ 2023-09-09T03:24:09,076 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_gravityScale_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,076 Box2D/Box2D_wrap.cpp:12899:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,077 12899 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,077 | ^~ 2023-09-09T03:24:09,078 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-09T03:24:09,078 12899 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,079 | ^~~~~~~~ 2023-09-09T03:24:09,079 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,080 Box2D/Box2D_wrap.cpp:12906:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,080 12906 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,081 | ^~ 2023-09-09T03:24:09,082 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-09T03:24:09,082 12906 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,083 | ^~~~~~~~ 2023-09-09T03:24:09,083 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef___GetUserData(PyObject*, PyObject*)’: 2023-09-09T03:24:09,084 Box2D/Box2D_wrap.cpp:12914:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,085 12914 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,086 | ^~ 2023-09-09T03:24:09,086 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-09T03:24:09,087 12914 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2023-09-09T03:24:09,088 | ^~~~~~~~ 2023-09-09T03:24:09,088 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___CreateFixture__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,089 Box2D/Box2D_wrap.cpp:12956:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,090 12956 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,091 | ^~ 2023-09-09T03:24:09,091 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-09T03:24:09,092 12956 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,092 | ^~~~ 2023-09-09T03:24:09,093 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetTransform(PyObject*, PyObject*)’: 2023-09-09T03:24:09,094 Box2D/Box2D_wrap.cpp:12989:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,095 12989 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,095 | ^~ 2023-09-09T03:24:09,096 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-09T03:24:09,097 12989 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,098 | ^~~~~~~~ 2023-09-09T03:24:09,098 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetPosition(PyObject*, PyObject*)’: 2023-09-09T03:24:09,099 Box2D/Box2D_wrap.cpp:12998:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,099 12998 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,100 | ^~ 2023-09-09T03:24:09,100 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-09T03:24:09,101 12998 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,101 | ^~~~~~~~ 2023-09-09T03:24:09,102 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorldCenter(PyObject*, PyObject*)’: 2023-09-09T03:24:09,102 Box2D/Box2D_wrap.cpp:13013:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,103 13013 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,103 | ^~ 2023-09-09T03:24:09,104 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-09T03:24:09,104 13013 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,105 | ^~~~~~~~ 2023-09-09T03:24:09,106 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetLocalCenter(PyObject*, PyObject*)’: 2023-09-09T03:24:09,107 Box2D/Box2D_wrap.cpp:13021:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,107 13021 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,108 | ^~ 2023-09-09T03:24:09,109 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-09T03:24:09,109 13021 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,110 | ^~~~~~~~ 2023-09-09T03:24:09,111 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetLinearVelocity(PyObject*, PyObject*)’: 2023-09-09T03:24:09,112 Box2D/Box2D_wrap.cpp:13046:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,112 13046 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,113 | ^~ 2023-09-09T03:24:09,114 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-09T03:24:09,114 13046 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,115 | ^~~~~~~~ 2023-09-09T03:24:09,170 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetType(PyObject*, PyObject*)’: 2023-09-09T03:24:09,170 Box2D/Box2D_wrap.cpp:13399:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,171 13399 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,172 | ^~ 2023-09-09T03:24:09,173 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-09T03:24:09,173 13399 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,174 | ^~~~~~~~ 2023-09-09T03:24:09,188 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,189 Box2D/Box2D_wrap.cpp:13492:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,190 13492 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,190 | ^~ 2023-09-09T03:24:09,191 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-09T03:24:09,191 13492 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,192 | ^~~~ 2023-09-09T03:24:09,192 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,193 Box2D/Box2D_wrap.cpp:13500:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,193 13500 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,194 | ^~ 2023-09-09T03:24:09,194 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-09T03:24:09,195 13500 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,196 | ^~~~ 2023-09-09T03:24:09,196 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal(PyObject*, PyObject*)’: 2023-09-09T03:24:09,197 Box2D/Box2D_wrap.cpp:13508:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,198 13508 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetFixtureList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,198 | ^~ 2023-09-09T03:24:09,199 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-09T03:24:09,200 13508 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetFixtureList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,200 | ^~ 2023-09-09T03:24:09,201 Box2D/Box2D_wrap.cpp:13510:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,202 13510 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,202 | ^~ 2023-09-09T03:24:09,203 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-09T03:24:09,204 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,204 | ^~~~ 2023-09-09T03:24:09,205 Box2D/Box2D_wrap.cpp:13510:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,206 13510 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,206 | ^~~~~~~~~ 2023-09-09T03:24:09,207 Box2D/Box2D_wrap.cpp:13512:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,208 13512 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,208 | ^~ 2023-09-09T03:24:09,209 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-09T03:24:09,210 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,210 | ^~~~ 2023-09-09T03:24:09,211 Box2D/Box2D_wrap.cpp:13512:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,211 13512 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,212 | ^~~~~~~~~ 2023-09-09T03:24:09,212 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,213 Box2D/Box2D_wrap.cpp:13517:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,213 13517 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,214 | ^~ 2023-09-09T03:24:09,214 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-09T03:24:09,215 13517 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,215 | ^~~~ 2023-09-09T03:24:09,216 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,216 Box2D/Box2D_wrap.cpp:13526:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,217 13526 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,217 | ^~ 2023-09-09T03:24:09,218 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-09T03:24:09,219 13526 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,220 | ^~~~ 2023-09-09T03:24:09,220 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal(PyObject*, PyObject*)’: 2023-09-09T03:24:09,221 Box2D/Box2D_wrap.cpp:13535:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,222 13535 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,222 | ^~ 2023-09-09T03:24:09,223 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-09T03:24:09,223 13535 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,224 | ^~ 2023-09-09T03:24:09,224 Box2D/Box2D_wrap.cpp:13537:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,225 13537 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,226 | ^~ 2023-09-09T03:24:09,226 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-09T03:24:09,227 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,228 | ^~~~ 2023-09-09T03:24:09,228 Box2D/Box2D_wrap.cpp:13537:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,229 13537 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,230 | ^~~~~~~~~ 2023-09-09T03:24:09,230 Box2D/Box2D_wrap.cpp:13539:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,231 13539 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,231 | ^~ 2023-09-09T03:24:09,232 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-09T03:24:09,232 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,233 | ^~~~ 2023-09-09T03:24:09,233 Box2D/Box2D_wrap.cpp:13539:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,234 13539 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,234 | ^~~~~~~~~ 2023-09-09T03:24:09,235 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetContactList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,235 Box2D/Box2D_wrap.cpp:13544:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,236 13544 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,236 | ^~ 2023-09-09T03:24:09,237 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-09T03:24:09,237 13544 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,238 | ^~~~ 2023-09-09T03:24:09,238 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetContactList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,239 Box2D/Box2D_wrap.cpp:13553:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,240 13553 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,240 | ^~ 2023-09-09T03:24:09,241 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-09T03:24:09,242 13553 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,243 | ^~~~ 2023-09-09T03:24:09,243 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetContactList_internal(PyObject*, PyObject*)’: 2023-09-09T03:24:09,244 Box2D/Box2D_wrap.cpp:13562:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,244 13562 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,245 | ^~ 2023-09-09T03:24:09,246 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-09T03:24:09,246 13562 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,247 | ^~ 2023-09-09T03:24:09,248 Box2D/Box2D_wrap.cpp:13564:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,248 13564 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,249 | ^~ 2023-09-09T03:24:09,249 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-09T03:24:09,250 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,250 | ^~~~ 2023-09-09T03:24:09,251 Box2D/Box2D_wrap.cpp:13564:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,251 13564 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,252 | ^~~~~~~~~ 2023-09-09T03:24:09,252 Box2D/Box2D_wrap.cpp:13566:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,253 13566 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,253 | ^~ 2023-09-09T03:24:09,254 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-09T03:24:09,254 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,255 | ^~~~ 2023-09-09T03:24:09,255 Box2D/Box2D_wrap.cpp:13566:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,256 13566 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,256 | ^~~~~~~~~ 2023-09-09T03:24:09,257 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,258 Box2D/Box2D_wrap.cpp:13571:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,258 13571 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,259 | ^~ 2023-09-09T03:24:09,259 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-09T03:24:09,260 13571 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,261 | ^~~~ 2023-09-09T03:24:09,262 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,262 Box2D/Box2D_wrap.cpp:13579:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,263 13579 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,264 | ^~ 2023-09-09T03:24:09,264 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-09T03:24:09,265 13579 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,265 | ^~~~ 2023-09-09T03:24:09,266 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext(PyObject*, PyObject*)’: 2023-09-09T03:24:09,267 Box2D/Box2D_wrap.cpp:13586:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,267 13586 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,268 | ^~ 2023-09-09T03:24:09,269 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-09T03:24:09,270 13586 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,271 | ^~ 2023-09-09T03:24:09,271 Box2D/Box2D_wrap.cpp:13588:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,272 13588 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,272 | ^~ 2023-09-09T03:24:09,273 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-09T03:24:09,273 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,274 | ^~~~ 2023-09-09T03:24:09,274 Box2D/Box2D_wrap.cpp:13588:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,275 13588 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,275 | ^~~~~~~~~ 2023-09-09T03:24:09,276 Box2D/Box2D_wrap.cpp:13590:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,276 13590 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,277 | ^~ 2023-09-09T03:24:09,277 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-09T03:24:09,278 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,279 | ^~~~ 2023-09-09T03:24:09,279 Box2D/Box2D_wrap.cpp:13590:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,280 13590 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,280 | ^~~~~~~~~ 2023-09-09T03:24:09,281 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,282 Box2D/Box2D_wrap.cpp:13595:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,282 13595 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,283 | ^~ 2023-09-09T03:24:09,284 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-09T03:24:09,285 13595 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,285 | ^~~~ 2023-09-09T03:24:09,286 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,287 Box2D/Box2D_wrap.cpp:13603:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,287 13603 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,288 | ^~ 2023-09-09T03:24:09,288 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-09T03:24:09,289 13603 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,290 | ^~~~ 2023-09-09T03:24:09,291 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld(PyObject*, PyObject*)’: 2023-09-09T03:24:09,291 Box2D/Box2D_wrap.cpp:13610:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,292 13610 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetWorld", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,293 | ^~ 2023-09-09T03:24:09,293 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-09T03:24:09,294 13610 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetWorld", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,294 | ^~ 2023-09-09T03:24:09,295 Box2D/Box2D_wrap.cpp:13612:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,296 13612 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,296 | ^~ 2023-09-09T03:24:09,297 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-09T03:24:09,297 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,298 | ^~~~ 2023-09-09T03:24:09,298 Box2D/Box2D_wrap.cpp:13612:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,299 13612 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,299 | ^~~~~~~~~ 2023-09-09T03:24:09,300 Box2D/Box2D_wrap.cpp:13614:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,300 13614 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,301 | ^~ 2023-09-09T03:24:09,302 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-09T03:24:09,302 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,303 | ^~~~ 2023-09-09T03:24:09,304 Box2D/Box2D_wrap.cpp:13614:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,304 13614 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,305 | ^~~~~~~~~ 2023-09-09T03:24:09,306 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___CreateFixture(PyObject*, PyObject*)’: 2023-09-09T03:24:09,307 Box2D/Box2D_wrap.cpp:13653:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,307 13653 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___CreateFixture", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:09,308 | ^~ 2023-09-09T03:24:09,308 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-09T03:24:09,309 13653 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___CreateFixture", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2023-09-09T03:24:09,310 | ^~ 2023-09-09T03:24:09,310 Box2D/Box2D_wrap.cpp:13655:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,311 13655 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:09,312 | ^~ 2023-09-09T03:24:09,313 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-09T03:24:09,313 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,314 | ^~~~ 2023-09-09T03:24:09,315 Box2D/Box2D_wrap.cpp:13655:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,315 13655 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2023-09-09T03:24:09,316 | ^~~~~~~~~ 2023-09-09T03:24:09,316 Box2D/Box2D_wrap.cpp:13657:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,317 13657 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,317 | ^~ 2023-09-09T03:24:09,318 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-09T03:24:09,318 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,318 | ^~~~ 2023-09-09T03:24:09,319 Box2D/Box2D_wrap.cpp:13657:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,319 13657 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,320 | ^~~~~~~~~ 2023-09-09T03:24:09,320 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetUserData(PyObject*, PyObject*)’: 2023-09-09T03:24:09,321 Box2D/Box2D_wrap.cpp:13663:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,322 13663 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,322 | ^~ 2023-09-09T03:24:09,323 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-09T03:24:09,324 13663 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2023-09-09T03:24:09,325 | ^~~~~~~~ 2023-09-09T03:24:09,325 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Filter(PyObject*, PyObject*)’: 2023-09-09T03:24:09,326 Box2D/Box2D_wrap.cpp:13692:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,326 13692 | if (!SWIG_Python_UnpackTuple(args, "new_b2Filter", 0, 0, 0)) SWIG_fail; { try { result = (b2Filter *)new b2Filter(); } 2023-09-09T03:24:09,327 | ^~ 2023-09-09T03:24:09,328 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-09T03:24:09,329 13692 | if (!SWIG_Python_UnpackTuple(args, "new_b2Filter", 0, 0, 0)) SWIG_fail; { try { result = (b2Filter *)new b2Filter(); } 2023-09-09T03:24:09,329 | ^ 2023-09-09T03:24:09,330 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Filter_categoryBits_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,330 Box2D/Box2D_wrap.cpp:13708:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,331 13708 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2023-09-09T03:24:09,332 | ^~ 2023-09-09T03:24:09,332 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-09T03:24:09,333 13708 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2023-09-09T03:24:09,334 | ^~~~~~~~ 2023-09-09T03:24:09,335 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Filter_maskBits_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,335 Box2D/Box2D_wrap.cpp:13725:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,336 13725 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2023-09-09T03:24:09,337 | ^~ 2023-09-09T03:24:09,337 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-09T03:24:09,338 13725 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2023-09-09T03:24:09,338 | ^~~~~~~~ 2023-09-09T03:24:09,339 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_shape_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,339 Box2D/Box2D_wrap.cpp:13788:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,340 13788 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,341 | ^~ 2023-09-09T03:24:09,341 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-09T03:24:09,342 13788 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,342 | ^~~~~~~~ 2023-09-09T03:24:09,343 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_friction_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,343 Box2D/Box2D_wrap.cpp:13810:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,344 13810 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,345 | ^~ 2023-09-09T03:24:09,345 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-09T03:24:09,346 13810 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,347 | ^~~~~~~~ 2023-09-09T03:24:09,348 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_restitution_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,348 Box2D/Box2D_wrap.cpp:13826:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,349 13826 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,350 | ^~ 2023-09-09T03:24:09,350 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-09T03:24:09,351 13826 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,352 | ^~~~~~~~ 2023-09-09T03:24:09,352 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_density_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,353 Box2D/Box2D_wrap.cpp:13842:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,354 13842 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,354 | ^~ 2023-09-09T03:24:09,355 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-09T03:24:09,356 13842 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,356 | ^~~~~~~~ 2023-09-09T03:24:09,357 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_isSensor_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,358 Box2D/Box2D_wrap.cpp:13858:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,358 13858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,359 | ^~ 2023-09-09T03:24:09,359 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-09T03:24:09,360 13858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,360 | ^~~~~~~~ 2023-09-09T03:24:09,361 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_filter_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,361 Box2D/Box2D_wrap.cpp:13876:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,362 13876 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,362 | ^~ 2023-09-09T03:24:09,363 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-09T03:24:09,363 13876 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,364 | ^~~~~~~~ 2023-09-09T03:24:09,364 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,365 Box2D/Box2D_wrap.cpp:13883:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,365 13883 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,366 | ^~ 2023-09-09T03:24:09,367 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-09T03:24:09,367 13883 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,368 | ^~~~~~~~ 2023-09-09T03:24:09,369 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef___GetUserData(PyObject*, PyObject*)’: 2023-09-09T03:24:09,369 Box2D/Box2D_wrap.cpp:13891:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,370 13891 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,371 | ^~ 2023-09-09T03:24:09,372 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-09T03:24:09,372 13891 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2023-09-09T03:24:09,373 | ^~~~~~~~ 2023-09-09T03:24:09,374 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy_aabb_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,374 Box2D/Box2D_wrap.cpp:13943:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,375 13943 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,376 | ^~ 2023-09-09T03:24:09,376 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-09T03:24:09,377 13943 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,378 | ^~~~~~~~ 2023-09-09T03:24:09,378 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy_fixture_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,379 Box2D/Box2D_wrap.cpp:13961:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,380 13961 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,380 | ^~ 2023-09-09T03:24:09,381 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-09T03:24:09,381 13961 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,382 | ^~~~~~~~ 2023-09-09T03:24:09,382 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy_childIndex_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,383 Box2D/Box2D_wrap.cpp:13977:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,383 13977 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,384 | ^~ 2023-09-09T03:24:09,384 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-09T03:24:09,385 13977 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,385 | ^~~~~~~~ 2023-09-09T03:24:09,386 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy_proxyId_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,387 Box2D/Box2D_wrap.cpp:13993:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,387 13993 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,388 | ^~ 2023-09-09T03:24:09,388 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-09T03:24:09,389 13993 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,390 | ^~~~~~~~ 2023-09-09T03:24:09,390 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureProxy___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,391 Box2D/Box2D_wrap.cpp:14000:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,392 14000 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,392 | ^~ 2023-09-09T03:24:09,393 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-09T03:24:09,394 14000 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureProxy, 0 | 0 ); 2023-09-09T03:24:09,394 | ^~~~~~~~ 2023-09-09T03:24:09,395 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetType(PyObject*, PyObject*)’: 2023-09-09T03:24:09,396 Box2D/Box2D_wrap.cpp:14032:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,396 14032 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,397 | ^~ 2023-09-09T03:24:09,398 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-09T03:24:09,398 14032 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,399 | ^~~~~~~~ 2023-09-09T03:24:09,400 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetShape__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,400 Box2D/Box2D_wrap.cpp:14040:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,400 14040 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,401 | ^~ 2023-09-09T03:24:09,401 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-09T03:24:09,402 14040 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,402 | ^~~~ 2023-09-09T03:24:09,403 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetShape__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,403 Box2D/Box2D_wrap.cpp:14053:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,404 14053 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,404 | ^~ 2023-09-09T03:24:09,405 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-09T03:24:09,405 14053 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,406 | ^~~~ 2023-09-09T03:24:09,407 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetShape(PyObject*, PyObject*)’: 2023-09-09T03:24:09,408 Box2D/Box2D_wrap.cpp:14066:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,408 14066 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetShape", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,409 | ^~ 2023-09-09T03:24:09,409 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-09T03:24:09,410 14066 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetShape", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,411 | ^~ 2023-09-09T03:24:09,412 Box2D/Box2D_wrap.cpp:14068:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,412 14068 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,413 | ^~ 2023-09-09T03:24:09,414 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-09T03:24:09,414 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,415 | ^~~~ 2023-09-09T03:24:09,416 Box2D/Box2D_wrap.cpp:14068:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,416 14068 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,417 | ^~~~~~~~~ 2023-09-09T03:24:09,417 Box2D/Box2D_wrap.cpp:14070:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,418 14070 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,419 | ^~ 2023-09-09T03:24:09,420 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-09T03:24:09,420 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,421 | ^~~~ 2023-09-09T03:24:09,421 Box2D/Box2D_wrap.cpp:14070:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,422 14070 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,422 | ^~~~~~~~~ 2023-09-09T03:24:09,423 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___IsSensor(PyObject*, PyObject*)’: 2023-09-09T03:24:09,424 Box2D/Box2D_wrap.cpp:14085:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,424 14085 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,425 | ^~ 2023-09-09T03:24:09,425 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-09T03:24:09,426 14085 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,426 | ^~~~~~~~ 2023-09-09T03:24:09,427 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetFilterData(PyObject*, PyObject*)’: 2023-09-09T03:24:09,427 Box2D/Box2D_wrap.cpp:14108:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,428 14108 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,428 | ^~ 2023-09-09T03:24:09,429 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-09T03:24:09,430 14108 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,431 | ^~~~~~~~ 2023-09-09T03:24:09,431 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,432 Box2D/Box2D_wrap.cpp:14122:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,432 14122 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,433 | ^~ 2023-09-09T03:24:09,434 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-09T03:24:09,434 14122 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,435 | ^~~~ 2023-09-09T03:24:09,436 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,436 Box2D/Box2D_wrap.cpp:14130:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,437 14130 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,437 | ^~ 2023-09-09T03:24:09,438 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-09T03:24:09,439 14130 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,440 | ^~~~ 2023-09-09T03:24:09,440 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody(PyObject*, PyObject*)’: 2023-09-09T03:24:09,441 Box2D/Box2D_wrap.cpp:14137:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,441 14137 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetBody", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,442 | ^~ 2023-09-09T03:24:09,443 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-09T03:24:09,443 14137 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetBody", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,444 | ^~ 2023-09-09T03:24:09,444 Box2D/Box2D_wrap.cpp:14139:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,445 14139 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,445 | ^~ 2023-09-09T03:24:09,446 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-09T03:24:09,446 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,447 | ^~~~ 2023-09-09T03:24:09,447 Box2D/Box2D_wrap.cpp:14139:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,448 14139 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,449 | ^~~~~~~~~ 2023-09-09T03:24:09,449 Box2D/Box2D_wrap.cpp:14141:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,450 14141 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,450 | ^~ 2023-09-09T03:24:09,451 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-09T03:24:09,452 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,452 | ^~~~ 2023-09-09T03:24:09,453 Box2D/Box2D_wrap.cpp:14141:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,453 14141 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,454 | ^~~~~~~~~ 2023-09-09T03:24:09,455 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,456 Box2D/Box2D_wrap.cpp:14146:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,456 14146 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,457 | ^~ 2023-09-09T03:24:09,457 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-09T03:24:09,458 14146 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,458 | ^~~~ 2023-09-09T03:24:09,459 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,460 Box2D/Box2D_wrap.cpp:14154:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,460 14154 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,461 | ^~ 2023-09-09T03:24:09,462 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-09T03:24:09,463 14154 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,463 | ^~~~ 2023-09-09T03:24:09,464 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetNext(PyObject*, PyObject*)’: 2023-09-09T03:24:09,464 Box2D/Box2D_wrap.cpp:14161:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,465 14161 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,465 | ^~ 2023-09-09T03:24:09,466 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-09T03:24:09,466 14161 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,467 | ^~ 2023-09-09T03:24:09,467 Box2D/Box2D_wrap.cpp:14163:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,468 14163 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,468 | ^~ 2023-09-09T03:24:09,469 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-09T03:24:09,470 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,470 | ^~~~ 2023-09-09T03:24:09,471 Box2D/Box2D_wrap.cpp:14163:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,471 14163 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,472 | ^~~~~~~~~ 2023-09-09T03:24:09,473 Box2D/Box2D_wrap.cpp:14165:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,473 14165 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,474 | ^~ 2023-09-09T03:24:09,475 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-09T03:24:09,476 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,476 | ^~~~ 2023-09-09T03:24:09,477 Box2D/Box2D_wrap.cpp:14165:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,478 14165 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,478 | ^~~~~~~~~ 2023-09-09T03:24:09,479 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetDensity(PyObject*, PyObject*)’: 2023-09-09T03:24:09,480 Box2D/Box2D_wrap.cpp:14232:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,480 14232 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,481 | ^~ 2023-09-09T03:24:09,482 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-09T03:24:09,483 14232 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,483 | ^~~~~~~~ 2023-09-09T03:24:09,484 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetFriction(PyObject*, PyObject*)’: 2023-09-09T03:24:09,485 Box2D/Box2D_wrap.cpp:14240:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,485 14240 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,486 | ^~ 2023-09-09T03:24:09,486 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-09T03:24:09,487 14240 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,488 | ^~~~~~~~ 2023-09-09T03:24:09,488 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetRestitution(PyObject*, PyObject*)’: 2023-09-09T03:24:09,489 Box2D/Box2D_wrap.cpp:14258:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,489 14258 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,490 | ^~ 2023-09-09T03:24:09,490 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-09T03:24:09,495 14258 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,496 | ^~~~~~~~ 2023-09-09T03:24:09,496 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,497 Box2D/Box2D_wrap.cpp:14298:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,498 14298 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,499 | ^~ 2023-09-09T03:24:09,500 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-09T03:24:09,501 14298 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,502 | ^~~~~~~~ 2023-09-09T03:24:09,502 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetUserData(PyObject*, PyObject*)’: 2023-09-09T03:24:09,503 Box2D/Box2D_wrap.cpp:14306:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,504 14306 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,505 | ^~ 2023-09-09T03:24:09,506 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-09T03:24:09,506 14306 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2023-09-09T03:24:09,507 | ^~~~~~~~ 2023-09-09T03:24:09,508 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DestructionListener(PyObject*, PyObject*)’: 2023-09-09T03:24:09,508 Box2D/Box2D_wrap.cpp:14343:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,509 14343 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,509 | ^~ 2023-09-09T03:24:09,510 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-09T03:24:09,511 14343 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,512 | ^~~~~~~~ 2023-09-09T03:24:09,512 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DestructionListener_SayGoodbye(PyObject*, PyObject*)’: 2023-09-09T03:24:09,513 Box2D/Box2D_wrap.cpp:14379:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,514 14379 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2DestructionListener_SayGoodbye", 0, 2, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,515 | ^~ 2023-09-09T03:24:09,515 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-09T03:24:09,516 14379 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2DestructionListener_SayGoodbye", 0, 2, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,516 | ^~ 2023-09-09T03:24:09,517 Box2D/Box2D_wrap.cpp:14384:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,517 14384 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,518 | ^~ 2023-09-09T03:24:09,518 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-09T03:24:09,519 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,519 | ^~~~ 2023-09-09T03:24:09,520 Box2D/Box2D_wrap.cpp:14384:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,521 14384 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,521 | ^~~~~~~~~ 2023-09-09T03:24:09,522 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2DestructionListener(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,523 Box2D/Box2D_wrap.cpp:14399:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,524 14399 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DestructionListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,524 | ^~ 2023-09-09T03:24:09,525 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-09T03:24:09,526 14399 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DestructionListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,527 | ^~~~ 2023-09-09T03:24:09,527 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactFilter___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,528 Box2D/Box2D_wrap.cpp:14454:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,529 14454 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFilter, 0 | 0 ); 2023-09-09T03:24:09,530 | ^~ 2023-09-09T03:24:09,531 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-09T03:24:09,531 14454 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactFilter, 0 | 0 ); 2023-09-09T03:24:09,532 | ^~~~~~~~ 2023-09-09T03:24:09,533 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2ContactFilter(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,533 Box2D/Box2D_wrap.cpp:14463:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,534 14463 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactFilter", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,535 | ^~ 2023-09-09T03:24:09,535 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-09T03:24:09,536 14463 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactFilter", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,536 | ^~~~ 2023-09-09T03:24:09,537 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactImpulse_count_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,537 Box2D/Box2D_wrap.cpp:14499:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,538 14499 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactImpulse, 0 | 0 ); 2023-09-09T03:24:09,539 | ^~ 2023-09-09T03:24:09,539 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-09T03:24:09,540 14499 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactImpulse, 0 | 0 ); 2023-09-09T03:24:09,540 | ^~~~~~~~ 2023-09-09T03:24:09,541 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactImpulse___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,541 Box2D/Box2D_wrap.cpp:14506:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,542 14506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactImpulse, 0 | 0 ); 2023-09-09T03:24:09,542 | ^~ 2023-09-09T03:24:09,543 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-09T03:24:09,544 14506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactImpulse, 0 | 0 ); 2023-09-09T03:24:09,544 | ^~~~~~~~ 2023-09-09T03:24:09,545 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactImpulse(PyObject*, PyObject*)’: 2023-09-09T03:24:09,546 Box2D/Box2D_wrap.cpp:14536:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,546 14536 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,547 | ^~ 2023-09-09T03:24:09,548 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-09T03:24:09,549 14536 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,549 | ^~~~~~~~ 2023-09-09T03:24:09,550 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactListener(PyObject*, PyObject*)’: 2023-09-09T03:24:09,551 Box2D/Box2D_wrap.cpp:14554:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,551 14554 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,552 | ^~ 2023-09-09T03:24:09,552 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-09T03:24:09,553 14554 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,554 | ^~~~~~~~ 2023-09-09T03:24:09,554 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactListener___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,555 Box2D/Box2D_wrap.cpp:14632:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,556 14632 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactListener, 0 | 0 ); 2023-09-09T03:24:09,556 | ^~ 2023-09-09T03:24:09,557 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-09T03:24:09,558 14632 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactListener, 0 | 0 ); 2023-09-09T03:24:09,559 | ^~~~~~~~ 2023-09-09T03:24:09,559 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2ContactListener(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,560 Box2D/Box2D_wrap.cpp:14641:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,560 14641 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,561 | ^~ 2023-09-09T03:24:09,561 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-09T03:24:09,562 14641 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,562 | ^~~~ 2023-09-09T03:24:09,563 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2QueryCallback___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,563 Box2D/Box2D_wrap.cpp:14691:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,564 14691 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2QueryCallback, 0 | 0 ); 2023-09-09T03:24:09,564 | ^~ 2023-09-09T03:24:09,565 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-09T03:24:09,565 14691 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2QueryCallback, 0 | 0 ); 2023-09-09T03:24:09,566 | ^~~~~~~~ 2023-09-09T03:24:09,567 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2QueryCallback(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,567 Box2D/Box2D_wrap.cpp:14700:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,568 14700 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2QueryCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,569 | ^~ 2023-09-09T03:24:09,569 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-09T03:24:09,570 14700 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2QueryCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,570 | ^~~~ 2023-09-09T03:24:09,571 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RayCastCallback(PyObject*, PyObject*)’: 2023-09-09T03:24:09,572 Box2D/Box2D_wrap.cpp:14727:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,572 14727 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,573 | ^~ 2023-09-09T03:24:09,573 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-09T03:24:09,574 14727 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,575 | ^~~~~~~~ 2023-09-09T03:24:09,576 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RayCastCallback___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,576 Box2D/Box2D_wrap.cpp:14772:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,577 14772 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastCallback, 0 | 0 ); 2023-09-09T03:24:09,578 | ^~ 2023-09-09T03:24:09,578 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-09T03:24:09,579 14772 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RayCastCallback, 0 | 0 ); 2023-09-09T03:24:09,579 | ^~~~~~~~ 2023-09-09T03:24:09,580 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2RayCastCallback(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,580 Box2D/Box2D_wrap.cpp:14781:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,581 14781 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2RayCastCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,581 | ^~ 2023-09-09T03:24:09,582 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-09T03:24:09,582 14781 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2RayCastCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2023-09-09T03:24:09,583 | ^~~~ 2023-09-09T03:24:09,583 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_step_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,584 Box2D/Box2D_wrap.cpp:14817:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,584 14817 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,585 | ^~ 2023-09-09T03:24:09,585 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-09T03:24:09,586 14817 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,587 | ^~~~~~~~ 2023-09-09T03:24:09,587 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_collide_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,588 Box2D/Box2D_wrap.cpp:14833:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,588 14833 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,589 | ^~ 2023-09-09T03:24:09,590 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-09T03:24:09,590 14833 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,591 | ^~~~~~~~ 2023-09-09T03:24:09,592 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solve_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,592 Box2D/Box2D_wrap.cpp:14849:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,593 14849 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,594 | ^~ 2023-09-09T03:24:09,594 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-09T03:24:09,595 14849 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,595 | ^~~~~~~~ 2023-09-09T03:24:09,596 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveInit_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,597 Box2D/Box2D_wrap.cpp:14865:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,597 14865 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,598 | ^~ 2023-09-09T03:24:09,599 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-09T03:24:09,599 14865 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,600 | ^~~~~~~~ 2023-09-09T03:24:09,600 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveVelocity_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,601 Box2D/Box2D_wrap.cpp:14881:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,601 14881 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,602 | ^~ 2023-09-09T03:24:09,602 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-09T03:24:09,603 14881 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,603 | ^~~~~~~~ 2023-09-09T03:24:09,604 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solvePosition_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,605 Box2D/Box2D_wrap.cpp:14897:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,605 14897 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,606 | ^~ 2023-09-09T03:24:09,606 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-09T03:24:09,607 14897 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,607 | ^~~~~~~~ 2023-09-09T03:24:09,608 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_broadphase_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,609 Box2D/Box2D_wrap.cpp:14913:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,609 14913 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,610 | ^~ 2023-09-09T03:24:09,611 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-09T03:24:09,611 14913 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,612 | ^~~~~~~~ 2023-09-09T03:24:09,612 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveTOI_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,613 Box2D/Box2D_wrap.cpp:14929:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,614 14929 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,614 | ^~ 2023-09-09T03:24:09,615 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-09T03:24:09,616 14929 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2023-09-09T03:24:09,616 | ^~~~~~~~ 2023-09-09T03:24:09,617 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Profile(PyObject*, PyObject*)’: 2023-09-09T03:24:09,618 Box2D/Box2D_wrap.cpp:14935:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,619 14935 | if (!SWIG_Python_UnpackTuple(args, "new_b2Profile", 0, 0, 0)) SWIG_fail; { try { result = (b2Profile *)new b2Profile(); } 2023-09-09T03:24:09,619 | ^~ 2023-09-09T03:24:09,620 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-09T03:24:09,620 14935 | if (!SWIG_Python_UnpackTuple(args, "new_b2Profile", 0, 0, 0)) SWIG_fail; { try { result = (b2Profile *)new b2Profile(); } 2023-09-09T03:24:09,621 | ^ 2023-09-09T03:24:09,621 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2SolverData_step_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,622 Box2D/Box2D_wrap.cpp:14970:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,622 14970 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-09T03:24:09,623 | ^~ 2023-09-09T03:24:09,623 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-09T03:24:09,624 14970 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-09T03:24:09,624 | ^~~~~~~~ 2023-09-09T03:24:09,625 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2SolverData_positions_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,625 Box2D/Box2D_wrap.cpp:14988:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,626 14988 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-09T03:24:09,626 | ^~ 2023-09-09T03:24:09,627 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-09T03:24:09,628 14988 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-09T03:24:09,628 | ^~~~~~~~ 2023-09-09T03:24:09,629 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2SolverData_velocities_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,630 Box2D/Box2D_wrap.cpp:15006:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,630 15006 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-09T03:24:09,631 | ^~ 2023-09-09T03:24:09,632 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-09T03:24:09,632 15006 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2SolverData, 0 | 0 ); 2023-09-09T03:24:09,633 | ^~~~~~~~ 2023-09-09T03:24:09,634 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager_FindNewContacts(PyObject*, PyObject*)’: 2023-09-09T03:24:09,634 Box2D/Box2D_wrap.cpp:15060:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,635 15060 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-09T03:24:09,636 | ^~ 2023-09-09T03:24:09,636 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-09T03:24:09,637 15060 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-09T03:24:09,638 | ^~~~~~~~ 2023-09-09T03:24:09,638 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager_Collide(PyObject*, PyObject*)’: 2023-09-09T03:24:09,639 Box2D/Box2D_wrap.cpp:15079:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,640 15079 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-09T03:24:09,640 | ^~ 2023-09-09T03:24:09,641 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-09T03:24:09,641 15079 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-09T03:24:09,642 | ^~~~~~~~ 2023-09-09T03:24:09,642 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager_contactCount_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,643 Box2D/Box2D_wrap.cpp:15132:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,643 15132 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-09T03:24:09,644 | ^~ 2023-09-09T03:24:09,644 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-09T03:24:09,645 15132 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-09T03:24:09,645 | ^~~~~~~~ 2023-09-09T03:24:09,651 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,652 Box2D/Box2D_wrap.cpp:15198:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,652 15198 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-09T03:24:09,653 | ^~ 2023-09-09T03:24:09,653 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-09T03:24:09,654 15198 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2023-09-09T03:24:09,655 | ^~~~~~~~ 2023-09-09T03:24:09,655 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactManager(PyObject*, PyObject*)’: 2023-09-09T03:24:09,656 Box2D/Box2D_wrap.cpp:15206:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,657 15206 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,657 | ^~ 2023-09-09T03:24:09,658 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-09T03:24:09,659 15206 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:09,659 | ^~~~~~~~ 2023-09-09T03:24:09,673 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_Step(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,674 Box2D/Box2D_wrap.cpp:15308:92: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-09T03:24:09,674 15308 | arg4 = static_cast< int32 >(val4); { try { (arg1)->Step(arg2,arg3,arg4); } catch (Swig::DirectorException) { SWIG_fail; } 2023-09-09T03:24:09,675 | ^~~~~~~~~~~~~~~~~ 2023-09-09T03:24:09,677 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DrawDebugData(PyObject*, PyObject*)’: 2023-09-09T03:24:09,678 Box2D/Box2D_wrap.cpp:15320:98: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-09T03:24:09,678 15320 | arg1 = reinterpret_cast< b2World * >(argp1); { try { (arg1)->DrawDebugData(); } catch (Swig::DirectorException) { 2023-09-09T03:24:09,679 | ^~~~~~~~~~~~~~~~~ 2023-09-09T03:24:09,681 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_QueryAABB(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,681 Box2D/Box2D_wrap.cpp:15339:18: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-09T03:24:09,682 15339 | catch (Swig::DirectorException) { SWIG_fail; } catch (b2AssertException) { SWIG_fail; } } resultobj = SWIG_Py_Void(); 2023-09-09T03:24:09,682 | ^~~~~~~~~~~~~~~~~ 2023-09-09T03:24:09,687 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_RayCast(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,688 Box2D/Box2D_wrap.cpp:15369:107: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-09T03:24:09,688 15369 | ((b2World const *)arg1)->RayCast(arg2,(b2Vec2 const &)*arg3,(b2Vec2 const &)*arg4); } catch (Swig::DirectorException) { 2023-09-09T03:24:09,689 | ^~~~~~~~~~~~~~~~~ 2023-09-09T03:24:09,689 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,690 Box2D/Box2D_wrap.cpp:15374:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,691 15374 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,691 | ^~ 2023-09-09T03:24:09,692 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-09T03:24:09,692 15374 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,693 | ^~~~ 2023-09-09T03:24:09,694 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,694 Box2D/Box2D_wrap.cpp:15382:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,695 15382 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,695 | ^~ 2023-09-09T03:24:09,696 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-09T03:24:09,697 15382 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,697 | ^~~~ 2023-09-09T03:24:09,698 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal(PyObject*, PyObject*)’: 2023-09-09T03:24:09,698 Box2D/Box2D_wrap.cpp:15390:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,699 15390 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetBodyList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,699 | ^~ 2023-09-09T03:24:09,700 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-09T03:24:09,701 15390 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetBodyList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,702 | ^~ 2023-09-09T03:24:09,702 Box2D/Box2D_wrap.cpp:15392:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,703 15392 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,704 | ^~ 2023-09-09T03:24:09,704 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-09T03:24:09,705 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,705 | ^~~~ 2023-09-09T03:24:09,706 Box2D/Box2D_wrap.cpp:15392:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,706 15392 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,707 | ^~~~~~~~~ 2023-09-09T03:24:09,707 Box2D/Box2D_wrap.cpp:15394:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,708 15394 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,708 | ^~ 2023-09-09T03:24:09,709 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-09T03:24:09,709 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,710 | ^~~~ 2023-09-09T03:24:09,710 Box2D/Box2D_wrap.cpp:15394:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,711 15394 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,711 | ^~~~~~~~~ 2023-09-09T03:24:09,712 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,712 Box2D/Box2D_wrap.cpp:15399:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,713 15399 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,713 | ^~ 2023-09-09T03:24:09,714 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-09T03:24:09,715 15399 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,715 | ^~~~ 2023-09-09T03:24:09,716 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,717 Box2D/Box2D_wrap.cpp:15420:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,717 15420 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,718 | ^~ 2023-09-09T03:24:09,718 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-09T03:24:09,719 15420 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,719 | ^~~~ 2023-09-09T03:24:09,720 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal(PyObject*, PyObject*)’: 2023-09-09T03:24:09,721 Box2D/Box2D_wrap.cpp:15441:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,721 15441 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,722 | ^~ 2023-09-09T03:24:09,723 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-09T03:24:09,723 15441 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,724 | ^~ 2023-09-09T03:24:09,724 Box2D/Box2D_wrap.cpp:15443:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,725 15443 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,725 | ^~ 2023-09-09T03:24:09,726 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-09T03:24:09,726 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,727 | ^~~~ 2023-09-09T03:24:09,727 Box2D/Box2D_wrap.cpp:15443:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,727 15443 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,728 | ^~~~~~~~~ 2023-09-09T03:24:09,728 Box2D/Box2D_wrap.cpp:15445:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,729 15445 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,729 | ^~ 2023-09-09T03:24:09,730 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-09T03:24:09,731 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,731 | ^~~~ 2023-09-09T03:24:09,732 Box2D/Box2D_wrap.cpp:15445:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,732 15445 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,733 | ^~~~~~~~~ 2023-09-09T03:24:09,733 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,734 Box2D/Box2D_wrap.cpp:15450:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,735 15450 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,735 | ^~ 2023-09-09T03:24:09,736 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-09T03:24:09,737 15450 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,737 | ^~~~ 2023-09-09T03:24:09,738 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,739 Box2D/Box2D_wrap.cpp:15458:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,739 15458 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,740 | ^~ 2023-09-09T03:24:09,741 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-09T03:24:09,741 15458 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,742 | ^~~~ 2023-09-09T03:24:09,743 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal(PyObject*, PyObject*)’: 2023-09-09T03:24:09,743 Box2D/Box2D_wrap.cpp:15466:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,744 15466 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,744 | ^~ 2023-09-09T03:24:09,745 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-09T03:24:09,745 15466 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2023-09-09T03:24:09,746 | ^~ 2023-09-09T03:24:09,746 Box2D/Box2D_wrap.cpp:15468:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,747 15468 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,747 | ^~ 2023-09-09T03:24:09,748 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-09T03:24:09,749 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,749 | ^~~~ 2023-09-09T03:24:09,750 Box2D/Box2D_wrap.cpp:15468:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,750 15468 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,751 | ^~~~~~~~~ 2023-09-09T03:24:09,751 Box2D/Box2D_wrap.cpp:15470:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,752 15470 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,753 | ^~ 2023-09-09T03:24:09,753 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-09T03:24:09,754 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,754 | ^~~~ 2023-09-09T03:24:09,755 Box2D/Box2D_wrap.cpp:15470:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,756 15470 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,756 | ^~~~~~~~~ 2023-09-09T03:24:09,765 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetGravity(PyObject*, PyObject*)’: 2023-09-09T03:24:09,765 Box2D/Box2D_wrap.cpp:15609:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,766 15609 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,766 | ^~ 2023-09-09T03:24:09,767 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-09T03:24:09,768 15609 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,768 | ^~~~~~~~ 2023-09-09T03:24:09,776 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactManager(PyObject*, PyObject*)’: 2023-09-09T03:24:09,777 Box2D/Box2D_wrap.cpp:15659:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,777 15659 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,778 | ^~ 2023-09-09T03:24:09,779 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-09T03:24:09,779 15659 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,780 | ^~~~~~~~ 2023-09-09T03:24:09,780 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_GetProfile(PyObject*, PyObject*)’: 2023-09-09T03:24:09,781 Box2D/Box2D_wrap.cpp:15669:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,781 15669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,782 | ^~ 2023-09-09T03:24:09,782 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-09T03:24:09,783 15669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2023-09-09T03:24:09,784 | ^~~~~~~~ 2023-09-09T03:24:09,792 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DestroyBody(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,792 Box2D/Box2D_wrap.cpp:15736:104: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-09T03:24:09,793 15736 | arg2 = reinterpret_cast< b2Body * >(argp2); { try { b2World_DestroyBody(arg1,arg2); } catch (Swig::DirectorException) { 2023-09-09T03:24:09,794 | ^~~~~~~~~~~~~~~~~ 2023-09-09T03:24:09,795 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DestroyJoint(PyObject*, PyObject*, PyObject*)’: 2023-09-09T03:24:09,795 Box2D/Box2D_wrap.cpp:15748:106: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2023-09-09T03:24:09,796 15748 | arg2 = reinterpret_cast< b2Joint * >(argp2); { try { b2World_DestroyJoint(arg1,arg2); } catch (Swig::DirectorException) { 2023-09-09T03:24:09,797 | ^~~~~~~~~~~~~~~~~ 2023-09-09T03:24:09,802 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactEdge_other_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,803 Box2D/Box2D_wrap.cpp:15797:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,804 15797 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-09T03:24:09,804 | ^~ 2023-09-09T03:24:09,805 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-09T03:24:09,805 15797 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-09T03:24:09,806 | ^~~~~~~~ 2023-09-09T03:24:09,807 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactEdge_contact_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,807 Box2D/Box2D_wrap.cpp:15815:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,808 15815 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-09T03:24:09,809 | ^~ 2023-09-09T03:24:09,810 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-09T03:24:09,810 15815 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-09T03:24:09,811 | ^~~~~~~~ 2023-09-09T03:24:09,815 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactEdge___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,815 Box2D/Box2D_wrap.cpp:15860:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,816 15860 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-09T03:24:09,816 | ^~ 2023-09-09T03:24:09,817 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-09T03:24:09,817 15860 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2023-09-09T03:24:09,818 | ^~~~~~~~ 2023-09-09T03:24:09,820 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetManifold__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,821 Box2D/Box2D_wrap.cpp:15892:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,821 15892 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,822 | ^~ 2023-09-09T03:24:09,823 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-09T03:24:09,823 15892 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,824 | ^~~~ 2023-09-09T03:24:09,824 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetManifold__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,825 Box2D/Box2D_wrap.cpp:15900:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,825 15900 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,826 | ^~ 2023-09-09T03:24:09,827 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-09T03:24:09,827 15900 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,828 | ^~~~ 2023-09-09T03:24:09,829 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetManifold(PyObject*, PyObject*)’: 2023-09-09T03:24:09,829 Box2D/Box2D_wrap.cpp:15907:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,830 15907 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetManifold", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,830 | ^~ 2023-09-09T03:24:09,831 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-09T03:24:09,831 15907 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetManifold", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,832 | ^~ 2023-09-09T03:24:09,833 Box2D/Box2D_wrap.cpp:15909:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,833 15909 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,834 | ^~ 2023-09-09T03:24:09,835 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-09T03:24:09,835 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,836 | ^~~~ 2023-09-09T03:24:09,837 Box2D/Box2D_wrap.cpp:15909:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,837 15909 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,838 | ^~~~~~~~~ 2023-09-09T03:24:09,838 Box2D/Box2D_wrap.cpp:15911:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,839 15911 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,840 | ^~ 2023-09-09T03:24:09,840 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-09T03:24:09,841 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,841 | ^~~~ 2023-09-09T03:24:09,842 Box2D/Box2D_wrap.cpp:15911:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,842 15911 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,843 | ^~~~~~~~~ 2023-09-09T03:24:09,843 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___IsTouching(PyObject*, PyObject*)’: 2023-09-09T03:24:09,844 Box2D/Box2D_wrap.cpp:15929:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,845 15929 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,845 | ^~ 2023-09-09T03:24:09,846 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-09T03:24:09,847 15929 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,847 | ^~~~~~~~ 2023-09-09T03:24:09,848 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___IsEnabled(PyObject*, PyObject*)’: 2023-09-09T03:24:09,849 Box2D/Box2D_wrap.cpp:15947:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,849 15947 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,850 | ^~ 2023-09-09T03:24:09,850 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-09T03:24:09,851 15947 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,851 | ^~~~~~~~ 2023-09-09T03:24:09,852 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,853 Box2D/Box2D_wrap.cpp:15955:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,853 15955 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,854 | ^~ 2023-09-09T03:24:09,854 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-09T03:24:09,855 15955 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,856 | ^~~~ 2023-09-09T03:24:09,856 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,857 Box2D/Box2D_wrap.cpp:15963:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,858 15963 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,858 | ^~ 2023-09-09T03:24:09,859 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-09T03:24:09,859 15963 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,860 | ^~~~ 2023-09-09T03:24:09,860 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetNext(PyObject*, PyObject*)’: 2023-09-09T03:24:09,861 Box2D/Box2D_wrap.cpp:15970:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,861 15970 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,862 | ^~ 2023-09-09T03:24:09,862 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-09T03:24:09,863 15970 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,863 | ^~ 2023-09-09T03:24:09,864 Box2D/Box2D_wrap.cpp:15972:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,864 15972 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,865 | ^~ 2023-09-09T03:24:09,865 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-09T03:24:09,866 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,867 | ^~~~ 2023-09-09T03:24:09,868 Box2D/Box2D_wrap.cpp:15972:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,868 15972 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,869 | ^~~~~~~~~ 2023-09-09T03:24:09,869 Box2D/Box2D_wrap.cpp:15974:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,870 15974 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,871 | ^~ 2023-09-09T03:24:09,872 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-09T03:24:09,872 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,873 | ^~~~ 2023-09-09T03:24:09,874 Box2D/Box2D_wrap.cpp:15974:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,874 15974 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,875 | ^~~~~~~~~ 2023-09-09T03:24:09,876 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureA__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,876 Box2D/Box2D_wrap.cpp:15979:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,877 15979 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,878 | ^~ 2023-09-09T03:24:09,879 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-09T03:24:09,879 15979 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,879 | ^~~~ 2023-09-09T03:24:09,880 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureA__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,880 Box2D/Box2D_wrap.cpp:15987:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,881 15987 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,881 | ^~ 2023-09-09T03:24:09,882 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-09T03:24:09,882 15987 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,883 | ^~~~ 2023-09-09T03:24:09,883 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureA(PyObject*, PyObject*)’: 2023-09-09T03:24:09,884 Box2D/Box2D_wrap.cpp:15994:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,885 15994 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureA", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,885 | ^~ 2023-09-09T03:24:09,886 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-09T03:24:09,886 15994 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureA", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,887 | ^~ 2023-09-09T03:24:09,888 Box2D/Box2D_wrap.cpp:15996:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,889 15996 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,889 | ^~ 2023-09-09T03:24:09,890 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-09T03:24:09,891 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,892 | ^~~~ 2023-09-09T03:24:09,892 Box2D/Box2D_wrap.cpp:15996:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,893 15996 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,894 | ^~~~~~~~~ 2023-09-09T03:24:09,894 Box2D/Box2D_wrap.cpp:15998:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,895 15998 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,896 | ^~ 2023-09-09T03:24:09,896 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-09T03:24:09,897 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,898 | ^~~~ 2023-09-09T03:24:09,898 Box2D/Box2D_wrap.cpp:15998:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,899 15998 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,900 | ^~~~~~~~~ 2023-09-09T03:24:09,901 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetChildIndexA(PyObject*, PyObject*)’: 2023-09-09T03:24:09,901 Box2D/Box2D_wrap.cpp:16003:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,902 16003 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,902 | ^~ 2023-09-09T03:24:09,903 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-09T03:24:09,903 16003 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,904 | ^~~~~~~~ 2023-09-09T03:24:09,904 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureB__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,905 Box2D/Box2D_wrap.cpp:16011:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,905 16011 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,906 | ^~ 2023-09-09T03:24:09,907 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-09T03:24:09,907 16011 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,908 | ^~~~ 2023-09-09T03:24:09,908 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureB__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:09,909 Box2D/Box2D_wrap.cpp:16019:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,909 16019 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,910 | ^~ 2023-09-09T03:24:09,911 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-09T03:24:09,912 16019 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,912 | ^~~~ 2023-09-09T03:24:09,913 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureB(PyObject*, PyObject*)’: 2023-09-09T03:24:09,914 Box2D/Box2D_wrap.cpp:16026:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,914 16026 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureB", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,915 | ^~ 2023-09-09T03:24:09,916 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-09T03:24:09,916 16026 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureB", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:09,917 | ^~ 2023-09-09T03:24:09,918 Box2D/Box2D_wrap.cpp:16028:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,918 16028 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,919 | ^~ 2023-09-09T03:24:09,920 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-09T03:24:09,921 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,921 | ^~~~ 2023-09-09T03:24:09,922 Box2D/Box2D_wrap.cpp:16028:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,923 16028 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:09,923 | ^~~~~~~~~ 2023-09-09T03:24:09,924 Box2D/Box2D_wrap.cpp:16030:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,924 16030 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,925 | ^~ 2023-09-09T03:24:09,925 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-09T03:24:09,926 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:09,926 | ^~~~ 2023-09-09T03:24:09,927 Box2D/Box2D_wrap.cpp:16030:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:09,927 16030 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:09,928 | ^~~~~~~~~ 2023-09-09T03:24:09,928 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetChildIndexB(PyObject*, PyObject*)’: 2023-09-09T03:24:09,929 Box2D/Box2D_wrap.cpp:16035:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,929 16035 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,930 | ^~ 2023-09-09T03:24:09,930 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-09T03:24:09,931 16035 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,932 | ^~~~~~~~ 2023-09-09T03:24:09,932 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFriction(PyObject*, PyObject*)’: 2023-09-09T03:24:09,933 Box2D/Box2D_wrap.cpp:16053:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,934 16053 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,934 | ^~ 2023-09-09T03:24:09,935 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-09T03:24:09,936 16053 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,936 | ^~~~~~~~ 2023-09-09T03:24:09,937 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetRestitution(PyObject*, PyObject*)’: 2023-09-09T03:24:09,938 Box2D/Box2D_wrap.cpp:16078:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,939 16078 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,939 | ^~ 2023-09-09T03:24:09,940 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-09T03:24:09,940 16078 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,941 | ^~~~~~~~ 2023-09-09T03:24:09,942 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetTangentSpeed(PyObject*, PyObject*)’: 2023-09-09T03:24:09,943 Box2D/Box2D_wrap.cpp:16102:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,944 16102 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,945 | ^~ 2023-09-09T03:24:09,945 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-09T03:24:09,946 16102 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,946 | ^~~~~~~~ 2023-09-09T03:24:09,947 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,947 Box2D/Box2D_wrap.cpp:16134:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,948 16134 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,948 | ^~ 2023-09-09T03:24:09,949 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-09T03:24:09,949 16134 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2023-09-09T03:24:09,950 | ^~~~~~~~ 2023-09-09T03:24:09,951 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian_linear_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,951 Box2D/Box2D_wrap.cpp:16165:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,952 16165 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-09T03:24:09,952 | ^~ 2023-09-09T03:24:09,953 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-09T03:24:09,954 16165 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-09T03:24:09,954 | ^~~~~~~~ 2023-09-09T03:24:09,955 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian_angularA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,956 Box2D/Box2D_wrap.cpp:16181:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,956 16181 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-09T03:24:09,957 | ^~ 2023-09-09T03:24:09,958 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-09T03:24:09,958 16181 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-09T03:24:09,959 | ^~~~~~~~ 2023-09-09T03:24:09,960 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian_angularB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,960 Box2D/Box2D_wrap.cpp:16197:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,961 16197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-09T03:24:09,962 | ^~ 2023-09-09T03:24:09,962 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-09T03:24:09,963 16197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-09T03:24:09,964 | ^~~~~~~~ 2023-09-09T03:24:09,964 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,965 Box2D/Box2D_wrap.cpp:16204:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,966 16204 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-09T03:24:09,966 | ^~ 2023-09-09T03:24:09,967 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-09T03:24:09,967 16204 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2023-09-09T03:24:09,968 | ^~~~~~~~ 2023-09-09T03:24:09,968 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Jacobian(PyObject*, PyObject*)’: 2023-09-09T03:24:09,969 Box2D/Box2D_wrap.cpp:16211:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,969 16211 | if (!SWIG_Python_UnpackTuple(args, "new_b2Jacobian", 0, 0, 0)) SWIG_fail; { try { result = (b2Jacobian *)new b2Jacobian(); } 2023-09-09T03:24:09,970 | ^~ 2023-09-09T03:24:09,970 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-09T03:24:09,971 16211 | if (!SWIG_Python_UnpackTuple(args, "new_b2Jacobian", 0, 0, 0)) SWIG_fail; { try { result = (b2Jacobian *)new b2Jacobian(); } 2023-09-09T03:24:09,972 | ^ 2023-09-09T03:24:09,972 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge_other_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,973 Box2D/Box2D_wrap.cpp:16245:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,974 16245 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,974 | ^~ 2023-09-09T03:24:09,975 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-09T03:24:09,975 16245 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,976 | ^~~~~~~~ 2023-09-09T03:24:09,977 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge_joint_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,978 Box2D/Box2D_wrap.cpp:16262:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,978 16262 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,979 | ^~ 2023-09-09T03:24:09,980 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-09T03:24:09,980 16262 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,981 | ^~~~~~~~ 2023-09-09T03:24:09,982 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge_prev_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,982 Box2D/Box2D_wrap.cpp:16293:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,983 16293 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,984 | ^~ 2023-09-09T03:24:09,984 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-09T03:24:09,985 16293 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,986 | ^~~~~~~~ 2023-09-09T03:24:09,987 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge_next_get(PyObject*, PyObject*)’: 2023-09-09T03:24:09,987 Box2D/Box2D_wrap.cpp:16312:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,988 16312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,988 | ^~ 2023-09-09T03:24:09,988 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-09T03:24:09,989 16312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,990 | ^~~~~~~~ 2023-09-09T03:24:09,990 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:09,990 Box2D/Box2D_wrap.cpp:16320:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,991 16320 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,991 | ^~ 2023-09-09T03:24:09,992 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-09T03:24:09,993 16320 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2023-09-09T03:24:09,993 | ^~~~~~~~ 2023-09-09T03:24:09,993 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2JointEdge(PyObject*, PyObject*)’: 2023-09-09T03:24:09,994 Box2D/Box2D_wrap.cpp:16327:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,995 16327 | if (!SWIG_Python_UnpackTuple(args, "new_b2JointEdge", 0, 0, 0)) SWIG_fail; { try { result = (b2JointEdge *)new b2JointEdge(); } 2023-09-09T03:24:09,996 | ^~ 2023-09-09T03:24:09,996 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-09T03:24:09,997 16327 | if (!SWIG_Python_UnpackTuple(args, "new_b2JointEdge", 0, 0, 0)) SWIG_fail; { try { result = (b2JointEdge *)new b2JointEdge(); } 2023-09-09T03:24:09,997 | ^ 2023-09-09T03:24:09,998 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2JointDef(PyObject*, PyObject*)’: 2023-09-09T03:24:09,999 Box2D/Box2D_wrap.cpp:16350:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:09,999 16350 | if (!SWIG_Python_UnpackTuple(args, "new_b2JointDef", 0, 0, 0)) SWIG_fail; { try { result = (b2JointDef *)new b2JointDef(); } 2023-09-09T03:24:10,000 | ^~ 2023-09-09T03:24:10,001 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-09T03:24:10,001 16350 | if (!SWIG_Python_UnpackTuple(args, "new_b2JointDef", 0, 0, 0)) SWIG_fail; { try { result = (b2JointDef *)new b2JointDef(); } 2023-09-09T03:24:10,002 | ^ 2023-09-09T03:24:10,003 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_type_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,003 Box2D/Box2D_wrap.cpp:16365:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,004 16365 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,005 | ^~ 2023-09-09T03:24:10,005 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-09T03:24:10,006 16365 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,007 | ^~~~~~~~ 2023-09-09T03:24:10,007 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_bodyA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,008 Box2D/Box2D_wrap.cpp:16382:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,008 16382 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,009 | ^~ 2023-09-09T03:24:10,009 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-09T03:24:10,010 16382 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,010 | ^~~~~~~~ 2023-09-09T03:24:10,011 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_bodyB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,011 Box2D/Box2D_wrap.cpp:16399:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,012 16399 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,012 | ^~ 2023-09-09T03:24:10,013 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-09T03:24:10,013 16399 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,014 | ^~~~~~~~ 2023-09-09T03:24:10,014 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_collideConnected_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,015 Box2D/Box2D_wrap.cpp:16415:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,016 16415 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,016 | ^~ 2023-09-09T03:24:10,017 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-09T03:24:10,018 16415 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,018 | ^~~~~~~~ 2023-09-09T03:24:10,019 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,020 Box2D/Box2D_wrap.cpp:16422:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,020 16422 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,021 | ^~ 2023-09-09T03:24:10,022 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-09T03:24:10,022 16422 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,023 | ^~~~~~~~ 2023-09-09T03:24:10,024 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef___GetUserData(PyObject*, PyObject*)’: 2023-09-09T03:24:10,024 Box2D/Box2D_wrap.cpp:16430:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,025 16430 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,026 | ^~ 2023-09-09T03:24:10,027 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-09T03:24:10,027 16430 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2023-09-09T03:24:10,028 | ^~~~~~~~ 2023-09-09T03:24:10,029 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetType(PyObject*, PyObject*)’: 2023-09-09T03:24:10,029 Box2D/Box2D_wrap.cpp:16471:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,030 16471 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,030 | ^~ 2023-09-09T03:24:10,031 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-09T03:24:10,031 16471 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,032 | ^~~~~~~~ 2023-09-09T03:24:10,032 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetBodyA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,033 Box2D/Box2D_wrap.cpp:16479:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,033 16479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,034 | ^~ 2023-09-09T03:24:10,035 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-09T03:24:10,035 16479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,036 | ^~~~~~~~ 2023-09-09T03:24:10,036 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetBodyB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,037 Box2D/Box2D_wrap.cpp:16487:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,038 16487 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,038 | ^~ 2023-09-09T03:24:10,039 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-09T03:24:10,040 16487 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,041 | ^~~~~~~~ 2023-09-09T03:24:10,041 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetAnchorA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,042 Box2D/Box2D_wrap.cpp:16495:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,043 16495 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,044 | ^~ 2023-09-09T03:24:10,044 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-09T03:24:10,045 16495 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,046 | ^~~~~~~~ 2023-09-09T03:24:10,046 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetAnchorB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,047 Box2D/Box2D_wrap.cpp:16504:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,048 16504 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,048 | ^~ 2023-09-09T03:24:10,049 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-09T03:24:10,050 16504 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,051 | ^~~~~~~~ 2023-09-09T03:24:10,052 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:10,052 Box2D/Box2D_wrap.cpp:16538:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,053 16538 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,053 | ^~ 2023-09-09T03:24:10,054 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-09T03:24:10,054 16538 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,055 | ^~~~ 2023-09-09T03:24:10,055 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2023-09-09T03:24:10,056 Box2D/Box2D_wrap.cpp:16558:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,056 16558 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,057 | ^~ 2023-09-09T03:24:10,058 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-09T03:24:10,058 16558 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,059 | ^~~~ 2023-09-09T03:24:10,060 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext(PyObject*, PyObject*)’: 2023-09-09T03:24:10,060 Box2D/Box2D_wrap.cpp:16578:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,061 16578 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Joint___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:10,062 | ^~ 2023-09-09T03:24:10,063 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-09T03:24:10,063 16578 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Joint___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2023-09-09T03:24:10,064 | ^~ 2023-09-09T03:24:10,064 Box2D/Box2D_wrap.cpp:16580:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,065 16580 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:10,066 | ^~ 2023-09-09T03:24:10,066 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-09T03:24:10,067 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:10,068 | ^~~~ 2023-09-09T03:24:10,068 Box2D/Box2D_wrap.cpp:16580:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:10,069 16580 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2023-09-09T03:24:10,070 | ^~~~~~~~~ 2023-09-09T03:24:10,070 Box2D/Box2D_wrap.cpp:16582:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,071 16582 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:10,072 | ^~ 2023-09-09T03:24:10,072 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-09T03:24:10,073 1122 | #define SWIG_fail goto fail 2023-09-09T03:24:10,073 | ^~~~ 2023-09-09T03:24:10,074 Box2D/Box2D_wrap.cpp:16582:64: note: in expansion of macro ‘SWIG_fail’ 2023-09-09T03:24:10,075 16582 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2023-09-09T03:24:10,075 | ^~~~~~~~~ 2023-09-09T03:24:10,076 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetUserData(PyObject*, PyObject*)’: 2023-09-09T03:24:10,076 Box2D/Box2D_wrap.cpp:16631:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,077 16631 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,077 | ^~ 2023-09-09T03:24:10,078 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-09T03:24:10,078 16631 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2023-09-09T03:24:10,079 | ^~~~~~~~ 2023-09-09T03:24:10,080 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJointDef_length_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,080 Box2D/Box2D_wrap.cpp:16760:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,081 16760 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-09T03:24:10,081 | ^~ 2023-09-09T03:24:10,082 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-09T03:24:10,083 16760 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-09T03:24:10,083 | ^~~~~~~~ 2023-09-09T03:24:10,084 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJointDef_frequencyHz_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,084 Box2D/Box2D_wrap.cpp:16778:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,085 16778 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-09T03:24:10,086 | ^~ 2023-09-09T03:24:10,086 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-09T03:24:10,087 16778 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-09T03:24:10,088 | ^~~~~~~~ 2023-09-09T03:24:10,088 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJointDef_dampingRatio_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,089 Box2D/Box2D_wrap.cpp:16796:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,089 16796 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-09T03:24:10,090 | ^~ 2023-09-09T03:24:10,091 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-09T03:24:10,092 16796 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-09T03:24:10,092 | ^~~~~~~~ 2023-09-09T03:24:10,093 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,094 Box2D/Box2D_wrap.cpp:16803:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,094 16803 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-09T03:24:10,095 | ^~ 2023-09-09T03:24:10,095 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-09T03:24:10,096 16803 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJointDef, 0 | 0 ); 2023-09-09T03:24:10,096 | ^~~~~~~~ 2023-09-09T03:24:10,097 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceJointDef(PyObject*, PyObject*)’: 2023-09-09T03:24:10,097 Box2D/Box2D_wrap.cpp:16811:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,098 16811 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,099 | ^~ 2023-09-09T03:24:10,099 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-09T03:24:10,100 16811 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,100 | ^~~~~~~~ 2023-09-09T03:24:10,101 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,101 Box2D/Box2D_wrap.cpp:16829:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,102 16829 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,102 | ^~ 2023-09-09T03:24:10,103 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-09T03:24:10,104 16829 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,104 | ^~~~~~~~ 2023-09-09T03:24:10,105 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,106 Box2D/Box2D_wrap.cpp:16838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,107 16838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,107 | ^~ 2023-09-09T03:24:10,108 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-09T03:24:10,108 16838 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,109 | ^~~~~~~~ 2023-09-09T03:24:10,110 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint___GetLength(PyObject*, PyObject*)’: 2023-09-09T03:24:10,110 Box2D/Box2D_wrap.cpp:16858:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,111 16858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,112 | ^~ 2023-09-09T03:24:10,112 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-09T03:24:10,113 16858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,114 | ^~~~~~~~ 2023-09-09T03:24:10,115 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint___GetFrequency(PyObject*, PyObject*)’: 2023-09-09T03:24:10,116 Box2D/Box2D_wrap.cpp:16877:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,116 16877 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,117 | ^~ 2023-09-09T03:24:10,117 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-09T03:24:10,118 16877 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,119 | ^~~~~~~~ 2023-09-09T03:24:10,119 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint___GetDampingRatio(PyObject*, PyObject*)’: 2023-09-09T03:24:10,120 Box2D/Box2D_wrap.cpp:16897:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,120 16897 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,121 | ^~ 2023-09-09T03:24:10,121 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-09T03:24:10,122 16897 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,123 | ^~~~~~~~ 2023-09-09T03:24:10,123 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,124 Box2D/Box2D_wrap.cpp:16906:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,125 16906 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,125 | ^~ 2023-09-09T03:24:10,126 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-09T03:24:10,126 16906 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceJoint, 0 | 0 ); 2023-09-09T03:24:10,127 | ^~~~~~~~ 2023-09-09T03:24:10,128 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJointDef_maxForce_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,128 Box2D/Box2D_wrap.cpp:17018:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,129 17018 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-09T03:24:10,130 | ^~ 2023-09-09T03:24:10,130 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-09T03:24:10,131 17018 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-09T03:24:10,132 | ^~~~~~~~ 2023-09-09T03:24:10,132 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJointDef_maxTorque_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,133 Box2D/Box2D_wrap.cpp:17036:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,134 17036 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-09T03:24:10,134 | ^~ 2023-09-09T03:24:10,135 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-09T03:24:10,136 17036 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-09T03:24:10,136 | ^~~~~~~~ 2023-09-09T03:24:10,137 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,137 Box2D/Box2D_wrap.cpp:17043:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,138 17043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-09T03:24:10,139 | ^~ 2023-09-09T03:24:10,139 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-09T03:24:10,140 17043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJointDef, 0 | 0 ); 2023-09-09T03:24:10,140 | ^~~~~~~~ 2023-09-09T03:24:10,141 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2FrictionJointDef(PyObject*, PyObject*)’: 2023-09-09T03:24:10,141 Box2D/Box2D_wrap.cpp:17051:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,142 17051 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,143 | ^~ 2023-09-09T03:24:10,143 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-09T03:24:10,144 17051 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,144 | ^~~~~~~~ 2023-09-09T03:24:10,145 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,145 Box2D/Box2D_wrap.cpp:17069:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,146 17069 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,147 | ^~ 2023-09-09T03:24:10,148 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-09T03:24:10,148 17069 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,149 | ^~~~~~~~ 2023-09-09T03:24:10,150 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,150 Box2D/Box2D_wrap.cpp:17078:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,151 17078 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,152 | ^~ 2023-09-09T03:24:10,152 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-09T03:24:10,153 17078 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,154 | ^~~~~~~~ 2023-09-09T03:24:10,154 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint___GetMaxForce(PyObject*, PyObject*)’: 2023-09-09T03:24:10,155 Box2D/Box2D_wrap.cpp:17098:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,156 17098 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,157 | ^~ 2023-09-09T03:24:10,157 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-09T03:24:10,158 17098 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,159 | ^~~~~~~~ 2023-09-09T03:24:10,160 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint___GetMaxTorque(PyObject*, PyObject*)’: 2023-09-09T03:24:10,160 Box2D/Box2D_wrap.cpp:17118:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,161 17118 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,161 | ^~ 2023-09-09T03:24:10,162 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-09T03:24:10,162 17118 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,163 | ^~~~~~~~ 2023-09-09T03:24:10,164 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FrictionJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,164 Box2D/Box2D_wrap.cpp:17127:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,165 17127 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,166 | ^~ 2023-09-09T03:24:10,166 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-09T03:24:10,167 17127 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FrictionJoint, 0 | 0 ); 2023-09-09T03:24:10,167 | ^~~~~~~~ 2023-09-09T03:24:10,168 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJointDef_joint1_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,169 Box2D/Box2D_wrap.cpp:17166:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,169 17166 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-09T03:24:10,170 | ^~ 2023-09-09T03:24:10,171 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-09T03:24:10,171 17166 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-09T03:24:10,172 | ^~~~~~~~ 2023-09-09T03:24:10,173 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJointDef_joint2_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,174 Box2D/Box2D_wrap.cpp:17197:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,174 17197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-09T03:24:10,175 | ^~ 2023-09-09T03:24:10,175 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-09T03:24:10,176 17197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-09T03:24:10,177 | ^~~~~~~~ 2023-09-09T03:24:10,177 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJointDef_ratio_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,178 Box2D/Box2D_wrap.cpp:17226:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,179 17226 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-09T03:24:10,179 | ^~ 2023-09-09T03:24:10,180 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-09T03:24:10,181 17226 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-09T03:24:10,181 | ^~~~~~~~ 2023-09-09T03:24:10,182 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,182 Box2D/Box2D_wrap.cpp:17233:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,183 17233 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-09T03:24:10,183 | ^~ 2023-09-09T03:24:10,184 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-09T03:24:10,185 17233 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJointDef, 0 | 0 ); 2023-09-09T03:24:10,185 | ^~~~~~~~ 2023-09-09T03:24:10,186 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint_GetJoint1(PyObject*, PyObject*)’: 2023-09-09T03:24:10,186 Box2D/Box2D_wrap.cpp:17259:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,187 17259 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-09T03:24:10,187 | ^~ 2023-09-09T03:24:10,188 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-09T03:24:10,189 17259 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-09T03:24:10,189 | ^~~~~~~~ 2023-09-09T03:24:10,190 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint_GetJoint2(PyObject*, PyObject*)’: 2023-09-09T03:24:10,190 Box2D/Box2D_wrap.cpp:17280:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,191 17280 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-09T03:24:10,192 | ^~ 2023-09-09T03:24:10,192 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-09T03:24:10,193 17280 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-09T03:24:10,194 | ^~~~~~~~ 2023-09-09T03:24:10,195 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint___GetRatio(PyObject*, PyObject*)’: 2023-09-09T03:24:10,195 Box2D/Box2D_wrap.cpp:17311:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,196 17311 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-09T03:24:10,197 | ^~ 2023-09-09T03:24:10,197 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-09T03:24:10,198 17311 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-09T03:24:10,199 | ^~~~~~~~ 2023-09-09T03:24:10,200 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,200 Box2D/Box2D_wrap.cpp:17319:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,201 17319 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-09T03:24:10,202 | ^~ 2023-09-09T03:24:10,203 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-09T03:24:10,203 17319 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2023-09-09T03:24:10,204 | ^~~~~~~~ 2023-09-09T03:24:10,204 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_linearOffset_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,205 Box2D/Box2D_wrap.cpp:17379:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,206 17379 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,206 | ^~ 2023-09-09T03:24:10,207 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-09T03:24:10,207 17379 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,208 | ^~~~~~~~ 2023-09-09T03:24:10,209 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_angularOffset_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,209 Box2D/Box2D_wrap.cpp:17395:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,210 17395 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,210 | ^~ 2023-09-09T03:24:10,211 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-09T03:24:10,212 17395 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,213 | ^~~~~~~~ 2023-09-09T03:24:10,213 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_maxForce_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,214 Box2D/Box2D_wrap.cpp:17411:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,215 17411 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,215 | ^~ 2023-09-09T03:24:10,216 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-09T03:24:10,217 17411 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,218 | ^~~~~~~~ 2023-09-09T03:24:10,218 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_maxTorque_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,219 Box2D/Box2D_wrap.cpp:17427:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,220 17427 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,220 | ^~ 2023-09-09T03:24:10,221 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-09T03:24:10,222 17427 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,222 | ^~~~~~~~ 2023-09-09T03:24:10,223 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJointDef_correctionFactor_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,224 Box2D/Box2D_wrap.cpp:17443:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,224 17443 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,225 | ^~ 2023-09-09T03:24:10,226 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-09T03:24:10,227 17443 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJointDef, 0 | 0 ); 2023-09-09T03:24:10,227 | ^~~~~~~~ 2023-09-09T03:24:10,227 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetLinearOffset(PyObject*, PyObject*)’: 2023-09-09T03:24:10,228 Box2D/Box2D_wrap.cpp:17486:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,229 17486 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-09T03:24:10,229 | ^~ 2023-09-09T03:24:10,230 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-09T03:24:10,230 17486 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-09T03:24:10,231 | ^~~~~~~~ 2023-09-09T03:24:10,232 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetAngularOffset(PyObject*, PyObject*)’: 2023-09-09T03:24:10,232 Box2D/Box2D_wrap.cpp:17506:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,233 17506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-09T03:24:10,233 | ^~ 2023-09-09T03:24:10,234 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-09T03:24:10,235 17506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-09T03:24:10,235 | ^~~~~~~~ 2023-09-09T03:24:10,236 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetMaxForce(PyObject*, PyObject*)’: 2023-09-09T03:24:10,237 Box2D/Box2D_wrap.cpp:17526:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,238 17526 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-09T03:24:10,238 | ^~ 2023-09-09T03:24:10,239 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-09T03:24:10,240 17526 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-09T03:24:10,240 | ^~~~~~~~ 2023-09-09T03:24:10,241 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetMaxTorque(PyObject*, PyObject*)’: 2023-09-09T03:24:10,242 Box2D/Box2D_wrap.cpp:17545:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,242 17545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-09T03:24:10,243 | ^~ 2023-09-09T03:24:10,244 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-09T03:24:10,244 17545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2023-09-09T03:24:10,245 | ^~~~~~~~ 2023-09-09T03:24:10,248 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef_target_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,249 Box2D/Box2D_wrap.cpp:17589:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,249 17589 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,250 | ^~ 2023-09-09T03:24:10,250 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-09T03:24:10,251 17589 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,251 | ^~~~~~~~ 2023-09-09T03:24:10,252 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef_maxForce_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,252 Box2D/Box2D_wrap.cpp:17605:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,253 17605 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,254 | ^~ 2023-09-09T03:24:10,254 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-09T03:24:10,255 17605 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,255 | ^~~~~~~~ 2023-09-09T03:24:10,256 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef_frequencyHz_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,256 Box2D/Box2D_wrap.cpp:17621:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,257 17621 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,257 | ^~ 2023-09-09T03:24:10,258 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-09T03:24:10,259 17621 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,259 | ^~~~~~~~ 2023-09-09T03:24:10,260 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef_dampingRatio_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,261 Box2D/Box2D_wrap.cpp:17637:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,262 17637 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,262 | ^~ 2023-09-09T03:24:10,263 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-09T03:24:10,264 17637 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,264 | ^~~~~~~~ 2023-09-09T03:24:10,265 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,265 Box2D/Box2D_wrap.cpp:17644:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,266 17644 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,267 | ^~ 2023-09-09T03:24:10,267 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-09T03:24:10,268 17644 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJointDef, 0 | 0 ); 2023-09-09T03:24:10,269 | ^~~~~~~~ 2023-09-09T03:24:10,270 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetTarget(PyObject*, PyObject*)’: 2023-09-09T03:24:10,270 Box2D/Box2D_wrap.cpp:17687:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,271 17687 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,271 | ^~ 2023-09-09T03:24:10,272 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-09T03:24:10,272 17687 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,273 | ^~~~~~~~ 2023-09-09T03:24:10,274 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetMaxForce(PyObject*, PyObject*)’: 2023-09-09T03:24:10,275 Box2D/Box2D_wrap.cpp:17706:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,276 17706 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,276 | ^~ 2023-09-09T03:24:10,277 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-09T03:24:10,277 17706 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,278 | ^~~~~~~~ 2023-09-09T03:24:10,279 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetFrequency(PyObject*, PyObject*)’: 2023-09-09T03:24:10,280 Box2D/Box2D_wrap.cpp:17725:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,281 17725 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,281 | ^~ 2023-09-09T03:24:10,282 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-09T03:24:10,282 17725 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,283 | ^~~~~~~~ 2023-09-09T03:24:10,284 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetDampingRatio(PyObject*, PyObject*)’: 2023-09-09T03:24:10,285 Box2D/Box2D_wrap.cpp:17744:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,285 17744 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,286 | ^~ 2023-09-09T03:24:10,287 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-09T03:24:10,287 17744 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,288 | ^~~~~~~~ 2023-09-09T03:24:10,288 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,289 Box2D/Box2D_wrap.cpp:17752:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,290 17752 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,290 | ^~ 2023-09-09T03:24:10,291 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-09T03:24:10,292 17752 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2023-09-09T03:24:10,292 | ^~~~~~~~ 2023-09-09T03:24:10,316 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJointDef_enableLimit_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,316 Box2D/Box2D_wrap.cpp:17915:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,317 17915 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-09T03:24:10,317 | ^~ 2023-09-09T03:24:10,318 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-09T03:24:10,319 17915 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-09T03:24:10,319 | ^~~~~~~~ 2023-09-09T03:24:10,325 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJointDef_enableMotor_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,326 Box2D/Box2D_wrap.cpp:17969:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,326 17969 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-09T03:24:10,327 | ^~ 2023-09-09T03:24:10,327 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-09T03:24:10,328 17969 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-09T03:24:10,328 | ^~~~~~~~ 2023-09-09T03:24:10,333 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,334 Box2D/Box2D_wrap.cpp:18012:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,334 18012 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-09T03:24:10,335 | ^~ 2023-09-09T03:24:10,335 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-09T03:24:10,336 18012 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJointDef, 0 | 0 ); 2023-09-09T03:24:10,337 | ^~~~~~~~ 2023-09-09T03:24:10,337 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PrismaticJointDef(PyObject*, PyObject*)’: 2023-09-09T03:24:10,338 Box2D/Box2D_wrap.cpp:18020:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,339 18020 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,339 | ^~ 2023-09-09T03:24:10,340 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-09T03:24:10,341 18020 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,341 | ^~~~~~~~ 2023-09-09T03:24:10,344 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint_GetReferenceAngle(PyObject*, PyObject*)’: 2023-09-09T03:24:10,344 Box2D/Box2D_wrap.cpp:18065:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,345 18065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,346 | ^~ 2023-09-09T03:24:10,346 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-09T03:24:10,347 18065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,348 | ^~~~~~~~ 2023-09-09T03:24:10,348 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetJointTranslation(PyObject*, PyObject*)’: 2023-09-09T03:24:10,349 Box2D/Box2D_wrap.cpp:18074:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,349 18074 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,350 | ^~ 2023-09-09T03:24:10,350 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-09T03:24:10,351 18074 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,351 | ^~~~~~~~ 2023-09-09T03:24:10,352 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetJointSpeed(PyObject*, PyObject*)’: 2023-09-09T03:24:10,352 Box2D/Box2D_wrap.cpp:18083:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,353 18083 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,353 | ^~ 2023-09-09T03:24:10,354 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-09T03:24:10,354 18083 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,355 | ^~~~~~~~ 2023-09-09T03:24:10,356 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___IsLimitEnabled(PyObject*, PyObject*)’: 2023-09-09T03:24:10,356 Box2D/Box2D_wrap.cpp:18092:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,357 18092 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,357 | ^~ 2023-09-09T03:24:10,358 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-09T03:24:10,359 18092 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,359 | ^~~~~~~~ 2023-09-09T03:24:10,360 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetLowerLimit(PyObject*, PyObject*)’: 2023-09-09T03:24:10,361 Box2D/Box2D_wrap.cpp:18112:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,362 18112 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,362 | ^~ 2023-09-09T03:24:10,363 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-09T03:24:10,363 18112 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,364 | ^~~~~~~~ 2023-09-09T03:24:10,365 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetUpperLimit(PyObject*, PyObject*)’: 2023-09-09T03:24:10,365 Box2D/Box2D_wrap.cpp:18121:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,366 18121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,367 | ^~ 2023-09-09T03:24:10,367 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-09T03:24:10,368 18121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,369 | ^~~~~~~~ 2023-09-09T03:24:10,369 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___IsMotorEnabled(PyObject*, PyObject*)’: 2023-09-09T03:24:10,370 Box2D/Box2D_wrap.cpp:18143:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,370 18143 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,371 | ^~ 2023-09-09T03:24:10,371 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-09T03:24:10,372 18143 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,372 | ^~~~~~~~ 2023-09-09T03:24:10,373 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetMotorSpeed(PyObject*, PyObject*)’: 2023-09-09T03:24:10,373 Box2D/Box2D_wrap.cpp:18174:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,374 18174 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,374 | ^~ 2023-09-09T03:24:10,375 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-09T03:24:10,375 18174 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,376 | ^~~~~~~~ 2023-09-09T03:24:10,377 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___GetMaxMotorForce(PyObject*, PyObject*)’: 2023-09-09T03:24:10,377 Box2D/Box2D_wrap.cpp:18194:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,378 18194 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,378 | ^~ 2023-09-09T03:24:10,379 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-09T03:24:10,380 18194 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,380 | ^~~~~~~~ 2023-09-09T03:24:10,381 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PrismaticJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,382 Box2D/Box2D_wrap.cpp:18215:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,382 18215 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,383 | ^~ 2023-09-09T03:24:10,384 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-09T03:24:10,384 18215 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PrismaticJoint, 0 | 0 ); 2023-09-09T03:24:10,385 | ^~~~~~~~ 2023-09-09T03:24:10,386 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PrismaticJoint(PyObject*, PyObject*)’: 2023-09-09T03:24:10,386 Box2D/Box2D_wrap.cpp:18223:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,387 18223 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,388 | ^~ 2023-09-09T03:24:10,389 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-09T03:24:10,389 18223 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,390 | ^~~~~~~~ 2023-09-09T03:24:10,416 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJointDef_lengthA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,417 Box2D/Box2D_wrap.cpp:18410:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,417 18410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-09T03:24:10,418 | ^~ 2023-09-09T03:24:10,419 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-09T03:24:10,419 18410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-09T03:24:10,420 | ^~~~~~~~ 2023-09-09T03:24:10,420 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJointDef_lengthB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,421 Box2D/Box2D_wrap.cpp:18428:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,421 18428 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-09T03:24:10,422 | ^~ 2023-09-09T03:24:10,422 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-09T03:24:10,423 18428 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-09T03:24:10,424 | ^~~~~~~~ 2023-09-09T03:24:10,424 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJointDef_ratio_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,425 Box2D/Box2D_wrap.cpp:18446:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,425 18446 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-09T03:24:10,426 | ^~ 2023-09-09T03:24:10,427 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-09T03:24:10,427 18446 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-09T03:24:10,428 | ^~~~~~~~ 2023-09-09T03:24:10,429 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,429 Box2D/Box2D_wrap.cpp:18453:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,430 18453 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-09T03:24:10,431 | ^~ 2023-09-09T03:24:10,431 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-09T03:24:10,432 18453 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJointDef, 0 | 0 ); 2023-09-09T03:24:10,433 | ^~~~~~~~ 2023-09-09T03:24:10,433 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PulleyJointDef(PyObject*, PyObject*)’: 2023-09-09T03:24:10,434 Box2D/Box2D_wrap.cpp:18461:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,435 18461 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,435 | ^~ 2023-09-09T03:24:10,436 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-09T03:24:10,437 18461 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,437 | ^~~~~~~~ 2023-09-09T03:24:10,438 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___GetLengthA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,438 Box2D/Box2D_wrap.cpp:18497:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,439 18497 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,439 | ^~ 2023-09-09T03:24:10,440 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-09T03:24:10,440 18497 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,441 | ^~~~~~~~ 2023-09-09T03:24:10,441 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___GetLengthB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,442 Box2D/Box2D_wrap.cpp:18505:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,442 18505 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,443 | ^~ 2023-09-09T03:24:10,443 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-09T03:24:10,444 18505 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,445 | ^~~~~~~~ 2023-09-09T03:24:10,445 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___GetRatio(PyObject*, PyObject*)’: 2023-09-09T03:24:10,446 Box2D/Box2D_wrap.cpp:18513:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,446 18513 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,447 | ^~ 2023-09-09T03:24:10,448 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-09T03:24:10,448 18513 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,449 | ^~~~~~~~ 2023-09-09T03:24:10,450 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint_GetCurrentLengthA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,450 Box2D/Box2D_wrap.cpp:18521:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,451 18521 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,451 | ^~ 2023-09-09T03:24:10,452 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-09T03:24:10,453 18521 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,453 | ^~~~~~~~ 2023-09-09T03:24:10,454 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint_GetCurrentLengthB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,455 Box2D/Box2D_wrap.cpp:18530:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,456 18530 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,456 | ^~ 2023-09-09T03:24:10,457 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-09T03:24:10,458 18530 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,458 | ^~~~~~~~ 2023-09-09T03:24:10,459 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,459 Box2D/Box2D_wrap.cpp:18539:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,460 18539 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,460 | ^~ 2023-09-09T03:24:10,461 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-09T03:24:10,461 18539 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2023-09-09T03:24:10,462 | ^~~~~~~~ 2023-09-09T03:24:10,470 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_referenceAngle_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,471 Box2D/Box2D_wrap.cpp:18651:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,471 18651 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,472 | ^~ 2023-09-09T03:24:10,472 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-09T03:24:10,473 18651 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,474 | ^~~~~~~~ 2023-09-09T03:24:10,475 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_enableLimit_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,475 Box2D/Box2D_wrap.cpp:18669:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,476 18669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,477 | ^~ 2023-09-09T03:24:10,477 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-09T03:24:10,478 18669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,479 | ^~~~~~~~ 2023-09-09T03:24:10,479 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_lowerAngle_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,480 Box2D/Box2D_wrap.cpp:18687:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,481 18687 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,481 | ^~ 2023-09-09T03:24:10,482 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-09T03:24:10,483 18687 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,483 | ^~~~~~~~ 2023-09-09T03:24:10,484 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_upperAngle_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,485 Box2D/Box2D_wrap.cpp:18705:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,485 18705 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,486 | ^~ 2023-09-09T03:24:10,487 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-09T03:24:10,487 18705 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,488 | ^~~~~~~~ 2023-09-09T03:24:10,488 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_enableMotor_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,489 Box2D/Box2D_wrap.cpp:18723:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,489 18723 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,490 | ^~ 2023-09-09T03:24:10,490 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-09T03:24:10,491 18723 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,491 | ^~~~~~~~ 2023-09-09T03:24:10,492 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_motorSpeed_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,492 Box2D/Box2D_wrap.cpp:18741:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,493 18741 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,494 | ^~ 2023-09-09T03:24:10,494 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-09T03:24:10,495 18741 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,495 | ^~~~~~~~ 2023-09-09T03:24:10,496 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef_maxMotorTorque_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,497 Box2D/Box2D_wrap.cpp:18759:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,497 18759 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,498 | ^~ 2023-09-09T03:24:10,499 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-09T03:24:10,499 18759 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,500 | ^~~~~~~~ 2023-09-09T03:24:10,501 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,501 Box2D/Box2D_wrap.cpp:18766:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,502 18766 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,503 | ^~ 2023-09-09T03:24:10,503 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-09T03:24:10,504 18766 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJointDef, 0 | 0 ); 2023-09-09T03:24:10,505 | ^~~~~~~~ 2023-09-09T03:24:10,505 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RevoluteJointDef(PyObject*, PyObject*)’: 2023-09-09T03:24:10,506 Box2D/Box2D_wrap.cpp:18774:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,507 18774 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,507 | ^~ 2023-09-09T03:24:10,508 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-09T03:24:10,508 18774 | if (!args) SWIG_fail; swig_obj[0] = args; 2023-09-09T03:24:10,509 | ^~~~~~~~ 2023-09-09T03:24:10,509 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,510 Box2D/Box2D_wrap.cpp:18792:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,510 18792 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,511 | ^~ 2023-09-09T03:24:10,511 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-09T03:24:10,512 18792 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,512 | ^~~~~~~~ 2023-09-09T03:24:10,513 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,513 Box2D/Box2D_wrap.cpp:18801:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,514 18801 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,515 | ^~ 2023-09-09T03:24:10,515 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-09T03:24:10,516 18801 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,516 | ^~~~~~~~ 2023-09-09T03:24:10,517 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint_GetReferenceAngle(PyObject*, PyObject*)’: 2023-09-09T03:24:10,518 Box2D/Box2D_wrap.cpp:18810:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,518 18810 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,519 | ^~ 2023-09-09T03:24:10,520 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-09T03:24:10,520 18810 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,521 | ^~~~~~~~ 2023-09-09T03:24:10,522 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetJointAngle(PyObject*, PyObject*)’: 2023-09-09T03:24:10,522 Box2D/Box2D_wrap.cpp:18819:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,523 18819 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,524 | ^~ 2023-09-09T03:24:10,524 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-09T03:24:10,525 18819 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,526 | ^~~~~~~~ 2023-09-09T03:24:10,526 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetJointSpeed(PyObject*, PyObject*)’: 2023-09-09T03:24:10,527 Box2D/Box2D_wrap.cpp:18828:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,528 18828 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,528 | ^~ 2023-09-09T03:24:10,529 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-09T03:24:10,529 18828 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,530 | ^~~~~~~~ 2023-09-09T03:24:10,531 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___IsLimitEnabled(PyObject*, PyObject*)’: 2023-09-09T03:24:10,531 Box2D/Box2D_wrap.cpp:18837:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,532 18837 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,532 | ^~ 2023-09-09T03:24:10,533 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-09T03:24:10,534 18837 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,534 | ^~~~~~~~ 2023-09-09T03:24:10,535 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetLowerLimit(PyObject*, PyObject*)’: 2023-09-09T03:24:10,535 Box2D/Box2D_wrap.cpp:18857:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,536 18857 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,537 | ^~ 2023-09-09T03:24:10,537 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-09T03:24:10,538 18857 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,539 | ^~~~~~~~ 2023-09-09T03:24:10,539 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetUpperLimit(PyObject*, PyObject*)’: 2023-09-09T03:24:10,540 Box2D/Box2D_wrap.cpp:18866:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,540 18866 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,541 | ^~ 2023-09-09T03:24:10,542 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-09T03:24:10,542 18866 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,543 | ^~~~~~~~ 2023-09-09T03:24:10,543 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___IsMotorEnabled(PyObject*, PyObject*)’: 2023-09-09T03:24:10,544 Box2D/Box2D_wrap.cpp:18888:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,545 18888 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,545 | ^~ 2023-09-09T03:24:10,546 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-09T03:24:10,547 18888 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,547 | ^~~~~~~~ 2023-09-09T03:24:10,548 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___GetMotorSpeed(PyObject*, PyObject*)’: 2023-09-09T03:24:10,549 Box2D/Box2D_wrap.cpp:18919:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,549 18919 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,550 | ^~ 2023-09-09T03:24:10,551 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-09T03:24:10,551 18919 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,552 | ^~~~~~~~ 2023-09-09T03:24:10,553 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint_GetMaxMotorTorque(PyObject*, PyObject*)’: 2023-09-09T03:24:10,553 Box2D/Box2D_wrap.cpp:18939:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,554 18939 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,554 | ^~ 2023-09-09T03:24:10,555 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-09T03:24:10,556 18939 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,556 | ^~~~~~~~ 2023-09-09T03:24:10,557 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RevoluteJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,557 Box2D/Box2D_wrap.cpp:18960:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,558 18960 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,559 | ^~ 2023-09-09T03:24:10,559 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-09T03:24:10,560 18960 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RevoluteJoint, 0 | 0 ); 2023-09-09T03:24:10,560 | ^~~~~~~~ 2023-09-09T03:24:10,561 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJointDef_localAnchorA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,562 Box2D/Box2D_wrap.cpp:19004:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,562 19004 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-09T03:24:10,563 | ^~ 2023-09-09T03:24:10,564 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-09T03:24:10,564 19004 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-09T03:24:10,565 | ^~~~~~~~ 2023-09-09T03:24:10,565 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJointDef_localAnchorB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,566 Box2D/Box2D_wrap.cpp:19027:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,567 19027 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-09T03:24:10,567 | ^~ 2023-09-09T03:24:10,568 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-09T03:24:10,568 19027 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-09T03:24:10,569 | ^~~~~~~~ 2023-09-09T03:24:10,570 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJointDef_maxLength_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,570 Box2D/Box2D_wrap.cpp:19043:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,571 19043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-09T03:24:10,571 | ^~ 2023-09-09T03:24:10,572 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-09T03:24:10,572 19043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-09T03:24:10,573 | ^~~~~~~~ 2023-09-09T03:24:10,573 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,574 Box2D/Box2D_wrap.cpp:19050:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,574 19050 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-09T03:24:10,575 | ^~ 2023-09-09T03:24:10,576 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-09T03:24:10,576 19050 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJointDef, 0 | 0 ); 2023-09-09T03:24:10,577 | ^~~~~~~~ 2023-09-09T03:24:10,577 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,578 Box2D/Box2D_wrap.cpp:19076:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,578 19076 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,579 | ^~ 2023-09-09T03:24:10,580 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-09T03:24:10,580 19076 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,581 | ^~~~~~~~ 2023-09-09T03:24:10,581 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,582 Box2D/Box2D_wrap.cpp:19085:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,583 19085 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,583 | ^~ 2023-09-09T03:24:10,584 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-09T03:24:10,584 19085 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,585 | ^~~~~~~~ 2023-09-09T03:24:10,586 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint___GetMaxLength(PyObject*, PyObject*)’: 2023-09-09T03:24:10,586 Box2D/Box2D_wrap.cpp:19104:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,587 19104 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,588 | ^~ 2023-09-09T03:24:10,589 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-09T03:24:10,589 19104 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,590 | ^~~~~~~~ 2023-09-09T03:24:10,590 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint___GetLimitState(PyObject*, PyObject*)’: 2023-09-09T03:24:10,591 Box2D/Box2D_wrap.cpp:19112:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,591 19112 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,592 | ^~ 2023-09-09T03:24:10,592 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-09T03:24:10,593 19112 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,593 | ^~~~~~~~ 2023-09-09T03:24:10,594 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,594 Box2D/Box2D_wrap.cpp:19121:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,595 19121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,595 | ^~ 2023-09-09T03:24:10,596 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-09T03:24:10,597 19121 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2023-09-09T03:24:10,597 | ^~~~~~~~ 2023-09-09T03:24:10,598 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_localAnchorA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,599 Box2D/Box2D_wrap.cpp:19190:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,600 19190 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,600 | ^~ 2023-09-09T03:24:10,601 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-09T03:24:10,602 19190 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,602 | ^~~~~~~~ 2023-09-09T03:24:10,604 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_localAnchorB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,605 Box2D/Box2D_wrap.cpp:19213:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,605 19213 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,606 | ^~ 2023-09-09T03:24:10,607 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-09T03:24:10,607 19213 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,608 | ^~~~~~~~ 2023-09-09T03:24:10,609 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_referenceAngle_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,609 Box2D/Box2D_wrap.cpp:19229:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,610 19229 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,611 | ^~ 2023-09-09T03:24:10,611 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-09T03:24:10,612 19229 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,612 | ^~~~~~~~ 2023-09-09T03:24:10,613 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_frequencyHz_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,613 Box2D/Box2D_wrap.cpp:19245:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,614 19245 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,615 | ^~ 2023-09-09T03:24:10,615 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-09T03:24:10,616 19245 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,616 | ^~~~~~~~ 2023-09-09T03:24:10,617 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef_dampingRatio_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,617 Box2D/Box2D_wrap.cpp:19261:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,618 19261 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,619 | ^~ 2023-09-09T03:24:10,619 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-09T03:24:10,620 19261 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,620 | ^~~~~~~~ 2023-09-09T03:24:10,621 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,622 Box2D/Box2D_wrap.cpp:19268:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,622 19268 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,623 | ^~ 2023-09-09T03:24:10,623 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-09T03:24:10,624 19268 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJointDef, 0 | 0 ); 2023-09-09T03:24:10,625 | ^~~~~~~~ 2023-09-09T03:24:10,625 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,626 Box2D/Box2D_wrap.cpp:19294:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,626 19294 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,627 | ^~ 2023-09-09T03:24:10,628 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-09T03:24:10,628 19294 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,629 | ^~~~~~~~ 2023-09-09T03:24:10,629 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,630 Box2D/Box2D_wrap.cpp:19303:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,631 19303 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,631 | ^~ 2023-09-09T03:24:10,632 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-09T03:24:10,632 19303 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,633 | ^~~~~~~~ 2023-09-09T03:24:10,633 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetReferenceAngle(PyObject*, PyObject*)’: 2023-09-09T03:24:10,634 Box2D/Box2D_wrap.cpp:19312:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,634 19312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,635 | ^~ 2023-09-09T03:24:10,636 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-09T03:24:10,636 19312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,637 | ^~~~~~~~ 2023-09-09T03:24:10,637 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetFrequency(PyObject*, PyObject*)’: 2023-09-09T03:24:10,638 Box2D/Box2D_wrap.cpp:19330:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,638 19330 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,639 | ^~ 2023-09-09T03:24:10,640 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-09T03:24:10,640 19330 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,641 | ^~~~~~~~ 2023-09-09T03:24:10,641 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetDampingRatio(PyObject*, PyObject*)’: 2023-09-09T03:24:10,642 Box2D/Box2D_wrap.cpp:19348:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,642 19348 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,643 | ^~ 2023-09-09T03:24:10,644 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-09T03:24:10,644 19348 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,645 | ^~~~~~~~ 2023-09-09T03:24:10,646 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,646 Box2D/Box2D_wrap.cpp:19356:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,647 19356 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,647 | ^~ 2023-09-09T03:24:10,648 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-09T03:24:10,649 19356 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2023-09-09T03:24:10,649 | ^~~~~~~~ 2023-09-09T03:24:10,657 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_localAnchorA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,657 Box2D/Box2D_wrap.cpp:19434:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,658 19434 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,659 | ^~ 2023-09-09T03:24:10,659 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-09T03:24:10,660 19434 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,660 | ^~~~~~~~ 2023-09-09T03:24:10,662 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_localAnchorB_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,663 Box2D/Box2D_wrap.cpp:19457:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,663 19457 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,664 | ^~ 2023-09-09T03:24:10,665 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-09T03:24:10,665 19457 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,666 | ^~~~~~~~ 2023-09-09T03:24:10,668 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_localAxisA_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,669 Box2D/Box2D_wrap.cpp:19480:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,669 19480 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,670 | ^~ 2023-09-09T03:24:10,670 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-09T03:24:10,671 19480 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,672 | ^~~~~~~~ 2023-09-09T03:24:10,672 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_enableMotor_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,673 Box2D/Box2D_wrap.cpp:19496:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,674 19496 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,674 | ^~ 2023-09-09T03:24:10,675 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-09T03:24:10,676 19496 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,676 | ^~~~~~~~ 2023-09-09T03:24:10,677 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_maxMotorTorque_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,677 Box2D/Box2D_wrap.cpp:19512:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,678 19512 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,678 | ^~ 2023-09-09T03:24:10,679 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-09T03:24:10,680 19512 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,680 | ^~~~~~~~ 2023-09-09T03:24:10,681 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_motorSpeed_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,682 Box2D/Box2D_wrap.cpp:19528:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,682 19528 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,683 | ^~ 2023-09-09T03:24:10,683 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-09T03:24:10,684 19528 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,684 | ^~~~~~~~ 2023-09-09T03:24:10,685 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_frequencyHz_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,686 Box2D/Box2D_wrap.cpp:19544:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,686 19544 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,687 | ^~ 2023-09-09T03:24:10,687 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-09T03:24:10,688 19544 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,688 | ^~~~~~~~ 2023-09-09T03:24:10,689 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef_dampingRatio_get(PyObject*, PyObject*)’: 2023-09-09T03:24:10,690 Box2D/Box2D_wrap.cpp:19560:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,690 19560 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,691 | ^~ 2023-09-09T03:24:10,691 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-09T03:24:10,692 19560 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,692 | ^~~~~~~~ 2023-09-09T03:24:10,693 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJointDef___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,694 Box2D/Box2D_wrap.cpp:19567:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,694 19567 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,695 | ^~ 2023-09-09T03:24:10,696 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-09T03:24:10,696 19567 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJointDef, 0 | 0 ); 2023-09-09T03:24:10,697 | ^~~~~~~~ 2023-09-09T03:24:10,698 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint_GetLocalAnchorA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,698 Box2D/Box2D_wrap.cpp:19593:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,699 19593 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,699 | ^~ 2023-09-09T03:24:10,700 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-09T03:24:10,700 19593 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,701 | ^~~~~~~~ 2023-09-09T03:24:10,702 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint_GetLocalAnchorB(PyObject*, PyObject*)’: 2023-09-09T03:24:10,702 Box2D/Box2D_wrap.cpp:19602:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,703 19602 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,703 | ^~ 2023-09-09T03:24:10,704 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-09T03:24:10,704 19602 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,705 | ^~~~~~~~ 2023-09-09T03:24:10,706 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint_GetLocalAxisA(PyObject*, PyObject*)’: 2023-09-09T03:24:10,706 Box2D/Box2D_wrap.cpp:19611:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,707 19611 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,707 | ^~ 2023-09-09T03:24:10,708 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-09T03:24:10,708 19611 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,709 | ^~~~~~~~ 2023-09-09T03:24:10,709 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetJointTranslation(PyObject*, PyObject*)’: 2023-09-09T03:24:10,710 Box2D/Box2D_wrap.cpp:19620:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,711 19620 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,711 | ^~ 2023-09-09T03:24:10,712 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-09T03:24:10,712 19620 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,713 | ^~~~~~~~ 2023-09-09T03:24:10,714 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetJointSpeed(PyObject*, PyObject*)’: 2023-09-09T03:24:10,714 Box2D/Box2D_wrap.cpp:19629:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,715 19629 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,715 | ^~ 2023-09-09T03:24:10,716 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-09T03:24:10,717 19629 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,717 | ^~~~~~~~ 2023-09-09T03:24:10,718 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___IsMotorEnabled(PyObject*, PyObject*)’: 2023-09-09T03:24:10,718 Box2D/Box2D_wrap.cpp:19637:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,719 19637 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,720 | ^~ 2023-09-09T03:24:10,721 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-09T03:24:10,721 19637 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,722 | ^~~~~~~~ 2023-09-09T03:24:10,722 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetMotorSpeed(PyObject*, PyObject*)’: 2023-09-09T03:24:10,723 Box2D/Box2D_wrap.cpp:19666:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,723 19666 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,724 | ^~ 2023-09-09T03:24:10,725 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-09T03:24:10,725 19666 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,726 | ^~~~~~~~ 2023-09-09T03:24:10,726 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetMaxMotorTorque(PyObject*, PyObject*)’: 2023-09-09T03:24:10,727 Box2D/Box2D_wrap.cpp:19685:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,728 19685 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,728 | ^~ 2023-09-09T03:24:10,729 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-09T03:24:10,729 19685 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,730 | ^~~~~~~~ 2023-09-09T03:24:10,731 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetSpringFrequencyHz(PyObject*, PyObject*)’: 2023-09-09T03:24:10,731 Box2D/Box2D_wrap.cpp:19717:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,732 19717 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,732 | ^~ 2023-09-09T03:24:10,733 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-09T03:24:10,734 19717 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,734 | ^~~~~~~~ 2023-09-09T03:24:10,735 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetSpringDampingRatio(PyObject*, PyObject*)’: 2023-09-09T03:24:10,736 Box2D/Box2D_wrap.cpp:19737:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,736 19737 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,737 | ^~ 2023-09-09T03:24:10,738 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-09T03:24:10,738 19737 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,739 | ^~~~~~~~ 2023-09-09T03:24:10,739 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___hash__(PyObject*, PyObject*)’: 2023-09-09T03:24:10,740 Box2D/Box2D_wrap.cpp:19746:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2023-09-09T03:24:10,741 19746 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,741 | ^~ 2023-09-09T03:24:10,742 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-09T03:24:10,742 19746 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2023-09-09T03:24:10,743 | ^~~~~~~~ 2023-09-09T03:25:15,595 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-09T03:25:17,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/Collision/Shapes/b2CircleShape.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Collision/Shapes/b2CircleShape.o -I. -Wno-unused 2023-09-09T03:25:18,306 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-09T03:25:19,616 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-09T03:25:21,318 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-09T03:25:22,681 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-09T03:25:23,990 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-09T03:25:25,889 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-09T03:25:27,384 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-09T03:25:28,866 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-09T03:25:30,681 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-09T03:25:31,607 Box2D/Collision/b2DynamicTree.cpp: In constructor ‘b2DynamicTree::b2DynamicTree()’: 2023-09-09T03:25:31,608 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-09T03:25:31,608 32 | memset(m_nodes, 0, m_nodeCapacity * sizeof(b2TreeNode)); 2023-09-09T03:25:31,609 | ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-09T03:25:31,610 In file included from Box2D/Collision/b2DynamicTree.cpp:19: 2023-09-09T03:25:31,610 ./Box2D/Collision/b2DynamicTree.h:28:8: note: ‘struct b2TreeNode’ declared here 2023-09-09T03:25:31,611 28 | struct b2TreeNode 2023-09-09T03:25:31,611 | ^~~~~~~~~~ 2023-09-09T03:25:32,943 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-09T03:25:34,962 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-09T03:25:36,643 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-09T03:25:37,772 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-09T03:25:38,985 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-09T03:25:40,085 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-09T03:25:40,994 In file included from ./Box2D/Common/b2StackAllocator.h:22, 2023-09-09T03:25:40,995 from Box2D/Common/b2StackAllocator.cpp:19: 2023-09-09T03:25:40,996 Box2D/Common/b2StackAllocator.cpp: In destructor ‘b2StackAllocator::~b2StackAllocator()’: 2023-09-09T03:25:40,996 ./Box2D/Common/b2Settings.h:31:76: warning: ‘throw’ will always call ‘terminate’ [-Wterminate] 2023-09-09T03:25:40,997 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2023-09-09T03:25:40,997 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-09T03:25:40,998 Box2D/Common/b2StackAllocator.cpp:32:9: note: in expansion of macro ‘b2Assert’ 2023-09-09T03:25:40,999 32 | b2Assert(m_index == 0); 2023-09-09T03:25:41,000 | ^~~~~~~~ 2023-09-09T03:25:41,000 ./Box2D/Common/b2Settings.h:31:76: note: in C++11 destructors default to ‘noexcept’ 2023-09-09T03:25:41,001 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2023-09-09T03:25:41,002 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-09T03:25:41,003 Box2D/Common/b2StackAllocator.cpp:32:9: note: in expansion of macro ‘b2Assert’ 2023-09-09T03:25:41,003 32 | b2Assert(m_index == 0); 2023-09-09T03:25:41,004 | ^~~~~~~~ 2023-09-09T03:25:41,004 ./Box2D/Common/b2Settings.h:31:76: warning: ‘throw’ will always call ‘terminate’ [-Wterminate] 2023-09-09T03:25:41,005 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2023-09-09T03:25:41,005 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-09T03:25:41,006 Box2D/Common/b2StackAllocator.cpp:33:9: note: in expansion of macro ‘b2Assert’ 2023-09-09T03:25:41,006 33 | b2Assert(m_entryCount == 0); 2023-09-09T03:25:41,007 | ^~~~~~~~ 2023-09-09T03:25:41,007 ./Box2D/Common/b2Settings.h:31:76: note: in C++11 destructors default to ‘noexcept’ 2023-09-09T03:25:41,008 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2023-09-09T03:25:41,009 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2023-09-09T03:25:41,009 Box2D/Common/b2StackAllocator.cpp:33:9: note: in expansion of macro ‘b2Assert’ 2023-09-09T03:25:41,010 33 | b2Assert(m_entryCount == 0); 2023-09-09T03:25:41,010 | ^~~~~~~~ 2023-09-09T03:25:41,289 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-09T03:25:42,386 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-09T03:25:44,098 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-09T03:25:45,838 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-09T03:25:47,526 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-09T03:25:49,583 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-09T03:25:52,399 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-09T03:25:54,080 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-09T03:25:55,773 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-09T03:25:57,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/Contacts/b2PolygonContact.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Contacts/b2PolygonContact.o -I. -Wno-unused 2023-09-09T03:25:59,158 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-09T03:26:01,151 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-09T03:26:03,122 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-09T03:26:05,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/b2Joint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2Joint.o -I. -Wno-unused 2023-09-09T03:26:07,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/Dynamics/Joints/b2MotorJoint.cpp -o build/temp.linux-armv7l-cpython-311/Box2D/Dynamics/Joints/b2MotorJoint.o -I. -Wno-unused 2023-09-09T03:26:09,243 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-09T03:26:11,173 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-09T03:26:13,656 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-09T03:26:15,770 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-09T03:26:18,071 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-09T03:26:20,016 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-09T03:26:22,083 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-09T03:26:24,212 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-09T03:26:26,594 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-09T03:26:29,122 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-09T03:26:31,218 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-09T03:26:33,513 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-09T03:26:37,359 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-09T03:26:39,027 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-09T03:26:39,807 /usr/local/lib/python3.11/dist-packages/setuptools/_distutils/cmd.py:66: SetuptoolsDeprecationWarning: setup.py install is deprecated. 2023-09-09T03:26:39,808 !! 2023-09-09T03:26:39,809 ******************************************************************************** 2023-09-09T03:26:39,810 Please avoid running ``setup.py`` directly. 2023-09-09T03:26:39,810 Instead, use pypa/build, pypa/installer or other 2023-09-09T03:26:39,811 standards-based tools. 2023-09-09T03:26:39,812 See https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html for details. 2023-09-09T03:26:39,813 ******************************************************************************** 2023-09-09T03:26:39,814 !! 2023-09-09T03:26:39,815 self.initialize_options() 2023-09-09T03:26:39,830 installing to build/bdist.linux-armv7l/wheel 2023-09-09T03:26:39,831 running install 2023-09-09T03:26:39,855 running install_lib 2023-09-09T03:26:39,875 creating build/bdist.linux-armv7l 2023-09-09T03:26:39,876 creating build/bdist.linux-armv7l/wheel 2023-09-09T03:26:39,877 creating build/bdist.linux-armv7l/wheel/Box2D 2023-09-09T03:26:39,879 copying build/lib.linux-armv7l-cpython-311/Box2D/_Box2D.cpython-311-arm-linux-gnueabihf.so -> build/bdist.linux-armv7l/wheel/Box2D 2023-09-09T03:26:39,965 copying build/lib.linux-armv7l-cpython-311/Box2D/__init__.py -> build/bdist.linux-armv7l/wheel/Box2D 2023-09-09T03:26:39,968 copying build/lib.linux-armv7l-cpython-311/Box2D/Box2D.py -> build/bdist.linux-armv7l/wheel/Box2D 2023-09-09T03:26:39,975 creating build/bdist.linux-armv7l/wheel/Box2D/b2 2023-09-09T03:26:39,977 copying build/lib.linux-armv7l-cpython-311/Box2D/b2/__init__.py -> build/bdist.linux-armv7l/wheel/Box2D/b2 2023-09-09T03:26:39,979 running install_egg_info 2023-09-09T03:26:40,033 running egg_info 2023-09-09T03:26:40,051 writing library/Box2D.egg-info/PKG-INFO 2023-09-09T03:26:40,053 writing dependency_links to library/Box2D.egg-info/dependency_links.txt 2023-09-09T03:26:40,055 writing top-level names to library/Box2D.egg-info/top_level.txt 2023-09-09T03:26:40,082 reading manifest file 'library/Box2D.egg-info/SOURCES.txt' 2023-09-09T03:26:40,124 reading manifest template 'MANIFEST.in' 2023-09-09T03:26:40,125 warning: no files found matching 'INSTALL' 2023-09-09T03:26:40,125 warning: no files found matching 'MANIFEST' 2023-09-09T03:26:40,126 warning: no files found matching 'README' 2023-09-09T03:26:40,127 warning: no files found matching 'distribute_setup.py' 2023-09-09T03:26:40,427 warning: no files found matching '*.py' under directory 'Box2D' 2023-09-09T03:26:40,565 warning: no files found matching '*.c' under directory 'Box2D' 2023-09-09T03:26:40,599 adding license file 'LICENSE' 2023-09-09T03:26:40,615 writing manifest file 'library/Box2D.egg-info/SOURCES.txt' 2023-09-09T03:26:40,618 Copying library/Box2D.egg-info to build/bdist.linux-armv7l/wheel/Box2D-2.3.2-py3.11.egg-info 2023-09-09T03:26:40,625 running install_scripts 2023-09-09T03:26:40,671 creating build/bdist.linux-armv7l/wheel/Box2D-2.3.2.dist-info/WHEEL 2023-09-09T03:26:40,674 creating '/tmp/pip-wheel-x_0_gwee/Box2D-2.3.2-cp311-cp311-linux_armv7l.whl' and adding 'build/bdist.linux-armv7l/wheel' to it 2023-09-09T03:26:40,705 adding 'Box2D/Box2D.py' 2023-09-09T03:26:41,743 adding 'Box2D/_Box2D.cpython-311-arm-linux-gnueabihf.so' 2023-09-09T03:26:41,795 adding 'Box2D/__init__.py' 2023-09-09T03:26:41,797 adding 'Box2D/b2/__init__.py' 2023-09-09T03:26:41,799 adding 'Box2D-2.3.2.dist-info/LICENSE' 2023-09-09T03:26:41,801 adding 'Box2D-2.3.2.dist-info/METADATA' 2023-09-09T03:26:41,802 adding 'Box2D-2.3.2.dist-info/WHEEL' 2023-09-09T03:26:41,803 adding 'Box2D-2.3.2.dist-info/top_level.txt' 2023-09-09T03:26:41,805 adding 'Box2D-2.3.2.dist-info/RECORD' 2023-09-09T03:26:41,829 removing build/bdist.linux-armv7l/wheel 2023-09-09T03:26:41,937 Building wheel for box2d (setup.py): finished with status 'done' 2023-09-09T03:26:41,967 Created wheel for box2d: filename=Box2D-2.3.2-cp311-cp311-linux_armv7l.whl size=2264074 sha256=517e50f5d0ad5cb70eedc01fba0003c6b7ba6964436521e108a7e0446a50151b 2023-09-09T03:26:41,969 Stored in directory: /tmp/pip-ephem-wheel-cache-bynfroql/wheels/e3/34/dd/9901b8d6cf4eb85dc3e843cb2f24cfc9ab0c2e76c5f1334d1d 2023-09-09T03:26:41,979 Successfully built box2d 2023-09-09T03:26:42,094 Removed build tracker: '/tmp/pip-build-tracker-y8h5nyyd'