2025-09-08T14:55:55,569 Created temporary directory: /tmp/pip-build-tracker-__r1wjiv 2025-09-08T14:55:55,570 Initialized build tracking at /tmp/pip-build-tracker-__r1wjiv 2025-09-08T14:55:55,570 Created build tracker: /tmp/pip-build-tracker-__r1wjiv 2025-09-08T14:55:55,570 Entered build tracker: /tmp/pip-build-tracker-__r1wjiv 2025-09-08T14:55:55,570 Created temporary directory: /tmp/pip-wheel-rr9v2e0l 2025-09-08T14:55:55,574 Created temporary directory: /tmp/pip-ephem-wheel-cache-_what2is 2025-09-08T14:55:55,636 Looking in indexes: https://pypi.org/simple, https://www.piwheels.org/simple 2025-09-08T14:55:55,638 2 location(s) to search for versions of box2d-py: 2025-09-08T14:55:55,638 * https://pypi.org/simple/box2d-py/ 2025-09-08T14:55:55,638 * https://www.piwheels.org/simple/box2d-py/ 2025-09-08T14:55:55,638 Fetching project page and analyzing links: https://pypi.org/simple/box2d-py/ 2025-09-08T14:55:55,639 Getting page https://pypi.org/simple/box2d-py/ 2025-09-08T14:55:55,640 Found index url https://pypi.org/simple/ 2025-09-08T14:55:55,711 Fetched page https://pypi.org/simple/box2d-py/ as application/vnd.pypi.simple.v1+json 2025-09-08T14:55:55,714 Found link https://files.pythonhosted.org/packages/d1/61/8d3837c797f3b959b00d9868f873dca961c1cf59545d82e7f26752f209f7/box2d-py-2.3.1.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.1 2025-09-08T14:55:55,715 Found link https://files.pythonhosted.org/packages/5d/73/1be62ed955f2c57dddca56d8c0755c7b70f490ff03e971080f807db9a869/box2d-py-2.3.4.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.4 2025-09-08T14:55:55,715 Found link https://files.pythonhosted.org/packages/dd/5a/ad8d3ef9c13d5afcc1e44a77f11792ee717f6727b3320bddbc607e935e2a/box2d-py-2.3.5.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.5 2025-09-08T14:55:55,715 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/35/1b/9326661e058e2fbcda2e5b78f58b4406dfb2ae07ae25869cf97e3f708217/box2d_py-2.3.5-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,715 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/72/d7/8f59be9952bcdabb5d716e12b36a6b6c4854f23930938e7d02797125728b/box2d_py-2.3.5-cp36-cp36m-macosx_10_13_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,716 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/16/a0/040870c99d16231bb2001e70ab7fc40d05b297fd4e03448cbad56657c75f/box2d_py-2.3.5-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,716 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/ac/51/2ab97653ad23aba5645d82c6f7335d7a8cd8d9db94bd6f35599e44f7cdea/box2d_py-2.3.5-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,716 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/90/0c/a21a63ba4a45f99da2792318ba82e9afb181da59beab503b1eb34f2088b7/box2d_py-2.3.6-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,716 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/b8/71/f7cdeddf91dcc976448678d2e4b84b83ce868281e97b3ccbbfa685d120e0/box2d_py-2.3.6-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,716 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/6c/9e/7afdf4e96536591e3760780488e7e1763b1c5ce297be7a603502747911ba/box2d_py-2.3.6-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,716 Found link https://files.pythonhosted.org/packages/2f/2c/1de11a022d552d194df396d75b7f6087fc7b9d27a3b13d177db2087fbce5/box2d-py-2.3.7.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.7 2025-09-08T14:55:55,717 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/6f/16/d47e1d6ec7a130445fb12812bcbccf0f7e9a9af9659c27431e5058ad5204/box2d_py-2.3.7-cp35-cp35m-macosx_10_5_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,717 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/47/73/48216f98d890373f2679c1f708641a7cde2f72fb203f9a4692bb02ed7165/box2d_py-2.3.7-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,717 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/c8/70/dd3f135e4cb7586c3c438c2fb54a0667eced89befcdbaf8593097db526b1/box2d_py-2.3.7-cp36-cp36m-macosx_10_7_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,717 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/49/1c/f7c72f6d96e906b40fbe1634dc9b1b7f9edc781d142e5aaedcc9aa4e1ea7/box2d_py-2.3.7-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,717 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/88/f3/73dbd3276344adf90d3894ab6c32e54a8148fea1e67c96822996d037ab53/box2d_py-2.3.7-cp37-cp37m-macosx_10_7_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,717 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/53/82/b0d9543d55729f18ab3187bd6b391e6c944b01743356dc5ad1a577db00cf/box2d_py-2.3.7-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,717 Found link https://files.pythonhosted.org/packages/98/c2/ab05b5329dc4416b5ee5530f0625a79c394a3e3c10abe0812b9345256451/box2d-py-2.3.8.tar.gz (from https://pypi.org/simple/box2d-py/), version: 2.3.8 2025-09-08T14:55:55,718 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/a6/c3/09b5fd0ee5a67d63cfb6ed73131675b2379187042f7b0c1c9839817d6b21/box2d_py-2.3.8-cp35-cp35m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,718 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/c4/59/58faf9c8277efd22509db7fc068d971d894ebf650ff73770401a4d5bed78/box2d_py-2.3.8-cp35-cp35m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,718 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/04/e3/9ca87ab61772eda6e65a0a21aac4d3ae006c265604ce82403d14a31862dd/box2d_py-2.3.8-cp36-cp36m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,718 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/06/bd/6cdc3fd994b0649dcf5d9bad85bd9e26172308bbe9a421bfc6fdbf5081a6/box2d_py-2.3.8-cp36-cp36m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,718 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/02/a8/f6f6986fe3c8f53ef8ddf7ac73ec7f87e45b0beccce8067194fa8d658a07/box2d_py-2.3.8-cp37-cp37m-macosx_10_6_intel.macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,718 Skipping link: No binaries permitted for box2d-py: https://files.pythonhosted.org/packages/87/34/da5393985c3ff9a76351df6127c275dcb5749ae0abbe8d5210f06d97405d/box2d_py-2.3.8-cp37-cp37m-manylinux1_x86_64.whl (from https://pypi.org/simple/box2d-py/) 2025-09-08T14:55:55,719 Fetching project page and analyzing links: https://www.piwheels.org/simple/box2d-py/ 2025-09-08T14:55:55,719 Getting page https://www.piwheels.org/simple/box2d-py/ 2025-09-08T14:55:55,720 Found index url https://www.piwheels.org/simple/ 2025-09-08T14:55:55,826 Fetched page https://www.piwheels.org/simple/box2d-py/ as text/html 2025-09-08T14:55:55,832 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.8-cp39-cp39-linux_armv6l.whl#sha256=162fca658a9bf149c03a1d447e56a587903ea51079b2e15eabf480493b865f1f (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,833 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.8-cp39-cp39-linux_armv7l.whl#sha256=162fca658a9bf149c03a1d447e56a587903ea51079b2e15eabf480493b865f1f (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,833 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.8-cp311-cp311-linux_armv6l.whl#sha256=44be3c0ab20c8726e8125f12fe1647055b66947e3d65977c0a91c6875e78e1c8 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,833 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.8-cp311-cp311-linux_armv7l.whl#sha256=44be3c0ab20c8726e8125f12fe1647055b66947e3d65977c0a91c6875e78e1c8 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,833 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.7-cp39-cp39-linux_armv6l.whl#sha256=3fcd8141bd85eb6eef455f4e083cf206b4c71ad350c0531d2a7161e39c4c9d1d (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,833 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.7-cp39-cp39-linux_armv7l.whl#sha256=3fcd8141bd85eb6eef455f4e083cf206b4c71ad350c0531d2a7161e39c4c9d1d (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,833 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.7-cp311-cp311-linux_armv6l.whl#sha256=5d2d199b09605b274612c3a0c4df135f33ee4c6a335f13d00bc916a180d1a8cd (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,834 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.7-cp311-cp311-linux_armv7l.whl#sha256=5d2d199b09605b274612c3a0c4df135f33ee4c6a335f13d00bc916a180d1a8cd (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,834 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.5-cp39-cp39-linux_armv6l.whl#sha256=8c797817040f4b59550773f4dcead3715a1bf278674318335265587c42dc57d0 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,834 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.5-cp39-cp39-linux_armv7l.whl#sha256=8c797817040f4b59550773f4dcead3715a1bf278674318335265587c42dc57d0 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,834 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.5-cp311-cp311-linux_armv6l.whl#sha256=f20f09910c0d44af4d9d387fc530ac8abc3a5f5315e80b2f92af00d8f95c16e0 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,834 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.5-cp311-cp311-linux_armv7l.whl#sha256=f20f09910c0d44af4d9d387fc530ac8abc3a5f5315e80b2f92af00d8f95c16e0 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,834 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.5-cp313-cp313-linux_armv6l.whl#sha256=789a5f311e74f453ce21422d7406371ea6d4e37a014f2cccf60908fafcdba73d (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,834 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.5-cp313-cp313-linux_armv7l.whl#sha256=789a5f311e74f453ce21422d7406371ea6d4e37a014f2cccf60908fafcdba73d (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,835 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.4-cp39-cp39-linux_armv6l.whl#sha256=4aad27a947974e644fa4b4e391ef14066718d352bebba16cfcbfa506dd5fd4f0 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,835 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.4-cp39-cp39-linux_armv7l.whl#sha256=4aad27a947974e644fa4b4e391ef14066718d352bebba16cfcbfa506dd5fd4f0 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,835 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.4-cp311-cp311-linux_armv6l.whl#sha256=045998dc99502ee783d2f224beb06fc4808db39cd2795d25ba0fa4a459ed6c10 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,835 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.4-cp311-cp311-linux_armv7l.whl#sha256=045998dc99502ee783d2f224beb06fc4808db39cd2795d25ba0fa4a459ed6c10 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,835 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.4-cp313-cp313-linux_armv6l.whl#sha256=4445c5773f403234976086f3cf6ba39e3ae7f6dbdb037b5d86ed5cd4fe731b73 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,835 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.4-cp313-cp313-linux_armv7l.whl#sha256=4445c5773f403234976086f3cf6ba39e3ae7f6dbdb037b5d86ed5cd4fe731b73 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,836 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.1-cp311-cp311-linux_armv6l.whl#sha256=ac4c9d1a44d2a93fcc4c86aeda8776aa08a68e9d7ff1ca1cadf958806c3c27c1 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,836 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.1-cp311-cp311-linux_armv7l.whl#sha256=ac4c9d1a44d2a93fcc4c86aeda8776aa08a68e9d7ff1ca1cadf958806c3c27c1 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,836 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.1-cp39-cp39-linux_armv6l.whl#sha256=b431f1f1d947e2ef2c23055f721e80b7087d94ac5c76efbdbca11928c76f50e3 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,836 Skipping link: No binaries permitted for box2d-py: https://archive1.piwheels.org/simple/box2d-py/box2d_py-2.3.1-cp39-cp39-linux_armv7l.whl#sha256=b431f1f1d947e2ef2c23055f721e80b7087d94ac5c76efbdbca11928c76f50e3 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,836 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.1-cp313-cp313-linux_armv6l.whl#sha256=aac4ff63c75fddff931d76afa9b214161341b76db568a3ba1980dfa5dd128df3 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,836 Skipping link: No binaries permitted for box2d-py: https://www.piwheels.org/simple/box2d-py/box2d_py-2.3.1-cp313-cp313-linux_armv7l.whl#sha256=aac4ff63c75fddff931d76afa9b214161341b76db568a3ba1980dfa5dd128df3 (from https://www.piwheels.org/simple/box2d-py/) 2025-09-08T14:55:55,836 Skipping link: not a file: https://www.piwheels.org/simple/box2d-py/ 2025-09-08T14:55:55,837 Skipping link: not a file: https://pypi.org/simple/box2d-py/ 2025-09-08T14:55:55,862 Given no hashes to check 1 links for project 'box2d-py': discarding no candidates 2025-09-08T14:55:55,863 Collecting box2d-py==2.3.8 2025-09-08T14:55:55,864 Created temporary directory: /tmp/pip-unpack-dhfrgrb8 2025-09-08T14:55:55,927 Downloading box2d-py-2.3.8.tar.gz (374 kB) 2025-09-08T14:55:56,183 Added box2d-py==2.3.8 from https://files.pythonhosted.org/packages/98/c2/ab05b5329dc4416b5ee5530f0625a79c394a3e3c10abe0812b9345256451/box2d-py-2.3.8.tar.gz to build tracker '/tmp/pip-build-tracker-__r1wjiv' 2025-09-08T14:55:56,184 Running setup.py (path:/tmp/pip-wheel-rr9v2e0l/box2d-py_a9dbc856dab44f5bad24cdb56cb54f91/setup.py) egg_info for package box2d-py 2025-09-08T14:55:56,184 Created temporary directory: /tmp/pip-pip-egg-info-1nvvmvpn 2025-09-08T14:55:56,184 Preparing metadata (setup.py): started 2025-09-08T14:55:56,185 Running command python setup.py egg_info 2025-09-08T14:55:56,869 /usr/local/lib/python3.13/dist-packages/setuptools/_distutils/dist.py:289: UserWarning: Unknown distribution option: 'test_suite' 2025-09-08T14:55:56,870 warnings.warn(msg) 2025-09-08T14:55:57,262 /usr/local/lib/python3.13/dist-packages/setuptools/dist.py:759: SetuptoolsDeprecationWarning: License classifiers are deprecated. 2025-09-08T14:55:57,262 !! 2025-09-08T14:55:57,263 ******************************************************************************** 2025-09-08T14:55:57,263 Please consider removing the following classifiers in favor of a SPDX license expression: 2025-09-08T14:55:57,263 License :: OSI Approved :: zlib/libpng License 2025-09-08T14:55:57,263 See https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#license for details. 2025-09-08T14:55:57,263 ******************************************************************************** 2025-09-08T14:55:57,263 !! 2025-09-08T14:55:57,263 self._finalize_license_expression() 2025-09-08T14:55:57,335 Using setuptools (version 80.9.0). 2025-09-08T14:55:57,336 running egg_info 2025-09-08T14:55:57,410 creating /tmp/pip-pip-egg-info-1nvvmvpn/box2d_py.egg-info 2025-09-08T14:55:57,410 writing /tmp/pip-pip-egg-info-1nvvmvpn/box2d_py.egg-info/PKG-INFO 2025-09-08T14:55:57,412 writing dependency_links to /tmp/pip-pip-egg-info-1nvvmvpn/box2d_py.egg-info/dependency_links.txt 2025-09-08T14:55:57,412 writing top-level names to /tmp/pip-pip-egg-info-1nvvmvpn/box2d_py.egg-info/top_level.txt 2025-09-08T14:55:57,413 writing manifest file '/tmp/pip-pip-egg-info-1nvvmvpn/box2d_py.egg-info/SOURCES.txt' 2025-09-08T14:55:57,704 reading manifest file '/tmp/pip-pip-egg-info-1nvvmvpn/box2d_py.egg-info/SOURCES.txt' 2025-09-08T14:55:57,705 reading manifest template 'MANIFEST.in' 2025-09-08T14:55:57,705 warning: no files found matching 'INSTALL' 2025-09-08T14:55:57,706 warning: no files found matching 'MANIFEST' 2025-09-08T14:55:57,706 warning: no files found matching 'README' 2025-09-08T14:55:57,707 warning: no files found matching 'distribute_setup.py' 2025-09-08T14:55:57,756 warning: no files found matching '*.py' under directory 'Box2D' 2025-09-08T14:55:57,777 warning: no files found matching '*.c' under directory 'Box2D' 2025-09-08T14:55:57,782 adding license file 'LICENSE' 2025-09-08T14:55:57,794 writing manifest file '/tmp/pip-pip-egg-info-1nvvmvpn/box2d_py.egg-info/SOURCES.txt' 2025-09-08T14:55:57,910 Preparing metadata (setup.py): finished with status 'done' 2025-09-08T14:55:57,915 Source in /tmp/pip-wheel-rr9v2e0l/box2d-py_a9dbc856dab44f5bad24cdb56cb54f91 has version 2.3.8, which satisfies requirement box2d-py==2.3.8 from https://files.pythonhosted.org/packages/98/c2/ab05b5329dc4416b5ee5530f0625a79c394a3e3c10abe0812b9345256451/box2d-py-2.3.8.tar.gz 2025-09-08T14:55:57,915 Removed box2d-py==2.3.8 from https://files.pythonhosted.org/packages/98/c2/ab05b5329dc4416b5ee5530f0625a79c394a3e3c10abe0812b9345256451/box2d-py-2.3.8.tar.gz from build tracker '/tmp/pip-build-tracker-__r1wjiv' 2025-09-08T14:55:57,918 Created temporary directory: /tmp/pip-unpack-ls5eo3d3 2025-09-08T14:55:57,918 Created temporary directory: /tmp/pip-unpack-p8mil63b 2025-09-08T14:55:57,919 Building wheels for collected packages: box2d-py 2025-09-08T14:55:57,920 Created temporary directory: /tmp/pip-wheel-r_3t0tx0 2025-09-08T14:55:57,920 DEPRECATION: Building 'box2d-py' using the legacy setup.py bdist_wheel mechanism, which will be removed in a future version. pip 25.3 will enforce this behaviour change. A possible replacement is to use the standardized build interface by setting the `--use-pep517` option, (possibly combined with `--no-build-isolation`), or adding a `pyproject.toml` file to the source tree of 'box2d-py'. Discussion can be found at https://github.com/pypa/pip/issues/6334 2025-09-08T14:55:57,921 Building wheel for box2d-py (setup.py): started 2025-09-08T14:55:57,922 Destination directory: /tmp/pip-wheel-r_3t0tx0 2025-09-08T14:55:57,922 Running command python setup.py bdist_wheel 2025-09-08T14:55:58,442 Using setuptools (version 80.9.0). 2025-09-08T14:55:58,616 /usr/local/lib/python3.13/dist-packages/setuptools/_distutils/dist.py:289: UserWarning: Unknown distribution option: 'test_suite' 2025-09-08T14:55:58,616 warnings.warn(msg) 2025-09-08T14:55:59,005 /usr/local/lib/python3.13/dist-packages/setuptools/dist.py:759: SetuptoolsDeprecationWarning: License classifiers are deprecated. 2025-09-08T14:55:59,005 !! 2025-09-08T14:55:59,006 ******************************************************************************** 2025-09-08T14:55:59,006 Please consider removing the following classifiers in favor of a SPDX license expression: 2025-09-08T14:55:59,006 License :: OSI Approved :: zlib/libpng License 2025-09-08T14:55:59,006 See https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#license for details. 2025-09-08T14:55:59,006 ******************************************************************************** 2025-09-08T14:55:59,006 !! 2025-09-08T14:55:59,006 self._finalize_license_expression() 2025-09-08T14:55:59,007 running bdist_wheel 2025-09-08T14:55:59,378 running build 2025-09-08T14:55:59,378 running build_py 2025-09-08T14:55:59,461 creating build/lib.linux-armv7l-cpython-313/Box2D 2025-09-08T14:55:59,461 copying library/Box2D/Box2D.py -> build/lib.linux-armv7l-cpython-313/Box2D 2025-09-08T14:55:59,462 copying library/Box2D/__init__.py -> build/lib.linux-armv7l-cpython-313/Box2D 2025-09-08T14:55:59,463 creating build/lib.linux-armv7l-cpython-313/Box2D/b2 2025-09-08T14:55:59,463 copying library/Box2D/b2/__init__.py -> build/lib.linux-armv7l-cpython-313/Box2D/b2 2025-09-08T14:55:59,465 running build_ext 2025-09-08T14:55:59,804 building 'Box2D._Box2D' extension 2025-09-08T14:55:59,804 swigging Box2D/Box2D.i to Box2D/Box2D_wrap.cpp 2025-09-08T14:55:59,804 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 2025-09-08T14:56:00,441 Box2D/Common/b2Math.h:67: Warning 302: Redefinition of identifier 'b2Vec2' by %extend ignored, 2025-09-08T14:56:00,441 Box2D/Box2D_math.i:47: Warning 302: %extend definition of 'b2Vec2'. 2025-09-08T14:56:00,448 Box2D/Common/b2Math.h:158: Warning 302: Redefinition of identifier 'b2Vec3' by %extend ignored, 2025-09-08T14:56:00,448 Box2D/Box2D_math.i:168: Warning 302: %extend definition of 'b2Vec3'. 2025-09-08T14:56:00,455 Box2D/Common/b2Math.h:197: Warning 302: Redefinition of identifier 'b2Mat22' by %extend ignored, 2025-09-08T14:56:00,455 Box2D/Box2D_math.i:301: Warning 302: %extend definition of 'b2Mat22'. 2025-09-08T14:56:00,462 Box2D/Common/b2Math.h:271: Warning 302: Redefinition of identifier 'b2Mat33' by %extend ignored, 2025-09-08T14:56:00,462 Box2D/Box2D_math.i:372: Warning 302: %extend definition of 'b2Mat33'. 2025-09-08T14:56:00,684 Box2D/Collision/b2DynamicTree.h:44: Warning 312: Nested union not currently supported (ignored). 2025-09-08T14:56:01,569 Box2D/Common/b2Settings.h:144: Warning 506: Can't wrap varargs with keyword arguments enabled 2025-09-08T14:56:01,620 Box2D/Common/b2Math.h:91: Warning 509: Overloaded method b2Vec2::operator ()(int32) effectively ignored, 2025-09-08T14:56:01,620 Box2D/Common/b2Math.h:85: Warning 509: as it is shadowed by b2Vec2::operator ()(int32) const. 2025-09-08T14:56:06,067 creating build/temp.linux-armv7l-cpython-313/Box2D 2025-09-08T14:56:06,068 creating build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes 2025-09-08T14:56:06,069 creating build/temp.linux-armv7l-cpython-313/Box2D/Common 2025-09-08T14:56:06,070 creating build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts 2025-09-08T14:56:06,071 creating build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints 2025-09-08T14:56:06,073 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Box2D_wrap.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Box2D_wrap.o -I. -Wno-unused 2025-09-08T14:56:08,787 Box2D/Box2D_wrap.cpp: In function ‘PyObject* b2GetPointStates(const b2Manifold*, const b2Manifold*)’: 2025-09-08T14:56:08,788 Box2D/Box2D_wrap.cpp:4439:13: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,788 4439 | if (state1[i]==b2_nullState && state1_length==0) 2025-09-08T14:56:08,788 | ^~ 2025-09-08T14:56:08,788 Box2D/Box2D_wrap.cpp:4441:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,788 4441 | if (state2_length > -1) 2025-09-08T14:56:08,788 | ^~ 2025-09-08T14:56:08,788 Box2D/Box2D_wrap.cpp:4443:13: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,788 4443 | if (state2[i]==b2_nullState && state2_length==0) 2025-09-08T14:56:08,788 | ^~ 2025-09-08T14:56:08,788 Box2D/Box2D_wrap.cpp:4445:17: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,789 4445 | if (state1_length > -1) 2025-09-08T14:56:08,789 | ^~ 2025-09-08T14:56:08,936 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Random__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:08,936 Box2D/Box2D_wrap.cpp:5966:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,937 5966 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2025-09-08T14:56:08,937 | ^~ 2025-09-08T14:56:08,937 Box2D/Box2D_wrap.cpp:5966:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,937 5966 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2025-09-08T14:56:08,937 | ^~~~~~ 2025-09-08T14:56:08,938 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Random(PyObject*, PyObject*)’: 2025-09-08T14:56:08,939 Box2D/Box2D_wrap.cpp:5974:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,939 5974 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Random", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:08,939 | ^~ 2025-09-08T14:56:08,939 Box2D/Box2D_wrap.cpp:5974:83: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,939 5974 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Random", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:08,939 | ^~ 2025-09-08T14:56:08,940 Box2D/Box2D_wrap.cpp:5977:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,940 5977 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:08,940 | ^~ 2025-09-08T14:56:08,941 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,941 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:08,941 | ^~~~ 2025-09-08T14:56:08,941 Box2D/Box2D_wrap.cpp:5977:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:08,941 5977 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:08,941 | ^~~~~~~~~ 2025-09-08T14:56:08,946 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Distance__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:08,946 Box2D/Box2D_wrap.cpp:6014:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,946 6014 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2025-09-08T14:56:08,946 | ^~ 2025-09-08T14:56:08,946 Box2D/Box2D_wrap.cpp:6014:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,946 6014 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2DistanceInput, 0 | 0 ); 2025-09-08T14:56:08,946 | ^~~~ 2025-09-08T14:56:08,948 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Distance(PyObject*, PyObject*)’: 2025-09-08T14:56:08,948 Box2D/Box2D_wrap.cpp:6022:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,948 6022 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2Distance", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:08,948 | ^~ 2025-09-08T14:56:08,948 Box2D/Box2D_wrap.cpp:6022:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,948 6022 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2Distance", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:08,949 | ^~ 2025-09-08T14:56:08,949 Box2D/Box2D_wrap.cpp:6025:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,949 6025 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:08,950 | ^~ 2025-09-08T14:56:08,950 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,951 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:08,951 | ^~~~ 2025-09-08T14:56:08,951 Box2D/Box2D_wrap.cpp:6025:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:08,951 6025 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:08,951 | ^~~~~~~~~ 2025-09-08T14:56:08,954 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactPoint(PyObject*, PyObject*)’: 2025-09-08T14:56:08,954 Box2D/Box2D_wrap.cpp:6050:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,955 6050 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:08,955 | ^~ 2025-09-08T14:56:08,955 Box2D/Box2D_wrap.cpp:6050:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,955 6050 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:08,955 | ^~~~~~~~ 2025-09-08T14:56:08,977 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2TimeOfImpact(PyObject*, PyObject*)’: 2025-09-08T14:56:08,977 Box2D/Box2D_wrap.cpp:6213:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,977 6213 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2TimeOfImpact", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:08,977 | ^~ 2025-09-08T14:56:08,977 Box2D/Box2D_wrap.cpp:6213:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,977 6213 | if (!(argc = SWIG_Python_UnpackTuple(args, "_b2TimeOfImpact", 0, 7, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:08,977 | ^~ 2025-09-08T14:56:08,977 Box2D/Box2D_wrap.cpp:6215:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,978 6215 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 7) { 2025-09-08T14:56:08,978 | ^~ 2025-09-08T14:56:08,978 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,978 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:08,979 | ^~~~ 2025-09-08T14:56:08,979 Box2D/Box2D_wrap.cpp:6215:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:08,979 6215 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 7) { 2025-09-08T14:56:08,979 | ^~~~~~~~~ 2025-09-08T14:56:08,979 Box2D/Box2D_wrap.cpp:6217:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,979 6217 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:08,979 | ^~ 2025-09-08T14:56:08,980 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,980 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:08,980 | ^~~~ 2025-09-08T14:56:08,980 Box2D/Box2D_wrap.cpp:6217:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:08,980 6217 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:08,980 | ^~~~~~~~~ 2025-09-08T14:56:08,983 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2AssertException(PyObject*, PyObject*)’: 2025-09-08T14:56:08,983 Box2D/Box2D_wrap.cpp:6237:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,983 6237 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:08,983 | ^~ 2025-09-08T14:56:08,983 Box2D/Box2D_wrap.cpp:6237:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,983 6237 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:08,983 | ^~~~~~~~ 2025-09-08T14:56:08,986 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Free(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:08,987 Box2D/Box2D_wrap.cpp:6263:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,987 6263 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Free", kwnames, &obj0)) SWIG_fail; { arg1 = obj0; 2025-09-08T14:56:08,987 | ^~ 2025-09-08T14:56:08,987 Box2D/Box2D_wrap.cpp:6263:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,987 6263 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:b2Free", kwnames, &obj0)) SWIG_fail; { arg1 = obj0; 2025-09-08T14:56:08,987 | ^ 2025-09-08T14:56:08,992 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_major_get(PyObject*, PyObject*)’: 2025-09-08T14:56:08,992 Box2D/Box2D_wrap.cpp:6286:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,992 6286 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2025-09-08T14:56:08,992 | ^~ 2025-09-08T14:56:08,992 Box2D/Box2D_wrap.cpp:6286:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,992 6286 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2025-09-08T14:56:08,992 | ^~~~~~~~ 2025-09-08T14:56:08,995 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_minor_get(PyObject*, PyObject*)’: 2025-09-08T14:56:08,995 Box2D/Box2D_wrap.cpp:6302:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,995 6302 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2025-09-08T14:56:08,995 | ^~ 2025-09-08T14:56:08,995 Box2D/Box2D_wrap.cpp:6302:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,995 6302 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2025-09-08T14:56:08,996 | ^~~~~~~~ 2025-09-08T14:56:08,998 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version_revision_get(PyObject*, PyObject*)’: 2025-09-08T14:56:08,998 Box2D/Box2D_wrap.cpp:6318:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:08,998 6318 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2025-09-08T14:56:08,998 | ^~ 2025-09-08T14:56:08,999 Box2D/Box2D_wrap.cpp:6318:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:08,999 6318 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2025-09-08T14:56:08,999 | ^~~~~~~~ 2025-09-08T14:56:09,000 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Version___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,000 Box2D/Box2D_wrap.cpp:6325:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,000 6325 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2025-09-08T14:56:09,000 | ^~ 2025-09-08T14:56:09,000 Box2D/Box2D_wrap.cpp:6325:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,001 6325 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Version, 0 | 0 ); 2025-09-08T14:56:09,001 | ^~~~~~~~ 2025-09-08T14:56:09,008 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec2__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,008 Box2D/Box2D_wrap.cpp:6380:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,009 6380 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2025-09-08T14:56:09,009 | ^~ 2025-09-08T14:56:09,009 Box2D/Box2D_wrap.cpp:6380:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,009 6380 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2025-09-08T14:56:09,009 | ^~~~~~ 2025-09-08T14:56:09,012 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_Set(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,013 Box2D/Box2D_wrap.cpp:6398:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,013 6398 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2_Set", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,013 | ^~ 2025-09-08T14:56:09,013 Box2D/Box2D_wrap.cpp:6398:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,013 6398 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2_Set", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,013 | ^ 2025-09-08T14:56:09,016 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___call____SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,017 Box2D/Box2D_wrap.cpp:6418:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,017 6418 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2025-09-08T14:56:09,017 | ^~ 2025-09-08T14:56:09,017 Box2D/Box2D_wrap.cpp:6418:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,017 6418 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2025-09-08T14:56:09,017 | ^ 2025-09-08T14:56:09,020 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___call__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,020 Box2D/Box2D_wrap.cpp:6437:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,020 6437 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2___call__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,020 | ^~ 2025-09-08T14:56:09,020 Box2D/Box2D_wrap.cpp:6437:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,020 6437 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2___call__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,021 | ^~ 2025-09-08T14:56:09,021 Box2D/Box2D_wrap.cpp:6439:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,021 6439 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2025-09-08T14:56:09,021 | ^~ 2025-09-08T14:56:09,021 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,021 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,022 | ^~~~ 2025-09-08T14:56:09,022 Box2D/Box2D_wrap.cpp:6439:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,022 6439 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2025-09-08T14:56:09,022 | ^~~~~~~~~ 2025-09-08T14:56:09,022 Box2D/Box2D_wrap.cpp:6441:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,022 6441 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,022 | ^~ 2025-09-08T14:56:09,023 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,023 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,023 | ^~~~ 2025-09-08T14:56:09,023 Box2D/Box2D_wrap.cpp:6441:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,023 6441 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,023 | ^~~~~~~~~ 2025-09-08T14:56:09,024 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___add_vector(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,024 Box2D/Box2D_wrap.cpp:6447:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,024 6447 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,024 | ^~ 2025-09-08T14:56:09,024 Box2D/Box2D_wrap.cpp:6447:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,025 6447 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,025 | ^ 2025-09-08T14:56:09,027 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___sub_vector(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,027 Box2D/Box2D_wrap.cpp:6464:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,028 6464 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,028 | ^~ 2025-09-08T14:56:09,028 Box2D/Box2D_wrap.cpp:6464:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,028 6464 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,028 | ^ 2025-09-08T14:56:09,031 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___mul_float(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,031 Box2D/Box2D_wrap.cpp:6481:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,031 6481 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,031 | ^~ 2025-09-08T14:56:09,031 Box2D/Box2D_wrap.cpp:6481:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,031 6481 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,031 | ^ 2025-09-08T14:56:09,038 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_x_set(PyObject*, PyObject*)’: 2025-09-08T14:56:09,038 Box2D/Box2D_wrap.cpp:6524:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,038 6524 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_x_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,038 | ^~ 2025-09-08T14:56:09,038 Box2D/Box2D_wrap.cpp:6524:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,039 6524 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_x_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,039 | ^ 2025-09-08T14:56:09,041 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_y_set(PyObject*, PyObject*)’: 2025-09-08T14:56:09,041 Box2D/Box2D_wrap.cpp:6539:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,041 6539 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_y_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,041 | ^~ 2025-09-08T14:56:09,041 Box2D/Box2D_wrap.cpp:6539:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,041 6539 | if (!SWIG_Python_UnpackTuple(args, "b2Vec2_y_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,042 | ^ 2025-09-08T14:56:09,048 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec2(PyObject*, PyObject*)’: 2025-09-08T14:56:09,048 Box2D/Box2D_wrap.cpp:6578:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,048 6578 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec2", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,048 | ^~ 2025-09-08T14:56:09,048 Box2D/Box2D_wrap.cpp:6578:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,048 6578 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec2", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,048 | ^~ 2025-09-08T14:56:09,049 Box2D/Box2D_wrap.cpp:6581:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,049 6581 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2025-09-08T14:56:09,049 | ^~ 2025-09-08T14:56:09,051 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,051 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,051 | ^~~~ 2025-09-08T14:56:09,051 Box2D/Box2D_wrap.cpp:6581:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,051 6581 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2025-09-08T14:56:09,051 | ^~~~~~~~~ 2025-09-08T14:56:09,052 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_cross__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,052 Box2D/Box2D_wrap.cpp:6589:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,052 6589 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2025-09-08T14:56:09,052 | ^~ 2025-09-08T14:56:09,053 Box2D/Box2D_wrap.cpp:6589:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,053 6589 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { int res1 = SWIG_ConvertPtr(swig_obj[0], (void**)&arg1, SWIGTYPE_p_b2Vec2, 0); 2025-09-08T14:56:09,053 | ^ 2025-09-08T14:56:09,058 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_cross(PyObject*, PyObject*)’: 2025-09-08T14:56:09,058 Box2D/Box2D_wrap.cpp:6615:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,058 6615 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2_cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2025-09-08T14:56:09,058 | ^~ 2025-09-08T14:56:09,058 Box2D/Box2D_wrap.cpp:6615:87: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,058 6615 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Vec2_cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2025-09-08T14:56:09,058 | ^~ 2025-09-08T14:56:09,059 Box2D/Box2D_wrap.cpp:6617:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,059 6617 | if (!_v) goto check_1; return _wrap_b2Vec2_cross__SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2025-09-08T14:56:09,059 | ^~ 2025-09-08T14:56:09,060 Box2D/Box2D_wrap.cpp:6617:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,060 6617 | if (!_v) goto check_1; return _wrap_b2Vec2_cross__SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2025-09-08T14:56:09,060 | ^~~~~~ 2025-09-08T14:56:09,062 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___getitem__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,062 Box2D/Box2D_wrap.cpp:6625:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,062 6625 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,062 | ^~ 2025-09-08T14:56:09,062 Box2D/Box2D_wrap.cpp:6625:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,062 6625 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,062 | ^ 2025-09-08T14:56:09,065 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___setitem__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,065 Box2D/Box2D_wrap.cpp:6637:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,065 6637 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,065 | ^~ 2025-09-08T14:56:09,065 Box2D/Box2D_wrap.cpp:6637:118: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,065 6637 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec2___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,065 | ^ 2025-09-08T14:56:09,068 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___equ(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,068 Box2D/Box2D_wrap.cpp:6649:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,068 6649 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,068 | ^~ 2025-09-08T14:56:09,068 Box2D/Box2D_wrap.cpp:6649:104: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,069 6649 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,069 | ^ 2025-09-08T14:56:09,072 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2_dot(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,072 Box2D/Box2D_wrap.cpp:6666:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,072 6666 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2_dot", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,073 | ^~ 2025-09-08T14:56:09,073 Box2D/Box2D_wrap.cpp:6666:102: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,073 6666 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2_dot", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,073 | ^ 2025-09-08T14:56:09,076 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___truediv__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,076 Box2D/Box2D_wrap.cpp:6683:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,076 6683 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,076 | ^~ 2025-09-08T14:56:09,076 Box2D/Box2D_wrap.cpp:6683:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,077 6683 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,077 | ^ 2025-09-08T14:56:09,078 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___div__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,079 Box2D/Box2D_wrap.cpp:6696:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,079 6696 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,079 | ^~ 2025-09-08T14:56:09,079 Box2D/Box2D_wrap.cpp:6696:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,079 6696 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,079 | ^ 2025-09-08T14:56:09,081 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___mul__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,081 Box2D/Box2D_wrap.cpp:6709:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,081 6709 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,082 | ^~ 2025-09-08T14:56:09,082 Box2D/Box2D_wrap.cpp:6709:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,082 6709 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,082 | ^ 2025-09-08T14:56:09,084 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___add__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,084 Box2D/Box2D_wrap.cpp:6722:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,084 6722 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,084 | ^~ 2025-09-08T14:56:09,084 Box2D/Box2D_wrap.cpp:6722:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,085 6722 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,085 | ^ 2025-09-08T14:56:09,088 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___sub__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,088 Box2D/Box2D_wrap.cpp:6741:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,088 6741 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,088 | ^~ 2025-09-08T14:56:09,088 Box2D/Box2D_wrap.cpp:6741:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,089 6741 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,089 | ^ 2025-09-08T14:56:09,092 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___rmul__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,092 Box2D/Box2D_wrap.cpp:6760:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,092 6760 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,092 | ^~ 2025-09-08T14:56:09,092 Box2D/Box2D_wrap.cpp:6760:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,093 6760 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,093 | ^ 2025-09-08T14:56:09,095 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___rdiv__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,095 Box2D/Box2D_wrap.cpp:6773:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,095 6773 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,095 | ^~ 2025-09-08T14:56:09,095 Box2D/Box2D_wrap.cpp:6773:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,096 6773 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,096 | ^ 2025-09-08T14:56:09,098 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec2___div_float(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,098 Box2D/Box2D_wrap.cpp:6786:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,098 6786 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,098 | ^~ 2025-09-08T14:56:09,098 Box2D/Box2D_wrap.cpp:6786:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,098 6786 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec2___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,098 | ^ 2025-09-08T14:56:09,105 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_Set(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,105 Box2D/Box2D_wrap.cpp:6833:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,105 6833 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Vec3_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2025-09-08T14:56:09,105 | ^~ 2025-09-08T14:56:09,105 Box2D/Box2D_wrap.cpp:6833:118: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,105 6833 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Vec3_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2025-09-08T14:56:09,105 | ^ 2025-09-08T14:56:09,110 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___add_vector(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,111 Box2D/Box2D_wrap.cpp:6856:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,111 6856 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,111 | ^~ 2025-09-08T14:56:09,111 Box2D/Box2D_wrap.cpp:6856:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,111 6856 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,111 | ^ 2025-09-08T14:56:09,115 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___sub_vector(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,115 Box2D/Box2D_wrap.cpp:6874:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,115 6874 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,115 | ^~ 2025-09-08T14:56:09,115 Box2D/Box2D_wrap.cpp:6874:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,115 6874 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub_vector", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,115 | ^ 2025-09-08T14:56:09,119 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___mul_float(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,119 Box2D/Box2D_wrap.cpp:6892:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,119 6892 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,119 | ^~ 2025-09-08T14:56:09,120 Box2D/Box2D_wrap.cpp:6892:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,120 6892 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,120 | ^ 2025-09-08T14:56:09,122 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_x_set(PyObject*, PyObject*)’: 2025-09-08T14:56:09,122 Box2D/Box2D_wrap.cpp:6901:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,122 6901 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_x_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,122 | ^~ 2025-09-08T14:56:09,122 Box2D/Box2D_wrap.cpp:6901:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,122 6901 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_x_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,123 | ^ 2025-09-08T14:56:09,125 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_y_set(PyObject*, PyObject*)’: 2025-09-08T14:56:09,125 Box2D/Box2D_wrap.cpp:6916:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,125 6916 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_y_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,125 | ^~ 2025-09-08T14:56:09,126 Box2D/Box2D_wrap.cpp:6916:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,126 6916 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_y_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,126 | ^ 2025-09-08T14:56:09,128 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_z_set(PyObject*, PyObject*)’: 2025-09-08T14:56:09,129 Box2D/Box2D_wrap.cpp:6931:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,129 6931 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_z_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,129 | ^~ 2025-09-08T14:56:09,129 Box2D/Box2D_wrap.cpp:6931:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,129 6931 | if (!SWIG_Python_UnpackTuple(args, "b2Vec3_z_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,129 | ^ 2025-09-08T14:56:09,138 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Vec3(PyObject*, PyObject*)’: 2025-09-08T14:56:09,138 Box2D/Box2D_wrap.cpp:6985:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,138 6985 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec3", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,138 | ^~ 2025-09-08T14:56:09,138 Box2D/Box2D_wrap.cpp:6985:85: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,139 6985 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Vec3", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,139 | ^~ 2025-09-08T14:56:09,139 Box2D/Box2D_wrap.cpp:6992:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,140 6992 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,140 | ^~ 2025-09-08T14:56:09,141 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,141 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,141 | ^~~~ 2025-09-08T14:56:09,141 Box2D/Box2D_wrap.cpp:6992:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,141 6992 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,141 | ^~~~~~~~~ 2025-09-08T14:56:09,142 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3_cross(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,142 Box2D/Box2D_wrap.cpp:6999:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,142 6999 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3_cross", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,142 | ^~ 2025-09-08T14:56:09,142 Box2D/Box2D_wrap.cpp:6999:104: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,143 6999 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3_cross", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,143 | ^ 2025-09-08T14:56:09,146 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___getitem__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,146 Box2D/Box2D_wrap.cpp:7018:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,146 7018 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,146 | ^~ 2025-09-08T14:56:09,147 Box2D/Box2D_wrap.cpp:7018:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,147 7018 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,147 | ^ 2025-09-08T14:56:09,148 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___setitem__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,149 Box2D/Box2D_wrap.cpp:7030:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,149 7030 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec3___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,149 | ^~ 2025-09-08T14:56:09,149 Box2D/Box2D_wrap.cpp:7030:118: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,149 7030 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Vec3___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,149 | ^ 2025-09-08T14:56:09,154 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___truediv__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,154 Box2D/Box2D_wrap.cpp:7061:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,154 7061 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,154 | ^~ 2025-09-08T14:56:09,154 Box2D/Box2D_wrap.cpp:7061:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,154 7061 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,155 | ^ 2025-09-08T14:56:09,157 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___div__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,157 Box2D/Box2D_wrap.cpp:7074:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,157 7074 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,157 | ^~ 2025-09-08T14:56:09,157 Box2D/Box2D_wrap.cpp:7074:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,158 7074 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,158 | ^ 2025-09-08T14:56:09,160 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___mul__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,160 Box2D/Box2D_wrap.cpp:7087:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,160 7087 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,160 | ^~ 2025-09-08T14:56:09,161 Box2D/Box2D_wrap.cpp:7087:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,161 7087 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,161 | ^ 2025-09-08T14:56:09,163 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___add__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,164 Box2D/Box2D_wrap.cpp:7100:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,164 7100 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,164 | ^~ 2025-09-08T14:56:09,164 Box2D/Box2D_wrap.cpp:7100:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,164 7100 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,164 | ^ 2025-09-08T14:56:09,168 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___sub__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,168 Box2D/Box2D_wrap.cpp:7120:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,168 7120 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,169 | ^~ 2025-09-08T14:56:09,169 Box2D/Box2D_wrap.cpp:7120:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,169 7120 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,169 | ^ 2025-09-08T14:56:09,173 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___rmul__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,173 Box2D/Box2D_wrap.cpp:7140:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,173 7140 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,173 | ^~ 2025-09-08T14:56:09,174 Box2D/Box2D_wrap.cpp:7140:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,174 7140 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,174 | ^ 2025-09-08T14:56:09,176 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___rdiv__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,177 Box2D/Box2D_wrap.cpp:7153:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,177 7153 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,177 | ^~ 2025-09-08T14:56:09,177 Box2D/Box2D_wrap.cpp:7153:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,177 7153 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___rdiv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,177 | ^ 2025-09-08T14:56:09,180 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Vec3___div_float(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,180 Box2D/Box2D_wrap.cpp:7166:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,180 7166 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,180 | ^~ 2025-09-08T14:56:09,180 Box2D/Box2D_wrap.cpp:7166:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,181 7166 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Vec3___div_float", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,181 | ^ 2025-09-08T14:56:09,184 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat22__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,184 Box2D/Box2D_wrap.cpp:7192:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,185 7192 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2025-09-08T14:56:09,185 | ^~ 2025-09-08T14:56:09,185 Box2D/Box2D_wrap.cpp:7192:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,185 7192 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2025-09-08T14:56:09,185 | ^ 2025-09-08T14:56:09,190 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat22__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,190 Box2D/Box2D_wrap.cpp:7217:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,190 7217 | if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2025-09-08T14:56:09,190 | ^~ 2025-09-08T14:56:09,190 Box2D/Box2D_wrap.cpp:7217:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,190 7217 | if ((nobjs < 4) || (nobjs > 4)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2025-09-08T14:56:09,190 | ^~~~~~ 2025-09-08T14:56:09,206 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22_col1_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,207 Box2D/Box2D_wrap.cpp:7310:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,207 7310 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2025-09-08T14:56:09,207 | ^~ 2025-09-08T14:56:09,207 Box2D/Box2D_wrap.cpp:7310:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,207 7310 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2025-09-08T14:56:09,207 | ^~~~~~~~ 2025-09-08T14:56:09,211 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22_col2_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,211 Box2D/Box2D_wrap.cpp:7332:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,211 7332 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2025-09-08T14:56:09,211 | ^~ 2025-09-08T14:56:09,211 Box2D/Box2D_wrap.cpp:7332:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,211 7332 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2025-09-08T14:56:09,212 | ^~~~~~~~ 2025-09-08T14:56:09,213 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,213 Box2D/Box2D_wrap.cpp:7339:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,213 7339 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2025-09-08T14:56:09,213 | ^~ 2025-09-08T14:56:09,213 Box2D/Box2D_wrap.cpp:7339:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,213 7339 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2025-09-08T14:56:09,213 | ^~~~~~~~ 2025-09-08T14:56:09,215 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat22(PyObject*, PyObject*)’: 2025-09-08T14:56:09,216 Box2D/Box2D_wrap.cpp:7351:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,216 7351 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat22", 0, 4, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,216 | ^~ 2025-09-08T14:56:09,216 Box2D/Box2D_wrap.cpp:7351:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,216 7351 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat22", 0, 4, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,216 | ^~ 2025-09-08T14:56:09,217 Box2D/Box2D_wrap.cpp:7354:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,217 7354 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2025-09-08T14:56:09,217 | ^~ 2025-09-08T14:56:09,218 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,218 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,218 | ^~~~ 2025-09-08T14:56:09,219 Box2D/Box2D_wrap.cpp:7354:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,219 7354 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2025-09-08T14:56:09,219 | ^~~~~~~~~ 2025-09-08T14:56:09,220 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___GetAngle(PyObject*, PyObject*)’: 2025-09-08T14:56:09,220 Box2D/Box2D_wrap.cpp:7362:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,220 7362 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2025-09-08T14:56:09,220 | ^~ 2025-09-08T14:56:09,220 Box2D/Box2D_wrap.cpp:7362:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,220 7362 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat22, 0 | 0 ); 2025-09-08T14:56:09,220 | ^~~~~~~~ 2025-09-08T14:56:09,223 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___SetAngle(PyObject*, PyObject*)’: 2025-09-08T14:56:09,223 Box2D/Box2D_wrap.cpp:7378:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,223 7378 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___SetAngle", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,224 | ^~ 2025-09-08T14:56:09,224 Box2D/Box2D_wrap.cpp:7378:93: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,224 7378 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___SetAngle", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,224 | ^~ 2025-09-08T14:56:09,224 Box2D/Box2D_wrap.cpp:7380:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,224 7380 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:09,225 | ^~ 2025-09-08T14:56:09,226 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,226 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,226 | ^~~~ 2025-09-08T14:56:09,226 Box2D/Box2D_wrap.cpp:7380:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,226 7380 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:09,226 | ^~~~~~~~~ 2025-09-08T14:56:09,227 Box2D/Box2D_wrap.cpp:7382:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,227 7382 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,227 | ^~ 2025-09-08T14:56:09,228 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,228 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,228 | ^~~~ 2025-09-08T14:56:09,229 Box2D/Box2D_wrap.cpp:7382:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,229 7382 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,229 | ^~~~~~~~~ 2025-09-08T14:56:09,235 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat22___mul__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,235 Box2D/Box2D_wrap.cpp:7418:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,235 7418 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___mul__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2025-09-08T14:56:09,235 | ^~ 2025-09-08T14:56:09,236 Box2D/Box2D_wrap.cpp:7418:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,236 7418 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mat22___mul__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2025-09-08T14:56:09,236 | ^~ 2025-09-08T14:56:09,237 Box2D/Box2D_wrap.cpp:7420:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,237 7420 | if (!_v) goto check_1; return _wrap_b2Mat22___mul____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2025-09-08T14:56:09,237 | ^~ 2025-09-08T14:56:09,237 Box2D/Box2D_wrap.cpp:7420:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,237 7420 | if (!_v) goto check_1; return _wrap_b2Mat22___mul____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2025-09-08T14:56:09,237 | ^~~~~~ 2025-09-08T14:56:09,238 Box2D/Box2D_wrap.cpp:7422:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,238 7422 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: SWIG_Py_INCREF(Py_NotImplemented); 2025-09-08T14:56:09,238 | ^~ 2025-09-08T14:56:09,240 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,240 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,240 | ^~~~ 2025-09-08T14:56:09,240 Box2D/Box2D_wrap.cpp:7422:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,240 7422 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: SWIG_Py_INCREF(Py_NotImplemented); 2025-09-08T14:56:09,240 | ^~~~~~~~~ 2025-09-08T14:56:09,271 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col1_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,272 Box2D/Box2D_wrap.cpp:7617:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,272 7617 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2025-09-08T14:56:09,272 | ^~ 2025-09-08T14:56:09,272 Box2D/Box2D_wrap.cpp:7617:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,272 7617 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2025-09-08T14:56:09,272 | ^~~~~~~~ 2025-09-08T14:56:09,276 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col2_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,276 Box2D/Box2D_wrap.cpp:7640:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,277 7640 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2025-09-08T14:56:09,277 | ^~ 2025-09-08T14:56:09,277 Box2D/Box2D_wrap.cpp:7640:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,277 7640 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2025-09-08T14:56:09,277 | ^~~~~~~~ 2025-09-08T14:56:09,281 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33_col3_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,282 Box2D/Box2D_wrap.cpp:7663:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,282 7663 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2025-09-08T14:56:09,282 | ^~ 2025-09-08T14:56:09,282 Box2D/Box2D_wrap.cpp:7663:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,282 7663 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2025-09-08T14:56:09,282 | ^~~~~~~~ 2025-09-08T14:56:09,283 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mat33___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,284 Box2D/Box2D_wrap.cpp:7670:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,284 7670 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2025-09-08T14:56:09,284 | ^~ 2025-09-08T14:56:09,284 Box2D/Box2D_wrap.cpp:7670:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,284 7670 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Mat33, 0 | 0 ); 2025-09-08T14:56:09,284 | ^~~~~~~~ 2025-09-08T14:56:09,286 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Mat33(PyObject*, PyObject*)’: 2025-09-08T14:56:09,287 Box2D/Box2D_wrap.cpp:7682:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,287 7682 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat33", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,287 | ^~ 2025-09-08T14:56:09,287 Box2D/Box2D_wrap.cpp:7682:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,287 7682 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Mat33", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,287 | ^~ 2025-09-08T14:56:09,288 Box2D/Box2D_wrap.cpp:7685:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,288 7685 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,288 | ^~ 2025-09-08T14:56:09,290 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,290 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,290 | ^~~~ 2025-09-08T14:56:09,290 Box2D/Box2D_wrap.cpp:7685:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,290 7685 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,290 | ^~~~~~~~~ 2025-09-08T14:56:09,307 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Rot(PyObject*, PyObject*)’: 2025-09-08T14:56:09,307 Box2D/Box2D_wrap.cpp:7793:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,307 7793 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Rot", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,307 | ^~ 2025-09-08T14:56:09,307 Box2D/Box2D_wrap.cpp:7793:84: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,307 7793 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Rot", 0, 1, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,307 | ^~ 2025-09-08T14:56:09,307 Box2D/Box2D_wrap.cpp:7796:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,307 7796 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,308 | ^~ 2025-09-08T14:56:09,309 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,309 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,309 | ^~~~ 2025-09-08T14:56:09,309 Box2D/Box2D_wrap.cpp:7796:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,309 7796 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,309 | ^~~~~~~~~ 2025-09-08T14:56:09,312 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Rot___GetAngle(PyObject*, PyObject*)’: 2025-09-08T14:56:09,312 Box2D/Box2D_wrap.cpp:7817:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,313 7817 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Rot, 0 | 0 ); 2025-09-08T14:56:09,313 | ^~ 2025-09-08T14:56:09,313 Box2D/Box2D_wrap.cpp:7817:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,313 7817 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Rot, 0 | 0 ); 2025-09-08T14:56:09,313 | ^~~~~~~~ 2025-09-08T14:56:09,344 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Transform(PyObject*, PyObject*)’: 2025-09-08T14:56:09,344 Box2D/Box2D_wrap.cpp:7932:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,344 7932 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Transform", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,344 | ^~ 2025-09-08T14:56:09,345 Box2D/Box2D_wrap.cpp:7932:90: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,345 7932 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Transform", 0, 2, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,345 | ^~ 2025-09-08T14:56:09,345 Box2D/Box2D_wrap.cpp:7934:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,345 7934 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2025-09-08T14:56:09,345 | ^~ 2025-09-08T14:56:09,347 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,347 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,347 | ^~~~ 2025-09-08T14:56:09,347 Box2D/Box2D_wrap.cpp:7934:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,347 7934 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 2) { 2025-09-08T14:56:09,347 | ^~~~~~~~~ 2025-09-08T14:56:09,348 Box2D/Box2D_wrap.cpp:7936:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,348 7936 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,348 | ^~ 2025-09-08T14:56:09,349 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,350 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,350 | ^~~~ 2025-09-08T14:56:09,350 Box2D/Box2D_wrap.cpp:7936:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,350 7936 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,350 | ^~~~~~~~~ 2025-09-08T14:56:09,351 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform_SetIdentity(PyObject*, PyObject*)’: 2025-09-08T14:56:09,351 Box2D/Box2D_wrap.cpp:7942:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,351 7942 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2025-09-08T14:56:09,351 | ^~ 2025-09-08T14:56:09,351 Box2D/Box2D_wrap.cpp:7942:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,351 7942 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2025-09-08T14:56:09,351 | ^~~~~~~~ 2025-09-08T14:56:09,362 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,362 Box2D/Box2D_wrap.cpp:8009:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,362 8009 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2025-09-08T14:56:09,362 | ^~ 2025-09-08T14:56:09,362 Box2D/Box2D_wrap.cpp:8009:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,362 8009 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2025-09-08T14:56:09,362 | ^~~~~~~~ 2025-09-08T14:56:09,363 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Transform___get_rotation_matrix(PyObject*, PyObject*)’: 2025-09-08T14:56:09,363 Box2D/Box2D_wrap.cpp:8017:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,363 8017 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2025-09-08T14:56:09,363 | ^~ 2025-09-08T14:56:09,363 Box2D/Box2D_wrap.cpp:8017:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,364 8017 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Transform, 0 | 0 ); 2025-09-08T14:56:09,364 | ^~~~~~~~ 2025-09-08T14:56:09,368 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2Transform(PyObject*, PyObject*)’: 2025-09-08T14:56:09,368 Box2D/Box2D_wrap.cpp:8046:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,368 8046 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,368 | ^~ 2025-09-08T14:56:09,369 Box2D/Box2D_wrap.cpp:8046:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,369 8046 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,369 | ^~~~~~~~ 2025-09-08T14:56:09,370 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_GetTransform__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,370 Box2D/Box2D_wrap.cpp:8065:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,370 8065 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,371 | ^~ 2025-09-08T14:56:09,371 Box2D/Box2D_wrap.cpp:8065:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,371 8065 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,371 | ^~~~ 2025-09-08T14:56:09,378 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_localCenter_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,378 Box2D/Box2D_wrap.cpp:8109:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,378 8109 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,378 | ^~ 2025-09-08T14:56:09,378 Box2D/Box2D_wrap.cpp:8109:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,378 8109 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,378 | ^~~~~~~~ 2025-09-08T14:56:09,382 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_c0_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,382 Box2D/Box2D_wrap.cpp:8131:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,382 8131 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,382 | ^~ 2025-09-08T14:56:09,383 Box2D/Box2D_wrap.cpp:8131:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,383 8131 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,383 | ^~~~~~~~ 2025-09-08T14:56:09,386 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_c_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,387 Box2D/Box2D_wrap.cpp:8153:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,387 8153 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,387 | ^~ 2025-09-08T14:56:09,387 Box2D/Box2D_wrap.cpp:8153:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,387 8153 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,387 | ^~~~~~~~ 2025-09-08T14:56:09,390 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_a0_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,390 Box2D/Box2D_wrap.cpp:8169:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,390 8169 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,390 | ^~ 2025-09-08T14:56:09,390 Box2D/Box2D_wrap.cpp:8169:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,390 8169 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,390 | ^~~~~~~~ 2025-09-08T14:56:09,393 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_a_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,393 Box2D/Box2D_wrap.cpp:8185:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,393 8185 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,393 | ^~ 2025-09-08T14:56:09,393 Box2D/Box2D_wrap.cpp:8185:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,394 8185 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,394 | ^~~~~~~~ 2025-09-08T14:56:09,396 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_alpha0_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,396 Box2D/Box2D_wrap.cpp:8201:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,396 8201 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,397 | ^~ 2025-09-08T14:56:09,397 Box2D/Box2D_wrap.cpp:8201:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,397 8201 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,397 | ^~~~~~~~ 2025-09-08T14:56:09,398 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,398 Box2D/Box2D_wrap.cpp:8208:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,399 8208 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,399 | ^~ 2025-09-08T14:56:09,399 Box2D/Box2D_wrap.cpp:8208:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,399 8208 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Sweep, 0 | 0 ); 2025-09-08T14:56:09,399 | ^~~~~~~~ 2025-09-08T14:56:09,402 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Sweep_GetTransform(PyObject*, PyObject*)’: 2025-09-08T14:56:09,402 Box2D/Box2D_wrap.cpp:8226:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,402 8226 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Sweep_GetTransform", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,402 | ^~ 2025-09-08T14:56:09,403 Box2D/Box2D_wrap.cpp:8226:95: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,403 8226 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Sweep_GetTransform", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,403 | ^~ 2025-09-08T14:56:09,403 Box2D/Box2D_wrap.cpp:8228:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,404 8228 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:09,404 | ^~ 2025-09-08T14:56:09,405 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,405 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,406 | ^~~~ 2025-09-08T14:56:09,406 Box2D/Box2D_wrap.cpp:8228:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,406 8228 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:09,406 | ^~~~~~~~~ 2025-09-08T14:56:09,406 Box2D/Box2D_wrap.cpp:8230:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,406 8230 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,406 | ^~ 2025-09-08T14:56:09,408 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,408 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,408 | ^~~~ 2025-09-08T14:56:09,408 Box2D/Box2D_wrap.cpp:8230:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,408 8230 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,408 | ^~~~~~~~~ 2025-09-08T14:56:09,412 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Dot__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,412 Box2D/Box2D_wrap.cpp:8263:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,413 8263 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2025-09-08T14:56:09,413 | ^~ 2025-09-08T14:56:09,413 Box2D/Box2D_wrap.cpp:8263:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,413 8263 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2025-09-08T14:56:09,413 | ^ 2025-09-08T14:56:09,417 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,417 Box2D/Box2D_wrap.cpp:8286:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,417 8286 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2025-09-08T14:56:09,417 | ^~ 2025-09-08T14:56:09,418 Box2D/Box2D_wrap.cpp:8286:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,418 8286 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2025-09-08T14:56:09,418 | ^ 2025-09-08T14:56:09,421 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,422 Box2D/Box2D_wrap.cpp:8309:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,422 8309 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2025-09-08T14:56:09,422 | ^~ 2025-09-08T14:56:09,422 Box2D/Box2D_wrap.cpp:8309:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,422 8309 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 2) { 2025-09-08T14:56:09,422 | ^ 2025-09-08T14:56:09,425 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_2(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,425 Box2D/Box2D_wrap.cpp:8325:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,425 8325 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2025-09-08T14:56:09,425 | ^~ 2025-09-08T14:56:09,425 Box2D/Box2D_wrap.cpp:8325:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,426 8325 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; ecode1 = SWIG_AsVal_float(swig_obj[0], &val1); if (!SWIG_IsOK(ecode1)) { 2025-09-08T14:56:09,426 | ^~~~~~ 2025-09-08T14:56:09,435 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DistanceSquared(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,435 Box2D/Box2D_wrap.cpp:8380:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,436 8380 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2DistanceSquared", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,436 | ^~ 2025-09-08T14:56:09,436 Box2D/Box2D_wrap.cpp:8380:109: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,436 8380 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2DistanceSquared", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,436 | ^ 2025-09-08T14:56:09,440 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Dot__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,440 Box2D/Box2D_wrap.cpp:8403:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,440 8403 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2025-09-08T14:56:09,440 | ^~ 2025-09-08T14:56:09,440 Box2D/Box2D_wrap.cpp:8403:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,440 8403 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2025-09-08T14:56:09,440 | ^ 2025-09-08T14:56:09,445 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Dot(PyObject*, PyObject*)’: 2025-09-08T14:56:09,445 Box2D/Box2D_wrap.cpp:8427:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,445 8427 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Dot", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2025-09-08T14:56:09,446 | ^~ 2025-09-08T14:56:09,446 Box2D/Box2D_wrap.cpp:8427:80: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,446 8427 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Dot", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2025-09-08T14:56:09,446 | ^~ 2025-09-08T14:56:09,446 Box2D/Box2D_wrap.cpp:8429:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,447 8429 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,447 | ^~ 2025-09-08T14:56:09,447 Box2D/Box2D_wrap.cpp:8429:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,447 8429 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,447 | ^ 2025-09-08T14:56:09,449 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross__SWIG_3(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,449 Box2D/Box2D_wrap.cpp:8438:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,449 8438 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2025-09-08T14:56:09,449 | ^~ 2025-09-08T14:56:09,449 Box2D/Box2D_wrap.cpp:8438:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,449 8438 | if ((nobjs < 2) || (nobjs > 2)) SWIG_fail; { if (PySequence_Check(swig_obj[0])) { if (PySequence_Size(swig_obj[0]) != 3) { 2025-09-08T14:56:09,450 | ^ 2025-09-08T14:56:09,455 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Cross(PyObject*, PyObject*)’: 2025-09-08T14:56:09,455 Box2D/Box2D_wrap.cpp:8463:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,455 8463 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2025-09-08T14:56:09,455 | ^~ 2025-09-08T14:56:09,455 Box2D/Box2D_wrap.cpp:8463:82: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,455 8463 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Cross", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { { 2025-09-08T14:56:09,455 | ^~ 2025-09-08T14:56:09,456 Box2D/Box2D_wrap.cpp:8465:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,456 8465 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,456 | ^~ 2025-09-08T14:56:09,457 Box2D/Box2D_wrap.cpp:8465:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,457 8465 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,457 | ^ 2025-09-08T14:56:09,458 Box2D/Box2D_wrap.cpp:8469:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,458 8469 | if (!_v) goto check_2; { { int res = SWIG_AsVal_float(argv[1], NULL); _v = SWIG_CheckState(res); } } if (!_v) goto check_2; 2025-09-08T14:56:09,458 | ^~ 2025-09-08T14:56:09,459 Box2D/Box2D_wrap.cpp:8469:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,459 8469 | if (!_v) goto check_2; { { int res = SWIG_AsVal_float(argv[1], NULL); _v = SWIG_CheckState(res); } } if (!_v) goto check_2; 2025-09-08T14:56:09,459 | ^ 2025-09-08T14:56:09,460 Box2D/Box2D_wrap.cpp:8472:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,460 8472 | if (!_v) goto check_3; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,460 | ^~ 2025-09-08T14:56:09,460 Box2D/Box2D_wrap.cpp:8472:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,460 8472 | if (!_v) goto check_3; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,461 | ^ 2025-09-08T14:56:09,493 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Mul(PyObject*, PyObject*)’: 2025-09-08T14:56:09,493 Box2D/Box2D_wrap.cpp:8681:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,493 8681 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mul", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2025-09-08T14:56:09,494 | ^~ 2025-09-08T14:56:09,494 Box2D/Box2D_wrap.cpp:8681:80: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,494 8681 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Mul", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2025-09-08T14:56:09,494 | ^~ 2025-09-08T14:56:09,494 Box2D/Box2D_wrap.cpp:8683:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,494 8683 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,494 | ^~ 2025-09-08T14:56:09,495 Box2D/Box2D_wrap.cpp:8683:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,495 8683 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,495 | ^ 2025-09-08T14:56:09,496 Box2D/Box2D_wrap.cpp:8687:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,496 8687 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2025-09-08T14:56:09,496 | ^~ 2025-09-08T14:56:09,496 Box2D/Box2D_wrap.cpp:8687:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,496 8687 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2025-09-08T14:56:09,496 | ^ 2025-09-08T14:56:09,498 Box2D/Box2D_wrap.cpp:8694:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,498 8694 | if (!_v) goto check_4; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Rot, SWIG_POINTER_NO_NULL | 0); 2025-09-08T14:56:09,498 | ^~ 2025-09-08T14:56:09,498 Box2D/Box2D_wrap.cpp:8694:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,498 8694 | if (!_v) goto check_4; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Rot, SWIG_POINTER_NO_NULL | 0); 2025-09-08T14:56:09,498 | ^ 2025-09-08T14:56:09,500 Box2D/Box2D_wrap.cpp:8701:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,500 8701 | if (!_v) goto check_6; return _wrap_b2Mul__SWIG_5(self, argc, argv);} check_6: if (argc == 2) { 2025-09-08T14:56:09,500 | ^~ 2025-09-08T14:56:09,500 Box2D/Box2D_wrap.cpp:8701:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,500 8701 | if (!_v) goto check_6; return _wrap_b2Mul__SWIG_5(self, argc, argv);} check_6: if (argc == 2) { 2025-09-08T14:56:09,500 | ^~~~~~ 2025-09-08T14:56:09,504 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MulT(PyObject*, PyObject*)’: 2025-09-08T14:56:09,505 Box2D/Box2D_wrap.cpp:8726:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,505 8726 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2MulT", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2025-09-08T14:56:09,505 | ^~ 2025-09-08T14:56:09,505 Box2D/Box2D_wrap.cpp:8726:81: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,505 8726 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2MulT", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { int _v = 0; { 2025-09-08T14:56:09,505 | ^~ 2025-09-08T14:56:09,506 Box2D/Box2D_wrap.cpp:8728:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,506 8728 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,506 | ^~ 2025-09-08T14:56:09,506 Box2D/Box2D_wrap.cpp:8728:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,506 8728 | if (!_v) goto check_1; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,506 | ^ 2025-09-08T14:56:09,507 Box2D/Box2D_wrap.cpp:8732:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,508 8732 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2025-09-08T14:56:09,508 | ^~ 2025-09-08T14:56:09,508 Box2D/Box2D_wrap.cpp:8732:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,508 8732 | if (!_v) goto check_2; { int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_b2Mat22, SWIG_POINTER_NO_NULL | 0); 2025-09-08T14:56:09,508 | ^ 2025-09-08T14:56:09,509 Box2D/Box2D_wrap.cpp:8737:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,509 8737 | if (!_v) goto check_3; return _wrap_b2MulT__SWIG_2(self, argc, argv);} check_3: if (argc == 2) { int _v = 0; { 2025-09-08T14:56:09,509 | ^~ 2025-09-08T14:56:09,510 Box2D/Box2D_wrap.cpp:8737:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,510 8737 | if (!_v) goto check_3; return _wrap_b2MulT__SWIG_2(self, argc, argv);} check_3: if (argc == 2) { int _v = 0; { 2025-09-08T14:56:09,510 | ^~~~~~ 2025-09-08T14:56:09,511 Box2D/Box2D_wrap.cpp:8739:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,511 8739 | if (!_v) goto check_4; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,511 | ^~ 2025-09-08T14:56:09,511 Box2D/Box2D_wrap.cpp:8739:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,511 8739 | if (!_v) goto check_4; { { _v = (PySequence_Check(argv[1]) || 2025-09-08T14:56:09,511 | ^ 2025-09-08T14:56:09,512 Box2D/Box2D_wrap.cpp:8743:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,513 8743 | if (!_v) goto check_5; return _wrap_b2MulT__SWIG_4(self, argc, argv);} check_5: if (argc == 2) { 2025-09-08T14:56:09,513 | ^~ 2025-09-08T14:56:09,513 Box2D/Box2D_wrap.cpp:8743:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,513 8743 | if (!_v) goto check_5; return _wrap_b2MulT__SWIG_4(self, argc, argv);} check_5: if (argc == 2) { 2025-09-08T14:56:09,513 | ^~~~~~ 2025-09-08T14:56:09,518 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Abs__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:09,518 Box2D/Box2D_wrap.cpp:8767:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,518 8767 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2025-09-08T14:56:09,518 | ^~ 2025-09-08T14:56:09,518 Box2D/Box2D_wrap.cpp:8767:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,518 8767 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1, SWIGTYPE_p_b2Mat22, 0 | 0); 2025-09-08T14:56:09,519 | ^~~~ 2025-09-08T14:56:09,521 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Abs(PyObject*, PyObject*)’: 2025-09-08T14:56:09,521 Box2D/Box2D_wrap.cpp:8777:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,521 8777 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Abs", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { int _v = 0; { { 2025-09-08T14:56:09,521 | ^~ 2025-09-08T14:56:09,521 Box2D/Box2D_wrap.cpp:8777:80: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,521 8777 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Abs", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { int _v = 0; { { 2025-09-08T14:56:09,522 | ^~ 2025-09-08T14:56:09,522 Box2D/Box2D_wrap.cpp:8779:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,523 8779 | if (!_v) goto check_1; return _wrap_b2Abs__SWIG_0(self, argc, argv);} check_1: if (argc == 1) { 2025-09-08T14:56:09,523 | ^~ 2025-09-08T14:56:09,523 Box2D/Box2D_wrap.cpp:8779:28: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,523 8779 | if (!_v) goto check_1; return _wrap_b2Abs__SWIG_0(self, argc, argv);} check_1: if (argc == 1) { 2025-09-08T14:56:09,523 | ^~~~~~ 2025-09-08T14:56:09,525 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Min(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,525 Box2D/Box2D_wrap.cpp:8786:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,525 8786 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Min", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2025-09-08T14:56:09,525 | ^~ 2025-09-08T14:56:09,526 Box2D/Box2D_wrap.cpp:8786:97: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,526 8786 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Min", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2025-09-08T14:56:09,526 | ^ 2025-09-08T14:56:09,530 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Max(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,530 Box2D/Box2D_wrap.cpp:8810:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,530 8810 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Max", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2025-09-08T14:56:09,531 | ^~ 2025-09-08T14:56:09,531 Box2D/Box2D_wrap.cpp:8810:97: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,531 8810 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Max", kwnames, &obj0, &obj1)) SWIG_fail; { if (PySequence_Check(obj0)) { 2025-09-08T14:56:09,531 | ^ 2025-09-08T14:56:09,535 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Clamp(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,535 Box2D/Box2D_wrap.cpp:8835:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,535 8835 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Clamp", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,535 | ^~ 2025-09-08T14:56:09,535 Box2D/Box2D_wrap.cpp:8835:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,535 8835 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Clamp", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,536 | ^ 2025-09-08T14:56:09,553 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactFeature(PyObject*, PyObject*)’: 2025-09-08T14:56:09,553 Box2D/Box2D_wrap.cpp:8973:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,554 8973 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,554 | ^~ 2025-09-08T14:56:09,554 Box2D/Box2D_wrap.cpp:8973:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,554 8973 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,554 | ^~~~~~~~ 2025-09-08T14:56:09,560 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactID_key_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,560 Box2D/Box2D_wrap.cpp:9020:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,560 9020 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2025-09-08T14:56:09,560 | ^~ 2025-09-08T14:56:09,560 Box2D/Box2D_wrap.cpp:9020:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,560 9020 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2025-09-08T14:56:09,560 | ^~~~~~~~ 2025-09-08T14:56:09,562 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactID___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,562 Box2D/Box2D_wrap.cpp:9027:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,562 9027 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2025-09-08T14:56:09,562 | ^~ 2025-09-08T14:56:09,562 Box2D/Box2D_wrap.cpp:9027:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,562 9027 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactID, 0 | 0 ); 2025-09-08T14:56:09,562 | ^~~~~~~~ 2025-09-08T14:56:09,565 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactID(PyObject*, PyObject*)’: 2025-09-08T14:56:09,565 Box2D/Box2D_wrap.cpp:9040:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,565 9040 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,565 | ^~ 2025-09-08T14:56:09,565 Box2D/Box2D_wrap.cpp:9040:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,565 9040 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,566 | ^~~~~~~~ 2025-09-08T14:56:09,579 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ManifoldPoint(PyObject*, PyObject*)’: 2025-09-08T14:56:09,579 Box2D/Box2D_wrap.cpp:9149:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,579 9149 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,580 | ^~ 2025-09-08T14:56:09,580 Box2D/Box2D_wrap.cpp:9149:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,580 9149 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,580 | ^~~~~~~~ 2025-09-08T14:56:09,592 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold_pointCount_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,592 Box2D/Box2D_wrap.cpp:9241:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,592 9241 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2025-09-08T14:56:09,592 | ^~ 2025-09-08T14:56:09,592 Box2D/Box2D_wrap.cpp:9241:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,592 9241 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2025-09-08T14:56:09,593 | ^~~~~~~~ 2025-09-08T14:56:09,594 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Manifold___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,594 Box2D/Box2D_wrap.cpp:9248:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,594 9248 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2025-09-08T14:56:09,594 | ^~ 2025-09-08T14:56:09,594 Box2D/Box2D_wrap.cpp:9248:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,594 9248 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Manifold, 0 | 0 ); 2025-09-08T14:56:09,594 | ^~~~~~~~ 2025-09-08T14:56:09,598 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2Manifold(PyObject*, PyObject*)’: 2025-09-08T14:56:09,599 Box2D/Box2D_wrap.cpp:9274:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,599 9274 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,599 | ^~ 2025-09-08T14:56:09,599 Box2D/Box2D_wrap.cpp:9274:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,599 9274 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,599 | ^~~~~~~~ 2025-09-08T14:56:09,611 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2WorldManifold(PyObject*, PyObject*)’: 2025-09-08T14:56:09,612 Box2D/Box2D_wrap.cpp:9370:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,612 9370 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,612 | ^~ 2025-09-08T14:56:09,612 Box2D/Box2D_wrap.cpp:9370:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,612 9370 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,612 | ^~~~~~~~ 2025-09-08T14:56:09,619 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ClipVertex___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,619 Box2D/Box2D_wrap.cpp:9430:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,619 9430 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2025-09-08T14:56:09,620 | ^~ 2025-09-08T14:56:09,620 Box2D/Box2D_wrap.cpp:9430:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,620 9430 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ClipVertex, 0 | 0 ); 2025-09-08T14:56:09,620 | ^~~~~~~~ 2025-09-08T14:56:09,622 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ClipVertex(PyObject*, PyObject*)’: 2025-09-08T14:56:09,622 Box2D/Box2D_wrap.cpp:9443:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,622 9443 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,622 | ^~ 2025-09-08T14:56:09,623 Box2D/Box2D_wrap.cpp:9443:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,623 9443 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,623 | ^~~~~~~~ 2025-09-08T14:56:09,636 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RayCastInput(PyObject*, PyObject*)’: 2025-09-08T14:56:09,636 Box2D/Box2D_wrap.cpp:9538:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,636 9538 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,636 | ^~ 2025-09-08T14:56:09,636 Box2D/Box2D_wrap.cpp:9538:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,636 9538 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,636 | ^~~~~~~~ 2025-09-08T14:56:09,646 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RayCastOutput(PyObject*, PyObject*)’: 2025-09-08T14:56:09,646 Box2D/Box2D_wrap.cpp:9611:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,646 9611 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,646 | ^~ 2025-09-08T14:56:09,646 Box2D/Box2D_wrap.cpp:9611:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,646 9611 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,647 | ^~~~~~~~ 2025-09-08T14:56:09,648 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___IsValid(PyObject*, PyObject*)’: 2025-09-08T14:56:09,648 Box2D/Box2D_wrap.cpp:9629:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,648 9629 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,648 | ^~ 2025-09-08T14:56:09,648 Box2D/Box2D_wrap.cpp:9629:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,648 9629 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,648 | ^~~~~~~~ 2025-09-08T14:56:09,652 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___GetPerimeter(PyObject*, PyObject*)’: 2025-09-08T14:56:09,652 Box2D/Box2D_wrap.cpp:9655:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,652 9655 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,652 | ^~ 2025-09-08T14:56:09,653 Box2D/Box2D_wrap.cpp:9655:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,653 9655 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,653 | ^~~~~~~~ 2025-09-08T14:56:09,657 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_Combine(PyObject*, PyObject*)’: 2025-09-08T14:56:09,658 Box2D/Box2D_wrap.cpp:9692:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,658 9692 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB_Combine", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,658 | ^~ 2025-09-08T14:56:09,658 Box2D/Box2D_wrap.cpp:9692:89: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,658 9692 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB_Combine", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,658 | ^~ 2025-09-08T14:56:09,658 Box2D/Box2D_wrap.cpp:9694:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,658 9694 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:09,658 | ^~ 2025-09-08T14:56:09,660 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,660 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,660 | ^~~~ 2025-09-08T14:56:09,660 Box2D/Box2D_wrap.cpp:9694:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,660 9694 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:09,661 | ^~~~~~~~~ 2025-09-08T14:56:09,661 Box2D/Box2D_wrap.cpp:9696:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,661 9696 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,661 | ^~ 2025-09-08T14:56:09,662 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,663 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,663 | ^~~~ 2025-09-08T14:56:09,663 Box2D/Box2D_wrap.cpp:9696:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,663 9696 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,663 | ^~~~~~~~~ 2025-09-08T14:56:09,670 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_lowerBound_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,670 Box2D/Box2D_wrap.cpp:9749:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,671 9749 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,671 | ^~ 2025-09-08T14:56:09,671 Box2D/Box2D_wrap.cpp:9749:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,671 9749 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,671 | ^~~~~~~~ 2025-09-08T14:56:09,675 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB_upperBound_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,675 Box2D/Box2D_wrap.cpp:9771:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,675 9771 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,675 | ^~ 2025-09-08T14:56:09,675 Box2D/Box2D_wrap.cpp:9771:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,675 9771 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,676 | ^~~~~~~~ 2025-09-08T14:56:09,677 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,677 Box2D/Box2D_wrap.cpp:9778:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,677 9778 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,677 | ^~ 2025-09-08T14:56:09,677 Box2D/Box2D_wrap.cpp:9778:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,677 9778 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2AABB, 0 | 0 ); 2025-09-08T14:56:09,677 | ^~~~~~~~ 2025-09-08T14:56:09,682 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2AABB___contains__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,682 Box2D/Box2D_wrap.cpp:9802:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,682 9802 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB___contains__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,682 | ^~ 2025-09-08T14:56:09,682 Box2D/Box2D_wrap.cpp:9802:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,682 9802 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2AABB___contains__", 0, 2, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,682 | ^~ 2025-09-08T14:56:09,683 Box2D/Box2D_wrap.cpp:9804:6: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,683 9804 | if (!_v) goto check_1; return _wrap_b2AABB___contains____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2025-09-08T14:56:09,683 | ^~ 2025-09-08T14:56:09,684 Box2D/Box2D_wrap.cpp:9804:29: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,684 9804 | if (!_v) goto check_1; return _wrap_b2AABB___contains____SWIG_0(self, argc, argv);} check_1: if (argc == 2) { 2025-09-08T14:56:09,684 | ^~~~~~ 2025-09-08T14:56:09,684 Box2D/Box2D_wrap.cpp:9806:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,684 9806 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,685 | ^~ 2025-09-08T14:56:09,687 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,687 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,687 | ^~~~ 2025-09-08T14:56:09,687 Box2D/Box2D_wrap.cpp:9806:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,687 9806 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,687 | ^~~~~~~~~ 2025-09-08T14:56:09,718 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TestOverlap(PyObject*, PyObject*)’: 2025-09-08T14:56:09,719 Box2D/Box2D_wrap.cpp:10071:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,719 10071 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2TestOverlap", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,719 | ^~ 2025-09-08T14:56:09,719 Box2D/Box2D_wrap.cpp:10071:88: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,719 10071 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2TestOverlap", 0, 6, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:09,719 | ^~ 2025-09-08T14:56:09,720 Box2D/Box2D_wrap.cpp:10074:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,720 10074 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,720 | ^~ 2025-09-08T14:56:09,722 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,722 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,722 | ^~~~ 2025-09-08T14:56:09,722 Box2D/Box2D_wrap.cpp:10074:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,723 10074 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:09,723 | ^~~~~~~~~ 2025-09-08T14:56:09,725 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete__b2Vec2Array(PyObject*, PyObject*)’: 2025-09-08T14:56:09,725 Box2D/Box2D_wrap.cpp:10091:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,725 10091 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,725 | ^~ 2025-09-08T14:56:09,725 Box2D/Box2D_wrap.cpp:10091:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,726 10091 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,726 | ^~~~~~~~ 2025-09-08T14:56:09,734 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap__b2Vec2Array_frompointer(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,734 Box2D/Box2D_wrap.cpp:10137:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,734 10137 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:_b2Vec2Array_frompointer", kwnames, &obj0)) SWIG_fail; { 2025-09-08T14:56:09,734 | ^~ 2025-09-08T14:56:09,734 Box2D/Box2D_wrap.cpp:10137:108: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,735 10137 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:_b2Vec2Array_frompointer", kwnames, &obj0)) SWIG_fail; { 2025-09-08T14:56:09,735 | ^ 2025-09-08T14:56:09,741 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_Set(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,741 Box2D/Box2D_wrap.cpp:10184:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,741 10184 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Color_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2025-09-08T14:56:09,741 | ^~ 2025-09-08T14:56:09,741 Box2D/Box2D_wrap.cpp:10184:119: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,742 10184 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOOO:b2Color_Set", kwnames, &obj0, &obj1, &obj2, &obj3)) SWIG_fail; { 2025-09-08T14:56:09,742 | ^ 2025-09-08T14:56:09,743 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_r_set(PyObject*, PyObject*)’: 2025-09-08T14:56:09,743 Box2D/Box2D_wrap.cpp:10197:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,744 10197 | if (!SWIG_Python_UnpackTuple(args, "b2Color_r_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,744 | ^~ 2025-09-08T14:56:09,744 Box2D/Box2D_wrap.cpp:10197:83: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,744 10197 | if (!SWIG_Python_UnpackTuple(args, "b2Color_r_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,744 | ^ 2025-09-08T14:56:09,746 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_g_set(PyObject*, PyObject*)’: 2025-09-08T14:56:09,746 Box2D/Box2D_wrap.cpp:10212:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,746 10212 | if (!SWIG_Python_UnpackTuple(args, "b2Color_g_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,746 | ^~ 2025-09-08T14:56:09,746 Box2D/Box2D_wrap.cpp:10212:83: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,746 10212 | if (!SWIG_Python_UnpackTuple(args, "b2Color_g_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,747 | ^ 2025-09-08T14:56:09,748 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color_b_set(PyObject*, PyObject*)’: 2025-09-08T14:56:09,749 Box2D/Box2D_wrap.cpp:10227:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,749 10227 | if (!SWIG_Python_UnpackTuple(args, "b2Color_b_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,749 | ^~ 2025-09-08T14:56:09,749 Box2D/Box2D_wrap.cpp:10227:83: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,749 10227 | if (!SWIG_Python_UnpackTuple(args, "b2Color_b_set", 2, 2, swig_obj)) SWIG_fail; { 2025-09-08T14:56:09,749 | ^ 2025-09-08T14:56:09,755 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2Color(PyObject*, PyObject*)’: 2025-09-08T14:56:09,755 Box2D/Box2D_wrap.cpp:10262:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,755 10262 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Color", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,755 | ^~ 2025-09-08T14:56:09,755 Box2D/Box2D_wrap.cpp:10262:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,755 10262 | if (!(argc = SWIG_Python_UnpackTuple(args, "new_b2Color", 0, 3, argv))) SWIG_fail; --argc; if (argc == 0) { 2025-09-08T14:56:09,755 | ^~ 2025-09-08T14:56:09,756 Box2D/Box2D_wrap.cpp:10265:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,756 10265 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:09,756 | ^~ 2025-09-08T14:56:09,758 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,758 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:09,758 | ^~~~ 2025-09-08T14:56:09,758 Box2D/Box2D_wrap.cpp:10265:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:09,758 10265 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:09,759 | ^~~~~~~~~ 2025-09-08T14:56:09,761 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___getitem__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,761 Box2D/Box2D_wrap.cpp:10280:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,761 10280 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,761 | ^~ 2025-09-08T14:56:09,761 Box2D/Box2D_wrap.cpp:10280:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,761 10280 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___getitem__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,762 | ^ 2025-09-08T14:56:09,763 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___setitem__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,764 Box2D/Box2D_wrap.cpp:10292:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,764 10292 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Color___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,764 | ^~ 2025-09-08T14:56:09,764 Box2D/Box2D_wrap.cpp:10292:119: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,764 10292 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OOO:b2Color___setitem__", kwnames, &obj0, &obj1, &obj2)) SWIG_fail; { 2025-09-08T14:56:09,764 | ^ 2025-09-08T14:56:09,766 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___truediv__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,766 Box2D/Box2D_wrap.cpp:10304:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,766 10304 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,767 | ^~ 2025-09-08T14:56:09,767 Box2D/Box2D_wrap.cpp:10304:111: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,767 10304 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___truediv__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,767 | ^ 2025-09-08T14:56:09,769 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___add__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,770 Box2D/Box2D_wrap.cpp:10317:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,770 10317 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,770 | ^~ 2025-09-08T14:56:09,770 Box2D/Box2D_wrap.cpp:10317:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,770 10317 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___add__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,770 | ^ 2025-09-08T14:56:09,774 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___sub__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,774 Box2D/Box2D_wrap.cpp:10337:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,774 10337 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,774 | ^~ 2025-09-08T14:56:09,775 Box2D/Box2D_wrap.cpp:10337:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,775 10337 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___sub__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,775 | ^ 2025-09-08T14:56:09,779 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___div__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,779 Box2D/Box2D_wrap.cpp:10357:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,779 10357 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,779 | ^~ 2025-09-08T14:56:09,779 Box2D/Box2D_wrap.cpp:10357:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,780 10357 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___div__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,780 | ^ 2025-09-08T14:56:09,782 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___rmul__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,782 Box2D/Box2D_wrap.cpp:10370:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,783 10370 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,783 | ^~ 2025-09-08T14:56:09,783 Box2D/Box2D_wrap.cpp:10370:108: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,783 10370 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___rmul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,783 | ^ 2025-09-08T14:56:09,786 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___mul__(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,786 Box2D/Box2D_wrap.cpp:10383:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,786 10383 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,786 | ^~ 2025-09-08T14:56:09,786 Box2D/Box2D_wrap.cpp:10383:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,787 10383 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___mul__", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,787 | ^ 2025-09-08T14:56:09,789 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___isub(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,789 Box2D/Box2D_wrap.cpp:10396:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,790 10396 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___isub", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,790 | ^~ 2025-09-08T14:56:09,790 Box2D/Box2D_wrap.cpp:10396:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,790 10396 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___isub", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,790 | ^ 2025-09-08T14:56:09,793 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___itruediv(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,793 Box2D/Box2D_wrap.cpp:10414:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,794 10414 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___itruediv", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,794 | ^~ 2025-09-08T14:56:09,794 Box2D/Box2D_wrap.cpp:10414:110: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,794 10414 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___itruediv", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,794 | ^ 2025-09-08T14:56:09,797 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___idiv(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,797 Box2D/Box2D_wrap.cpp:10432:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,797 10432 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___idiv", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,797 | ^~ 2025-09-08T14:56:09,797 Box2D/Box2D_wrap.cpp:10432:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,797 10432 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___idiv", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,797 | ^ 2025-09-08T14:56:09,800 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___imul(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,800 Box2D/Box2D_wrap.cpp:10450:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,800 10450 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___imul", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,801 | ^~ 2025-09-08T14:56:09,801 Box2D/Box2D_wrap.cpp:10450:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,801 10450 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___imul", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,801 | ^ 2025-09-08T14:56:09,804 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___iadd(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,804 Box2D/Box2D_wrap.cpp:10468:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,804 10468 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___iadd", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,804 | ^~ 2025-09-08T14:56:09,804 Box2D/Box2D_wrap.cpp:10468:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,804 10468 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___iadd", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,804 | ^ 2025-09-08T14:56:09,807 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Color___equ(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,807 Box2D/Box2D_wrap.cpp:10486:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,808 10486 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,808 | ^~ 2025-09-08T14:56:09,808 Box2D/Box2D_wrap.cpp:10486:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,808 10486 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO:b2Color___equ", kwnames, &obj0, &obj1)) SWIG_fail; { 2025-09-08T14:56:09,808 | ^ 2025-09-08T14:56:09,816 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Draw___GetFlags(PyObject*, PyObject*)’: 2025-09-08T14:56:09,816 Box2D/Box2D_wrap.cpp:10545:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,816 10545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Draw, 0 | 0 ); 2025-09-08T14:56:09,816 | ^~ 2025-09-08T14:56:09,816 Box2D/Box2D_wrap.cpp:10545:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,817 10545 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Draw, 0 | 0 ); 2025-09-08T14:56:09,817 | ^~~~~~~~ 2025-09-08T14:56:09,854 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Draw___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,854 Box2D/Box2D_wrap.cpp:10775:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,854 10775 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Draw, 0 | 0 ); 2025-09-08T14:56:09,854 | ^~ 2025-09-08T14:56:09,854 Box2D/Box2D_wrap.cpp:10775:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,855 10775 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Draw, 0 | 0 ); 2025-09-08T14:56:09,855 | ^~~~~~~~ 2025-09-08T14:56:09,917 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DrawExtended(PyObject*, PyObject*)’: 2025-09-08T14:56:09,918 Box2D/Box2D_wrap.cpp:11194:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,918 11194 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,918 | ^~ 2025-09-08T14:56:09,918 Box2D/Box2D_wrap.cpp:11194:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,918 11194 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,918 | ^~~~~~~~ 2025-09-08T14:56:09,920 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2DrawExtended(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:09,920 Box2D/Box2D_wrap.cpp:11202:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,920 11202 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DrawExtended", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:09,920 | ^~ 2025-09-08T14:56:09,921 Box2D/Box2D_wrap.cpp:11202:102: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,921 11202 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DrawExtended", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:09,921 | ^~~~ 2025-09-08T14:56:09,927 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData_mass_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,927 Box2D/Box2D_wrap.cpp:11262:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,927 11262 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2025-09-08T14:56:09,928 | ^~ 2025-09-08T14:56:09,928 Box2D/Box2D_wrap.cpp:11262:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,928 11262 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2025-09-08T14:56:09,928 | ^~~~~~~~ 2025-09-08T14:56:09,933 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData_I_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,934 Box2D/Box2D_wrap.cpp:11301:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,934 11301 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2025-09-08T14:56:09,934 | ^~ 2025-09-08T14:56:09,934 Box2D/Box2D_wrap.cpp:11301:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,934 11301 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2025-09-08T14:56:09,934 | ^~~~~~~~ 2025-09-08T14:56:09,935 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MassData___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,935 Box2D/Box2D_wrap.cpp:11308:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,935 11308 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2025-09-08T14:56:09,935 | ^~ 2025-09-08T14:56:09,935 Box2D/Box2D_wrap.cpp:11308:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,936 11308 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MassData, 0 | 0 ); 2025-09-08T14:56:09,936 | ^~~~~~~~ 2025-09-08T14:56:09,938 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2MassData(PyObject*, PyObject*)’: 2025-09-08T14:56:09,938 Box2D/Box2D_wrap.cpp:11321:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,938 11321 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,938 | ^~ 2025-09-08T14:56:09,938 Box2D/Box2D_wrap.cpp:11321:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,938 11321 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,939 | ^~~~~~~~ 2025-09-08T14:56:09,941 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Shape___GetType(PyObject*, PyObject*)’: 2025-09-08T14:56:09,942 Box2D/Box2D_wrap.cpp:11346:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,942 11346 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2025-09-08T14:56:09,942 | ^~ 2025-09-08T14:56:09,942 Box2D/Box2D_wrap.cpp:11346:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,942 11346 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2025-09-08T14:56:09,942 | ^~~~~~~~ 2025-09-08T14:56:09,943 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Shape___GetChildCount(PyObject*, PyObject*)’: 2025-09-08T14:56:09,943 Box2D/Box2D_wrap.cpp:11354:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,944 11354 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2025-09-08T14:56:09,944 | ^~ 2025-09-08T14:56:09,944 Box2D/Box2D_wrap.cpp:11354:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,944 11354 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2025-09-08T14:56:09,944 | ^~~~~~~~ 2025-09-08T14:56:09,959 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Shape_radius_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,959 Box2D/Box2D_wrap.cpp:11459:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,959 11459 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2025-09-08T14:56:09,959 | ^~ 2025-09-08T14:56:09,959 Box2D/Box2D_wrap.cpp:11459:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,959 11459 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2025-09-08T14:56:09,960 | ^~~~~~~~ 2025-09-08T14:56:09,961 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Shape___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,961 Box2D/Box2D_wrap.cpp:11466:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,961 11466 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2025-09-08T14:56:09,961 | ^~ 2025-09-08T14:56:09,962 Box2D/Box2D_wrap.cpp:11466:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,962 11466 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Shape, 0 | 0 ); 2025-09-08T14:56:09,962 | ^~~~~~~~ 2025-09-08T14:56:09,968 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2CircleShape___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,968 Box2D/Box2D_wrap.cpp:11510:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,968 11510 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2025-09-08T14:56:09,968 | ^~ 2025-09-08T14:56:09,968 Box2D/Box2D_wrap.cpp:11510:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,968 11510 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2CircleShape, 0 | 0 ); 2025-09-08T14:56:09,968 | ^~~~~~~~ 2025-09-08T14:56:09,969 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2CircleShape(PyObject*, PyObject*)’: 2025-09-08T14:56:09,969 Box2D/Box2D_wrap.cpp:11518:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,970 11518 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,970 | ^~ 2025-09-08T14:56:09,970 Box2D/Box2D_wrap.cpp:11518:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,970 11518 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:09,970 | ^~~~~~~~ 2025-09-08T14:56:09,992 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_hasVertex0_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,993 Box2D/Box2D_wrap.cpp:11669:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,993 11669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2025-09-08T14:56:09,993 | ^~ 2025-09-08T14:56:09,993 Box2D/Box2D_wrap.cpp:11669:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,993 11669 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2025-09-08T14:56:09,993 | ^~~~~~~~ 2025-09-08T14:56:09,996 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape_hasVertex3_get(PyObject*, PyObject*)’: 2025-09-08T14:56:09,996 Box2D/Box2D_wrap.cpp:11686:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,996 11686 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2025-09-08T14:56:09,996 | ^~ 2025-09-08T14:56:09,996 Box2D/Box2D_wrap.cpp:11686:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,996 11686 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2025-09-08T14:56:09,996 | ^~~~~~~~ 2025-09-08T14:56:09,998 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2EdgeShape___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:09,998 Box2D/Box2D_wrap.cpp:11693:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:09,998 11693 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2025-09-08T14:56:09,998 | ^~ 2025-09-08T14:56:09,998 Box2D/Box2D_wrap.cpp:11693:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:09,999 11693 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2EdgeShape, 0 | 0 ); 2025-09-08T14:56:09,999 | ^~~~~~~~ 2025-09-08T14:56:10,000 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2EdgeShape(PyObject*, PyObject*)’: 2025-09-08T14:56:10,000 Box2D/Box2D_wrap.cpp:11701:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,001 11701 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,001 | ^~ 2025-09-08T14:56:10,001 Box2D/Box2D_wrap.cpp:11701:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,001 11701 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,001 | ^~~~~~~~ 2025-09-08T14:56:10,004 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ChainShape(PyObject*, PyObject*)’: 2025-09-08T14:56:10,004 Box2D/Box2D_wrap.cpp:11724:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,005 11724 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,005 | ^~ 2025-09-08T14:56:10,005 Box2D/Box2D_wrap.cpp:11724:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,005 11724 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,005 | ^~~~~~~~ 2025-09-08T14:56:10,029 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_hasPrevVertex_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,029 Box2D/Box2D_wrap.cpp:11881:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,029 11881 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2025-09-08T14:56:10,029 | ^~ 2025-09-08T14:56:10,029 Box2D/Box2D_wrap.cpp:11881:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,029 11881 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2025-09-08T14:56:10,029 | ^~~~~~~~ 2025-09-08T14:56:10,032 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape_m_hasNextVertex_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,032 Box2D/Box2D_wrap.cpp:11898:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,032 11898 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2025-09-08T14:56:10,032 | ^~ 2025-09-08T14:56:10,032 Box2D/Box2D_wrap.cpp:11898:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,032 11898 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2025-09-08T14:56:10,033 | ^~~~~~~~ 2025-09-08T14:56:10,034 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,034 Box2D/Box2D_wrap.cpp:11905:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,034 11905 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2025-09-08T14:56:10,034 | ^~ 2025-09-08T14:56:10,034 Box2D/Box2D_wrap.cpp:11905:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,034 11905 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2025-09-08T14:56:10,034 | ^~~~~~~~ 2025-09-08T14:56:10,041 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ChainShape___get_count(PyObject*, PyObject*)’: 2025-09-08T14:56:10,041 Box2D/Box2D_wrap.cpp:11951:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,041 11951 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2025-09-08T14:56:10,041 | ^~ 2025-09-08T14:56:10,042 Box2D/Box2D_wrap.cpp:11951:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,042 11951 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ChainShape, 0 | 0 ); 2025-09-08T14:56:10,042 | ^~~~~~~~ 2025-09-08T14:56:10,045 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___set_vertices_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,045 Box2D/Box2D_wrap.cpp:11977:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,045 11977 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2025-09-08T14:56:10,045 | ^~ 2025-09-08T14:56:10,045 Box2D/Box2D_wrap.cpp:11977:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,046 11977 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2025-09-08T14:56:10,046 | ^~~~ 2025-09-08T14:56:10,049 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_SetAsBox__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,050 Box2D/Box2D_wrap.cpp:11997:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,050 11997 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2025-09-08T14:56:10,050 | ^~ 2025-09-08T14:56:10,050 Box2D/Box2D_wrap.cpp:11997:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,050 11997 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2025-09-08T14:56:10,050 | ^~~~ 2025-09-08T14:56:10,056 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_SetAsBox(PyObject*, PyObject*)’: 2025-09-08T14:56:10,056 Box2D/Box2D_wrap.cpp:12030:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,056 12030 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape_SetAsBox", 0, 5, argv))) SWIG_fail; --argc; if (argc == 3) { 2025-09-08T14:56:10,056 | ^~ 2025-09-08T14:56:10,056 Box2D/Box2D_wrap.cpp:12030:98: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,056 12030 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape_SetAsBox", 0, 5, argv))) SWIG_fail; --argc; if (argc == 3) { 2025-09-08T14:56:10,056 | ^~ 2025-09-08T14:56:10,057 Box2D/Box2D_wrap.cpp:12032:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,057 12032 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 5) { 2025-09-08T14:56:10,057 | ^~ 2025-09-08T14:56:10,058 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,059 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,059 | ^~~~ 2025-09-08T14:56:10,059 Box2D/Box2D_wrap.cpp:12032:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,059 12032 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 5) { 2025-09-08T14:56:10,059 | ^~~~~~~~~ 2025-09-08T14:56:10,059 Box2D/Box2D_wrap.cpp:12034:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,059 12034 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,059 | ^~ 2025-09-08T14:56:10,061 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,061 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,061 | ^~~~ 2025-09-08T14:56:10,062 Box2D/Box2D_wrap.cpp:12034:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,062 12034 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,062 | ^~~~~~~~~ 2025-09-08T14:56:10,081 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape_set_vertex(PyObject*, PyObject*)’: 2025-09-08T14:56:10,081 Box2D/Box2D_wrap.cpp:12175:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,081 12175 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2025-09-08T14:56:10,081 | ^~ 2025-09-08T14:56:10,083 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,083 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,083 | ^~~~ 2025-09-08T14:56:10,084 Box2D/Box2D_wrap.cpp:12175:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,084 12175 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 4) { 2025-09-08T14:56:10,084 | ^~~~~~~~~ 2025-09-08T14:56:10,084 Box2D/Box2D_wrap.cpp:12177:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,084 12177 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,084 | ^~ 2025-09-08T14:56:10,087 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,087 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,087 | ^~~~ 2025-09-08T14:56:10,087 Box2D/Box2D_wrap.cpp:12177:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,087 12177 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,087 | ^~~~~~~~~ 2025-09-08T14:56:10,088 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___set_vertices_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,088 Box2D/Box2D_wrap.cpp:12183:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,088 12183 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2025-09-08T14:56:10,088 | ^~ 2025-09-08T14:56:10,088 Box2D/Box2D_wrap.cpp:12183:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,088 12183 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PolygonShape, 0 | 0 ); 2025-09-08T14:56:10,088 | ^~~~ 2025-09-08T14:56:10,090 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PolygonShape___set_vertices_internal(PyObject*, PyObject*)’: 2025-09-08T14:56:10,090 Box2D/Box2D_wrap.cpp:12191:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,090 12191 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape___set_vertices_internal", 0, 3, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,090 | ^~ 2025-09-08T14:56:10,090 Box2D/Box2D_wrap.cpp:12191:113: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,090 12191 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2PolygonShape___set_vertices_internal", 0, 3, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,091 | ^~ 2025-09-08T14:56:10,091 Box2D/Box2D_wrap.cpp:12193:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,091 12193 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:10,091 | ^~ 2025-09-08T14:56:10,094 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,094 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,094 | ^~~~ 2025-09-08T14:56:10,094 Box2D/Box2D_wrap.cpp:12193:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,094 12193 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:10,094 | ^~~~~~~~~ 2025-09-08T14:56:10,095 Box2D/Box2D_wrap.cpp:12195:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,095 12195 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,095 | ^~ 2025-09-08T14:56:10,097 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,097 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,097 | ^~~~ 2025-09-08T14:56:10,098 Box2D/Box2D_wrap.cpp:12195:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,098 12195 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,098 | ^~~~~~~~~ 2025-09-08T14:56:10,098 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PolygonShape(PyObject*, PyObject*)’: 2025-09-08T14:56:10,098 Box2D/Box2D_wrap.cpp:12201:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,099 12201 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,099 | ^~ 2025-09-08T14:56:10,099 Box2D/Box2D_wrap.cpp:12201:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,099 12201 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,099 | ^~~~~~~~ 2025-09-08T14:56:10,102 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_IsLeaf(PyObject*, PyObject*)’: 2025-09-08T14:56:10,102 Box2D/Box2D_wrap.cpp:12219:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,102 12219 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2025-09-08T14:56:10,102 | ^~ 2025-09-08T14:56:10,102 Box2D/Box2D_wrap.cpp:12219:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,102 12219 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2025-09-08T14:56:10,102 | ^~~~~~~~ 2025-09-08T14:56:10,108 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_child1_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,108 Box2D/Box2D_wrap.cpp:12254:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,108 12254 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2025-09-08T14:56:10,108 | ^~ 2025-09-08T14:56:10,108 Box2D/Box2D_wrap.cpp:12254:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,108 12254 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2025-09-08T14:56:10,108 | ^~~~~~~~ 2025-09-08T14:56:10,111 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_child2_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,111 Box2D/Box2D_wrap.cpp:12270:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,112 12270 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2025-09-08T14:56:10,112 | ^~ 2025-09-08T14:56:10,112 Box2D/Box2D_wrap.cpp:12270:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,112 12270 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2025-09-08T14:56:10,112 | ^~~~~~~~ 2025-09-08T14:56:10,114 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TreeNode_height_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,115 Box2D/Box2D_wrap.cpp:12286:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,115 12286 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2025-09-08T14:56:10,115 | ^~ 2025-09-08T14:56:10,115 Box2D/Box2D_wrap.cpp:12286:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,115 12286 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TreeNode, 0 | 0 ); 2025-09-08T14:56:10,115 | ^~~~~~~~ 2025-09-08T14:56:10,117 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2TreeNode(PyObject*, PyObject*)’: 2025-09-08T14:56:10,117 Box2D/Box2D_wrap.cpp:12298:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,117 12298 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,117 | ^~ 2025-09-08T14:56:10,117 Box2D/Box2D_wrap.cpp:12298:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,117 12298 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,118 | ^~~~~~~~ 2025-09-08T14:56:10,120 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Pair_proxyIdA_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,120 Box2D/Box2D_wrap.cpp:12325:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,120 12325 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Pair, 0 | 0 ); 2025-09-08T14:56:10,121 | ^~ 2025-09-08T14:56:10,121 Box2D/Box2D_wrap.cpp:12325:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,121 12325 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Pair, 0 | 0 ); 2025-09-08T14:56:10,121 | ^~~~~~~~ 2025-09-08T14:56:10,123 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Pair_proxyIdB_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,123 Box2D/Box2D_wrap.cpp:12341:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,123 12341 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Pair, 0 | 0 ); 2025-09-08T14:56:10,123 | ^~ 2025-09-08T14:56:10,123 Box2D/Box2D_wrap.cpp:12341:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,123 12341 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Pair, 0 | 0 ); 2025-09-08T14:56:10,124 | ^~~~~~~~ 2025-09-08T14:56:10,124 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Pair___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,124 Box2D/Box2D_wrap.cpp:12348:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,125 12348 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Pair, 0 | 0 ); 2025-09-08T14:56:10,125 | ^~ 2025-09-08T14:56:10,125 Box2D/Box2D_wrap.cpp:12348:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,125 12348 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Pair, 0 | 0 ); 2025-09-08T14:56:10,125 | ^~~~~~~~ 2025-09-08T14:56:10,129 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2BroadPhase(PyObject*, PyObject*)’: 2025-09-08T14:56:10,129 Box2D/Box2D_wrap.cpp:12384:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,130 12384 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,130 | ^~ 2025-09-08T14:56:10,130 Box2D/Box2D_wrap.cpp:12384:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,130 12384 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,130 | ^~~~~~~~ 2025-09-08T14:56:10,140 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetProxyCount(PyObject*, PyObject*)’: 2025-09-08T14:56:10,141 Box2D/Box2D_wrap.cpp:12452:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,141 12452 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,141 | ^~ 2025-09-08T14:56:10,141 Box2D/Box2D_wrap.cpp:12452:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,141 12452 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,141 | ^~~~~~~~ 2025-09-08T14:56:10,143 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeHeight(PyObject*, PyObject*)’: 2025-09-08T14:56:10,143 Box2D/Box2D_wrap.cpp:12460:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,143 12460 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,143 | ^~ 2025-09-08T14:56:10,143 Box2D/Box2D_wrap.cpp:12460:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,143 12460 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,143 | ^~~~~~~~ 2025-09-08T14:56:10,145 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeBalance(PyObject*, PyObject*)’: 2025-09-08T14:56:10,145 Box2D/Box2D_wrap.cpp:12468:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,145 12468 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,145 | ^~ 2025-09-08T14:56:10,145 Box2D/Box2D_wrap.cpp:12468:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,145 12468 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,145 | ^~~~~~~~ 2025-09-08T14:56:10,147 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___GetTreeQuality(PyObject*, PyObject*)’: 2025-09-08T14:56:10,147 Box2D/Box2D_wrap.cpp:12476:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,147 12476 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,147 | ^~ 2025-09-08T14:56:10,147 Box2D/Box2D_wrap.cpp:12476:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,148 12476 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,148 | ^~~~~~~~ 2025-09-08T14:56:10,152 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BroadPhase___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,152 Box2D/Box2D_wrap.cpp:12501:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,153 12501 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,153 | ^~ 2025-09-08T14:56:10,153 Box2D/Box2D_wrap.cpp:12501:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,153 12501 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BroadPhase, 0 | 0 ); 2025-09-08T14:56:10,153 | ^~~~~~~~ 2025-09-08T14:56:10,172 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceProxy(PyObject*, PyObject*)’: 2025-09-08T14:56:10,172 Box2D/Box2D_wrap.cpp:12644:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,172 12644 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,172 | ^~ 2025-09-08T14:56:10,172 Box2D/Box2D_wrap.cpp:12644:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,172 12644 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,173 | ^~~~~~~~ 2025-09-08T14:56:10,188 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceInput(PyObject*, PyObject*)’: 2025-09-08T14:56:10,188 Box2D/Box2D_wrap.cpp:12769:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,188 12769 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,188 | ^~ 2025-09-08T14:56:10,188 Box2D/Box2D_wrap.cpp:12769:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,188 12769 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,188 | ^~~~~~~~ 2025-09-08T14:56:10,203 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceOutput(PyObject*, PyObject*)’: 2025-09-08T14:56:10,203 Box2D/Box2D_wrap.cpp:12884:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,203 12884 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,203 | ^~ 2025-09-08T14:56:10,203 Box2D/Box2D_wrap.cpp:12884:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,204 12884 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,204 | ^~~~~~~~ 2025-09-08T14:56:10,217 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput_tMax_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,217 Box2D/Box2D_wrap.cpp:12985:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,217 12985 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2025-09-08T14:56:10,217 | ^~ 2025-09-08T14:56:10,217 Box2D/Box2D_wrap.cpp:12985:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,218 12985 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2025-09-08T14:56:10,218 | ^~~~~~~~ 2025-09-08T14:56:10,219 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIInput___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,219 Box2D/Box2D_wrap.cpp:12992:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,219 12992 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2025-09-08T14:56:10,219 | ^~ 2025-09-08T14:56:10,219 Box2D/Box2D_wrap.cpp:12992:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,219 12992 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIInput, 0 | 0 ); 2025-09-08T14:56:10,220 | ^~~~~~~~ 2025-09-08T14:56:10,222 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2TOIInput(PyObject*, PyObject*)’: 2025-09-08T14:56:10,222 Box2D/Box2D_wrap.cpp:13005:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,222 13005 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,222 | ^~ 2025-09-08T14:56:10,222 Box2D/Box2D_wrap.cpp:13005:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,222 13005 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,222 | ^~~~~~~~ 2025-09-08T14:56:10,228 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIOutput_t_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,228 Box2D/Box2D_wrap.cpp:13048:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,228 13048 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2025-09-08T14:56:10,228 | ^~ 2025-09-08T14:56:10,229 Box2D/Box2D_wrap.cpp:13048:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,229 13048 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2025-09-08T14:56:10,229 | ^~~~~~~~ 2025-09-08T14:56:10,230 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2TOIOutput___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,230 Box2D/Box2D_wrap.cpp:13055:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,230 13055 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2025-09-08T14:56:10,231 | ^~ 2025-09-08T14:56:10,231 Box2D/Box2D_wrap.cpp:13055:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,231 13055 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2TOIOutput, 0 | 0 ); 2025-09-08T14:56:10,231 | ^~~~~~~~ 2025-09-08T14:56:10,233 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2TOIOutput(PyObject*, PyObject*)’: 2025-09-08T14:56:10,234 Box2D/Box2D_wrap.cpp:13068:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,234 13068 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,234 | ^~ 2025-09-08T14:56:10,234 Box2D/Box2D_wrap.cpp:13068:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,234 13068 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,234 | ^~~~~~~~ 2025-09-08T14:56:10,238 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_type_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,238 Box2D/Box2D_wrap.cpp:13100:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,238 13100 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,238 | ^~ 2025-09-08T14:56:10,239 Box2D/Box2D_wrap.cpp:13100:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,239 13100 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,239 | ^~~~~~~~ 2025-09-08T14:56:10,242 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_position_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,242 Box2D/Box2D_wrap.cpp:13123:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,242 13123 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,242 | ^~ 2025-09-08T14:56:10,242 Box2D/Box2D_wrap.cpp:13123:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,243 13123 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,243 | ^~~~~~~~ 2025-09-08T14:56:10,245 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angle_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,245 Box2D/Box2D_wrap.cpp:13139:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,245 13139 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,245 | ^~ 2025-09-08T14:56:10,245 Box2D/Box2D_wrap.cpp:13139:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,245 13139 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,245 | ^~~~~~~~ 2025-09-08T14:56:10,249 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_linearVelocity_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,249 Box2D/Box2D_wrap.cpp:13163:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,249 13163 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,249 | ^~ 2025-09-08T14:56:10,249 Box2D/Box2D_wrap.cpp:13163:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,249 13163 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,250 | ^~~~~~~~ 2025-09-08T14:56:10,252 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angularVelocity_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,252 Box2D/Box2D_wrap.cpp:13180:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,252 13180 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,252 | ^~ 2025-09-08T14:56:10,252 Box2D/Box2D_wrap.cpp:13180:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,252 13180 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,252 | ^~~~~~~~ 2025-09-08T14:56:10,255 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_linearDamping_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,255 Box2D/Box2D_wrap.cpp:13197:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,255 13197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,255 | ^~ 2025-09-08T14:56:10,255 Box2D/Box2D_wrap.cpp:13197:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,255 13197 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,255 | ^~~~~~~~ 2025-09-08T14:56:10,258 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_angularDamping_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,258 Box2D/Box2D_wrap.cpp:13214:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,258 13214 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,258 | ^~ 2025-09-08T14:56:10,258 Box2D/Box2D_wrap.cpp:13214:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,258 13214 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,259 | ^~~~~~~~ 2025-09-08T14:56:10,261 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_allowSleep_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,261 Box2D/Box2D_wrap.cpp:13230:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,261 13230 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,261 | ^~ 2025-09-08T14:56:10,261 Box2D/Box2D_wrap.cpp:13230:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,261 13230 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,262 | ^~~~~~~~ 2025-09-08T14:56:10,264 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_awake_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,264 Box2D/Box2D_wrap.cpp:13246:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,264 13246 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,264 | ^~ 2025-09-08T14:56:10,265 Box2D/Box2D_wrap.cpp:13246:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,265 13246 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,265 | ^~~~~~~~ 2025-09-08T14:56:10,267 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_fixedRotation_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,267 Box2D/Box2D_wrap.cpp:13263:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,268 13263 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,268 | ^~ 2025-09-08T14:56:10,268 Box2D/Box2D_wrap.cpp:13263:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,268 13263 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,268 | ^~~~~~~~ 2025-09-08T14:56:10,271 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_bullet_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,271 Box2D/Box2D_wrap.cpp:13279:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,271 13279 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,271 | ^~ 2025-09-08T14:56:10,271 Box2D/Box2D_wrap.cpp:13279:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,271 13279 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,271 | ^~~~~~~~ 2025-09-08T14:56:10,274 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_active_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,274 Box2D/Box2D_wrap.cpp:13295:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,274 13295 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,274 | ^~ 2025-09-08T14:56:10,275 Box2D/Box2D_wrap.cpp:13295:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,275 13295 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,275 | ^~~~~~~~ 2025-09-08T14:56:10,278 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef_gravityScale_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,278 Box2D/Box2D_wrap.cpp:13312:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,278 13312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,278 | ^~ 2025-09-08T14:56:10,278 Box2D/Box2D_wrap.cpp:13312:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,278 13312 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,278 | ^~~~~~~~ 2025-09-08T14:56:10,280 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2BodyDef___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,280 Box2D/Box2D_wrap.cpp:13319:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,280 13319 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,280 | ^~ 2025-09-08T14:56:10,280 Box2D/Box2D_wrap.cpp:13319:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,281 13319 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2BodyDef, 0 | 0 ); 2025-09-08T14:56:10,281 | ^~~~~~~~ 2025-09-08T14:56:10,287 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___CreateFixture__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,287 Box2D/Box2D_wrap.cpp:13369:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,287 13369 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,287 | ^~ 2025-09-08T14:56:10,287 Box2D/Box2D_wrap.cpp:13369:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,287 13369 | if ((nobjs < 3) || (nobjs > 3)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,287 | ^~~~ 2025-09-08T14:56:10,292 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetTransform(PyObject*, PyObject*)’: 2025-09-08T14:56:10,292 Box2D/Box2D_wrap.cpp:13402:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,292 13402 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,293 | ^~ 2025-09-08T14:56:10,293 Box2D/Box2D_wrap.cpp:13402:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,293 13402 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,293 | ^~~~~~~~ 2025-09-08T14:56:10,294 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetPosition(PyObject*, PyObject*)’: 2025-09-08T14:56:10,294 Box2D/Box2D_wrap.cpp:13411:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,294 13411 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,294 | ^~ 2025-09-08T14:56:10,294 Box2D/Box2D_wrap.cpp:13411:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,295 13411 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,295 | ^~~~~~~~ 2025-09-08T14:56:10,296 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetAngle(PyObject*, PyObject*)’: 2025-09-08T14:56:10,296 Box2D/Box2D_wrap.cpp:13419:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,296 13419 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,296 | ^~ 2025-09-08T14:56:10,296 Box2D/Box2D_wrap.cpp:13419:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,296 13419 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,296 | ^~~~~~~~ 2025-09-08T14:56:10,297 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorldCenter(PyObject*, PyObject*)’: 2025-09-08T14:56:10,298 Box2D/Box2D_wrap.cpp:13427:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,298 13427 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,298 | ^~ 2025-09-08T14:56:10,298 Box2D/Box2D_wrap.cpp:13427:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,298 13427 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,298 | ^~~~~~~~ 2025-09-08T14:56:10,299 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetLocalCenter(PyObject*, PyObject*)’: 2025-09-08T14:56:10,299 Box2D/Box2D_wrap.cpp:13435:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,300 13435 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,300 | ^~ 2025-09-08T14:56:10,300 Box2D/Box2D_wrap.cpp:13435:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,300 13435 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,300 | ^~~~~~~~ 2025-09-08T14:56:10,304 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetLinearVelocity(PyObject*, PyObject*)’: 2025-09-08T14:56:10,304 Box2D/Box2D_wrap.cpp:13460:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,304 13460 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,304 | ^~ 2025-09-08T14:56:10,305 Box2D/Box2D_wrap.cpp:13460:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,305 13460 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,305 | ^~~~~~~~ 2025-09-08T14:56:10,308 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetAngularVelocity(PyObject*, PyObject*)’: 2025-09-08T14:56:10,308 Box2D/Box2D_wrap.cpp:13479:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,308 13479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,308 | ^~ 2025-09-08T14:56:10,308 Box2D/Box2D_wrap.cpp:13479:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,308 13479 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,308 | ^~~~~~~~ 2025-09-08T14:56:10,327 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetMass(PyObject*, PyObject*)’: 2025-09-08T14:56:10,327 Box2D/Box2D_wrap.cpp:13591:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,327 13591 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,327 | ^~ 2025-09-08T14:56:10,327 Box2D/Box2D_wrap.cpp:13591:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,327 13591 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,327 | ^~~~~~~~ 2025-09-08T14:56:10,329 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetInertia(PyObject*, PyObject*)’: 2025-09-08T14:56:10,329 Box2D/Box2D_wrap.cpp:13599:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,329 13599 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,330 | ^~ 2025-09-08T14:56:10,330 Box2D/Box2D_wrap.cpp:13599:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,330 13599 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,330 | ^~~~~~~~ 2025-09-08T14:56:10,355 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetLinearDamping(PyObject*, PyObject*)’: 2025-09-08T14:56:10,355 Box2D/Box2D_wrap.cpp:13755:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,355 13755 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,355 | ^~ 2025-09-08T14:56:10,355 Box2D/Box2D_wrap.cpp:13755:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,355 13755 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,355 | ^~~~~~~~ 2025-09-08T14:56:10,358 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetAngularDamping(PyObject*, PyObject*)’: 2025-09-08T14:56:10,359 Box2D/Box2D_wrap.cpp:13774:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,359 13774 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,359 | ^~ 2025-09-08T14:56:10,359 Box2D/Box2D_wrap.cpp:13774:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,359 13774 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,359 | ^~~~~~~~ 2025-09-08T14:56:10,362 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetGravityScale(PyObject*, PyObject*)’: 2025-09-08T14:56:10,362 Box2D/Box2D_wrap.cpp:13793:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,362 13793 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,363 | ^~ 2025-09-08T14:56:10,363 Box2D/Box2D_wrap.cpp:13793:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,363 13793 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,363 | ^~~~~~~~ 2025-09-08T14:56:10,368 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetType(PyObject*, PyObject*)’: 2025-09-08T14:56:10,368 Box2D/Box2D_wrap.cpp:13821:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,368 13821 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,368 | ^~ 2025-09-08T14:56:10,368 Box2D/Box2D_wrap.cpp:13821:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,368 13821 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,368 | ^~~~~~~~ 2025-09-08T14:56:10,372 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___IsBullet(PyObject*, PyObject*)’: 2025-09-08T14:56:10,372 Box2D/Box2D_wrap.cpp:13839:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,372 13839 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,372 | ^~ 2025-09-08T14:56:10,372 Box2D/Box2D_wrap.cpp:13839:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,372 13839 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,372 | ^~~~~~~~ 2025-09-08T14:56:10,376 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___IsSleepingAllowed(PyObject*, PyObject*)’: 2025-09-08T14:56:10,376 Box2D/Box2D_wrap.cpp:13858:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,376 13858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,376 | ^~ 2025-09-08T14:56:10,376 Box2D/Box2D_wrap.cpp:13858:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,376 13858 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,376 | ^~~~~~~~ 2025-09-08T14:56:10,380 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___IsAwake(PyObject*, PyObject*)’: 2025-09-08T14:56:10,380 Box2D/Box2D_wrap.cpp:13876:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,380 13876 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,380 | ^~ 2025-09-08T14:56:10,381 Box2D/Box2D_wrap.cpp:13876:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,381 13876 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,381 | ^~~~~~~~ 2025-09-08T14:56:10,383 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___IsActive(PyObject*, PyObject*)’: 2025-09-08T14:56:10,384 Box2D/Box2D_wrap.cpp:13894:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,384 13894 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,384 | ^~ 2025-09-08T14:56:10,384 Box2D/Box2D_wrap.cpp:13894:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,384 13894 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,384 | ^~~~~~~~ 2025-09-08T14:56:10,386 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___IsFixedRotation(PyObject*, PyObject*)’: 2025-09-08T14:56:10,387 Box2D/Box2D_wrap.cpp:13912:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,387 13912 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,387 | ^~ 2025-09-08T14:56:10,387 Box2D/Box2D_wrap.cpp:13912:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,387 13912 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,387 | ^~~~~~~~ 2025-09-08T14:56:10,388 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,388 Box2D/Box2D_wrap.cpp:13920:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,388 13920 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,388 | ^~ 2025-09-08T14:56:10,388 Box2D/Box2D_wrap.cpp:13920:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,389 13920 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,389 | ^~~~ 2025-09-08T14:56:10,390 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,390 Box2D/Box2D_wrap.cpp:13928:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,390 13928 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,390 | ^~ 2025-09-08T14:56:10,390 Box2D/Box2D_wrap.cpp:13928:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,390 13928 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,390 | ^~~~ 2025-09-08T14:56:10,391 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetFixtureList_internal(PyObject*, PyObject*)’: 2025-09-08T14:56:10,392 Box2D/Box2D_wrap.cpp:13936:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,392 13936 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetFixtureList_internal", 0, 1, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,392 | ^~ 2025-09-08T14:56:10,392 Box2D/Box2D_wrap.cpp:13936:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,392 13936 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetFixtureList_internal", 0, 1, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,392 | ^~ 2025-09-08T14:56:10,392 Box2D/Box2D_wrap.cpp:13938:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,392 13938 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,392 | ^~ 2025-09-08T14:56:10,395 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,395 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,395 | ^~~~ 2025-09-08T14:56:10,395 Box2D/Box2D_wrap.cpp:13938:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,395 13938 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,395 | ^~~~~~~~~ 2025-09-08T14:56:10,396 Box2D/Box2D_wrap.cpp:13940:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,396 13940 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,396 | ^~ 2025-09-08T14:56:10,398 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,398 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,398 | ^~~~ 2025-09-08T14:56:10,399 Box2D/Box2D_wrap.cpp:13940:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,399 13940 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,399 | ^~~~~~~~~ 2025-09-08T14:56:10,399 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,399 Box2D/Box2D_wrap.cpp:13945:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,399 13945 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,399 | ^~ 2025-09-08T14:56:10,400 Box2D/Box2D_wrap.cpp:13945:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,400 13945 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,400 | ^~~~ 2025-09-08T14:56:10,401 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,401 Box2D/Box2D_wrap.cpp:13954:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,401 13954 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,401 | ^~ 2025-09-08T14:56:10,401 Box2D/Box2D_wrap.cpp:13954:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,402 13954 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,402 | ^~~~ 2025-09-08T14:56:10,403 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetJointList_internal(PyObject*, PyObject*)’: 2025-09-08T14:56:10,403 Box2D/Box2D_wrap.cpp:13963:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,403 13963 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,403 | ^~ 2025-09-08T14:56:10,403 Box2D/Box2D_wrap.cpp:13963:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,403 13963 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,404 | ^~ 2025-09-08T14:56:10,404 Box2D/Box2D_wrap.cpp:13965:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,404 13965 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,404 | ^~ 2025-09-08T14:56:10,406 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,407 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,407 | ^~~~ 2025-09-08T14:56:10,407 Box2D/Box2D_wrap.cpp:13965:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,407 13965 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,407 | ^~~~~~~~~ 2025-09-08T14:56:10,407 Box2D/Box2D_wrap.cpp:13967:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,407 13967 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,407 | ^~ 2025-09-08T14:56:10,410 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,410 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,410 | ^~~~ 2025-09-08T14:56:10,410 Box2D/Box2D_wrap.cpp:13967:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,410 13967 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,410 | ^~~~~~~~~ 2025-09-08T14:56:10,413 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetContactList_internal(PyObject*, PyObject*)’: 2025-09-08T14:56:10,413 Box2D/Box2D_wrap.cpp:13990:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,413 13990 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,414 | ^~ 2025-09-08T14:56:10,414 Box2D/Box2D_wrap.cpp:13990:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,414 13990 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,414 | ^~ 2025-09-08T14:56:10,414 Box2D/Box2D_wrap.cpp:13992:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,414 13992 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,414 | ^~ 2025-09-08T14:56:10,417 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,417 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,417 | ^~~~ 2025-09-08T14:56:10,417 Box2D/Box2D_wrap.cpp:13992:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,417 13992 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,418 | ^~~~~~~~~ 2025-09-08T14:56:10,418 Box2D/Box2D_wrap.cpp:13994:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,418 13994 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,418 | ^~ 2025-09-08T14:56:10,421 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,421 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,421 | ^~~~ 2025-09-08T14:56:10,421 Box2D/Box2D_wrap.cpp:13994:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,421 13994 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,421 | ^~~~~~~~~ 2025-09-08T14:56:10,422 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,422 Box2D/Box2D_wrap.cpp:13999:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,422 13999 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,422 | ^~ 2025-09-08T14:56:10,422 Box2D/Box2D_wrap.cpp:13999:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,422 13999 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,422 | ^~~~ 2025-09-08T14:56:10,424 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,424 Box2D/Box2D_wrap.cpp:14007:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,424 14007 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,424 | ^~ 2025-09-08T14:56:10,424 Box2D/Box2D_wrap.cpp:14007:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,424 14007 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,424 | ^~~~ 2025-09-08T14:56:10,426 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetNext(PyObject*, PyObject*)’: 2025-09-08T14:56:10,426 Box2D/Box2D_wrap.cpp:14014:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,426 14014 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,426 | ^~ 2025-09-08T14:56:10,426 Box2D/Box2D_wrap.cpp:14014:91: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,426 14014 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,426 | ^~ 2025-09-08T14:56:10,427 Box2D/Box2D_wrap.cpp:14016:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,427 14016 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,427 | ^~ 2025-09-08T14:56:10,430 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,430 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,430 | ^~~~ 2025-09-08T14:56:10,430 Box2D/Box2D_wrap.cpp:14016:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,430 14016 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,430 | ^~~~~~~~~ 2025-09-08T14:56:10,430 Box2D/Box2D_wrap.cpp:14018:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,430 14018 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,430 | ^~ 2025-09-08T14:56:10,433 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,433 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,434 | ^~~~ 2025-09-08T14:56:10,434 Box2D/Box2D_wrap.cpp:14018:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,434 14018 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,434 | ^~~~~~~~~ 2025-09-08T14:56:10,434 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,434 Box2D/Box2D_wrap.cpp:14023:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,435 14023 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,435 | ^~ 2025-09-08T14:56:10,435 Box2D/Box2D_wrap.cpp:14023:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,435 14023 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,435 | ^~~~ 2025-09-08T14:56:10,436 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,437 Box2D/Box2D_wrap.cpp:14031:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,437 14031 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,437 | ^~ 2025-09-08T14:56:10,437 Box2D/Box2D_wrap.cpp:14031:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,437 14031 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,437 | ^~~~ 2025-09-08T14:56:10,439 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetWorld(PyObject*, PyObject*)’: 2025-09-08T14:56:10,439 Box2D/Box2D_wrap.cpp:14038:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,439 14038 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetWorld", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,439 | ^~ 2025-09-08T14:56:10,439 Box2D/Box2D_wrap.cpp:14038:92: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,439 14038 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___GetWorld", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,439 | ^~ 2025-09-08T14:56:10,440 Box2D/Box2D_wrap.cpp:14040:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,440 14040 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,440 | ^~ 2025-09-08T14:56:10,443 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,443 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,443 | ^~~~ 2025-09-08T14:56:10,443 Box2D/Box2D_wrap.cpp:14040:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,443 14040 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,443 | ^~~~~~~~~ 2025-09-08T14:56:10,443 Box2D/Box2D_wrap.cpp:14042:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,444 14042 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,444 | ^~ 2025-09-08T14:56:10,447 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,447 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,447 | ^~~~ 2025-09-08T14:56:10,447 Box2D/Box2D_wrap.cpp:14042:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,447 14042 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,447 | ^~~~~~~~~ 2025-09-08T14:56:10,449 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,449 Box2D/Box2D_wrap.cpp:14053:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,449 14053 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,449 | ^~ 2025-09-08T14:56:10,449 Box2D/Box2D_wrap.cpp:14053:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,449 14053 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,450 | ^~~~~~~~ 2025-09-08T14:56:10,454 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___CreateFixture(PyObject*, PyObject*)’: 2025-09-08T14:56:10,454 Box2D/Box2D_wrap.cpp:14082:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,455 14082 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___CreateFixture", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:10,455 | ^~ 2025-09-08T14:56:10,455 Box2D/Box2D_wrap.cpp:14082:97: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,455 14082 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Body___CreateFixture", 0, 3, argv))) SWIG_fail; --argc; if (argc == 2) { 2025-09-08T14:56:10,455 | ^~ 2025-09-08T14:56:10,456 Box2D/Box2D_wrap.cpp:14084:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,456 14084 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:10,456 | ^~ 2025-09-08T14:56:10,459 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,459 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,459 | ^~~~ 2025-09-08T14:56:10,459 Box2D/Box2D_wrap.cpp:14084:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,459 14084 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 3) { 2025-09-08T14:56:10,459 | ^~~~~~~~~ 2025-09-08T14:56:10,460 Box2D/Box2D_wrap.cpp:14086:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,460 14086 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,460 | ^~ 2025-09-08T14:56:10,463 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,463 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,463 | ^~~~ 2025-09-08T14:56:10,463 Box2D/Box2D_wrap.cpp:14086:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,463 14086 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,463 | ^~~~~~~~~ 2025-09-08T14:56:10,464 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Body___GetUserData(PyObject*, PyObject*)’: 2025-09-08T14:56:10,464 Box2D/Box2D_wrap.cpp:14092:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,464 14092 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,464 | ^~ 2025-09-08T14:56:10,465 Box2D/Box2D_wrap.cpp:14092:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,465 14092 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Body, 0 | 0 ); 2025-09-08T14:56:10,465 | ^~~~~~~~ 2025-09-08T14:56:10,471 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Filter_categoryBits_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,472 Box2D/Box2D_wrap.cpp:14138:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,472 14138 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2025-09-08T14:56:10,472 | ^~ 2025-09-08T14:56:10,472 Box2D/Box2D_wrap.cpp:14138:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,472 14138 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2025-09-08T14:56:10,472 | ^~~~~~~~ 2025-09-08T14:56:10,475 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Filter_maskBits_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,475 Box2D/Box2D_wrap.cpp:14155:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,475 14155 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2025-09-08T14:56:10,475 | ^~ 2025-09-08T14:56:10,475 Box2D/Box2D_wrap.cpp:14155:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,475 14155 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2025-09-08T14:56:10,475 | ^~~~~~~~ 2025-09-08T14:56:10,477 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Filter_groupIndex_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,477 Box2D/Box2D_wrap.cpp:14171:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,477 14171 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2025-09-08T14:56:10,477 | ^~ 2025-09-08T14:56:10,478 Box2D/Box2D_wrap.cpp:14171:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,478 14171 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2025-09-08T14:56:10,478 | ^~~~~~~~ 2025-09-08T14:56:10,478 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Filter___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,478 Box2D/Box2D_wrap.cpp:14178:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,479 14178 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2025-09-08T14:56:10,479 | ^~ 2025-09-08T14:56:10,479 Box2D/Box2D_wrap.cpp:14178:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,479 14178 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Filter, 0 | 0 ); 2025-09-08T14:56:10,479 | ^~~~~~~~ 2025-09-08T14:56:10,486 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_friction_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,487 Box2D/Box2D_wrap.cpp:14243:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,487 14243 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,487 | ^~ 2025-09-08T14:56:10,487 Box2D/Box2D_wrap.cpp:14243:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,487 14243 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,487 | ^~~~~~~~ 2025-09-08T14:56:10,489 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_restitution_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,490 Box2D/Box2D_wrap.cpp:14260:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,490 14260 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,490 | ^~ 2025-09-08T14:56:10,490 Box2D/Box2D_wrap.cpp:14260:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,490 14260 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,490 | ^~~~~~~~ 2025-09-08T14:56:10,492 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_density_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,493 Box2D/Box2D_wrap.cpp:14276:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,493 14276 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,493 | ^~ 2025-09-08T14:56:10,493 Box2D/Box2D_wrap.cpp:14276:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,493 14276 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,493 | ^~~~~~~~ 2025-09-08T14:56:10,495 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_isSensor_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,496 Box2D/Box2D_wrap.cpp:14293:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,496 14293 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,496 | ^~ 2025-09-08T14:56:10,496 Box2D/Box2D_wrap.cpp:14293:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,496 14293 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,496 | ^~~~~~~~ 2025-09-08T14:56:10,500 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,500 Box2D/Box2D_wrap.cpp:14318:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,500 14318 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,500 | ^~ 2025-09-08T14:56:10,500 Box2D/Box2D_wrap.cpp:14318:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,500 14318 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,500 | ^~~~~~~~ 2025-09-08T14:56:10,504 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2FixtureDef_ClearUserData(PyObject*, PyObject*)’: 2025-09-08T14:56:10,504 Box2D/Box2D_wrap.cpp:14343:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,504 14343 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,504 | ^~ 2025-09-08T14:56:10,505 Box2D/Box2D_wrap.cpp:14343:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,505 14343 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2FixtureDef, 0 | 0 ); 2025-09-08T14:56:10,505 | ^~~~~~~~ 2025-09-08T14:56:10,506 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2FixtureDef(PyObject*, PyObject*)’: 2025-09-08T14:56:10,506 Box2D/Box2D_wrap.cpp:14350:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,507 14350 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,507 | ^~ 2025-09-08T14:56:10,507 Box2D/Box2D_wrap.cpp:14350:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,507 14350 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,507 | ^~~~~~~~ 2025-09-08T14:56:10,520 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2FixtureProxy(PyObject*, PyObject*)’: 2025-09-08T14:56:10,520 Box2D/Box2D_wrap.cpp:14452:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,520 14452 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,520 | ^~ 2025-09-08T14:56:10,520 Box2D/Box2D_wrap.cpp:14452:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,520 14452 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,520 | ^~~~~~~~ 2025-09-08T14:56:10,522 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetType(PyObject*, PyObject*)’: 2025-09-08T14:56:10,522 Box2D/Box2D_wrap.cpp:14470:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,522 14470 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,522 | ^~ 2025-09-08T14:56:10,522 Box2D/Box2D_wrap.cpp:14470:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,522 14470 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,522 | ^~~~~~~~ 2025-09-08T14:56:10,527 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetShape(PyObject*, PyObject*)’: 2025-09-08T14:56:10,527 Box2D/Box2D_wrap.cpp:14504:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,527 14504 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetShape", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,527 | ^~ 2025-09-08T14:56:10,528 Box2D/Box2D_wrap.cpp:14504:95: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,528 14504 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetShape", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,528 | ^~ 2025-09-08T14:56:10,528 Box2D/Box2D_wrap.cpp:14506:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,528 14506 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,528 | ^~ 2025-09-08T14:56:10,531 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,531 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,531 | ^~~~ 2025-09-08T14:56:10,531 Box2D/Box2D_wrap.cpp:14506:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,531 14506 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,531 | ^~~~~~~~~ 2025-09-08T14:56:10,531 Box2D/Box2D_wrap.cpp:14508:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,532 14508 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,532 | ^~ 2025-09-08T14:56:10,534 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,535 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,535 | ^~~~ 2025-09-08T14:56:10,535 Box2D/Box2D_wrap.cpp:14508:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,535 14508 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,535 | ^~~~~~~~~ 2025-09-08T14:56:10,537 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___IsSensor(PyObject*, PyObject*)’: 2025-09-08T14:56:10,537 Box2D/Box2D_wrap.cpp:14523:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,537 14523 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,537 | ^~ 2025-09-08T14:56:10,537 Box2D/Box2D_wrap.cpp:14523:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,538 14523 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,538 | ^~~~~~~~ 2025-09-08T14:56:10,543 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,543 Box2D/Box2D_wrap.cpp:14560:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,543 14560 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,543 | ^~ 2025-09-08T14:56:10,543 Box2D/Box2D_wrap.cpp:14560:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,544 14560 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,544 | ^~~~ 2025-09-08T14:56:10,545 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,545 Box2D/Box2D_wrap.cpp:14568:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,545 14568 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,545 | ^~ 2025-09-08T14:56:10,545 Box2D/Box2D_wrap.cpp:14568:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,546 14568 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,546 | ^~~~ 2025-09-08T14:56:10,547 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetBody(PyObject*, PyObject*)’: 2025-09-08T14:56:10,547 Box2D/Box2D_wrap.cpp:14575:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,547 14575 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetBody", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,548 | ^~ 2025-09-08T14:56:10,548 Box2D/Box2D_wrap.cpp:14575:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,548 14575 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetBody", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,548 | ^~ 2025-09-08T14:56:10,548 Box2D/Box2D_wrap.cpp:14577:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,548 14577 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,548 | ^~ 2025-09-08T14:56:10,551 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,552 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,552 | ^~~~ 2025-09-08T14:56:10,552 Box2D/Box2D_wrap.cpp:14577:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,552 14577 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,552 | ^~~~~~~~~ 2025-09-08T14:56:10,552 Box2D/Box2D_wrap.cpp:14579:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,552 14579 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,552 | ^~ 2025-09-08T14:56:10,555 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,556 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,556 | ^~~~ 2025-09-08T14:56:10,556 Box2D/Box2D_wrap.cpp:14579:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,556 14579 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,556 | ^~~~~~~~~ 2025-09-08T14:56:10,559 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetNext(PyObject*, PyObject*)’: 2025-09-08T14:56:10,559 Box2D/Box2D_wrap.cpp:14599:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,559 14599 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,559 | ^~ 2025-09-08T14:56:10,560 Box2D/Box2D_wrap.cpp:14599:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,560 14599 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Fixture___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,560 | ^~ 2025-09-08T14:56:10,560 Box2D/Box2D_wrap.cpp:14601:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,560 14601 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,560 | ^~ 2025-09-08T14:56:10,564 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,564 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,564 | ^~~~ 2025-09-08T14:56:10,564 Box2D/Box2D_wrap.cpp:14601:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,564 14601 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,564 | ^~~~~~~~~ 2025-09-08T14:56:10,564 Box2D/Box2D_wrap.cpp:14603:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,564 14603 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,564 | ^~ 2025-09-08T14:56:10,567 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,568 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,568 | ^~~~ 2025-09-08T14:56:10,568 Box2D/Box2D_wrap.cpp:14603:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,568 14603 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,568 | ^~~~~~~~~ 2025-09-08T14:56:10,578 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetDensity(PyObject*, PyObject*)’: 2025-09-08T14:56:10,578 Box2D/Box2D_wrap.cpp:14670:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,578 14670 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,578 | ^~ 2025-09-08T14:56:10,579 Box2D/Box2D_wrap.cpp:14670:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,579 14670 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,579 | ^~~~~~~~ 2025-09-08T14:56:10,581 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetFriction(PyObject*, PyObject*)’: 2025-09-08T14:56:10,581 Box2D/Box2D_wrap.cpp:14678:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,581 14678 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,581 | ^~ 2025-09-08T14:56:10,581 Box2D/Box2D_wrap.cpp:14678:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,581 14678 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,582 | ^~~~~~~~ 2025-09-08T14:56:10,584 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___GetRestitution(PyObject*, PyObject*)’: 2025-09-08T14:56:10,584 Box2D/Box2D_wrap.cpp:14696:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,585 14696 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,585 | ^~ 2025-09-08T14:56:10,585 Box2D/Box2D_wrap.cpp:14696:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,585 14696 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,585 | ^~~~~~~~ 2025-09-08T14:56:10,591 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Fixture___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,591 Box2D/Box2D_wrap.cpp:14737:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,591 14737 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,591 | ^~ 2025-09-08T14:56:10,591 Box2D/Box2D_wrap.cpp:14737:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,591 14737 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Fixture, 0 | 0 ); 2025-09-08T14:56:10,591 | ^~~~~~~~ 2025-09-08T14:56:10,602 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2DestructionListener_SayGoodbye(PyObject*, PyObject*)’: 2025-09-08T14:56:10,602 Box2D/Box2D_wrap.cpp:14818:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,602 14818 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2DestructionListener_SayGoodbye", 0, 2, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,602 | ^~ 2025-09-08T14:56:10,602 Box2D/Box2D_wrap.cpp:14818:107: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,602 14818 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2DestructionListener_SayGoodbye", 0, 2, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,602 | ^~ 2025-09-08T14:56:10,603 Box2D/Box2D_wrap.cpp:14823:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,603 14823 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,603 | ^~ 2025-09-08T14:56:10,606 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,607 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,607 | ^~~~ 2025-09-08T14:56:10,607 Box2D/Box2D_wrap.cpp:14823:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,607 14823 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,607 | ^~~~~~~~~ 2025-09-08T14:56:10,609 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2DestructionListener(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,609 Box2D/Box2D_wrap.cpp:14838:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,609 14838 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DestructionListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,609 | ^~ 2025-09-08T14:56:10,609 Box2D/Box2D_wrap.cpp:14838:109: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,609 14838 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2DestructionListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,610 | ^~~~ 2025-09-08T14:56:10,613 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactFilter(PyObject*, PyObject*)’: 2025-09-08T14:56:10,613 Box2D/Box2D_wrap.cpp:14865:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,613 14865 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,613 | ^~ 2025-09-08T14:56:10,613 Box2D/Box2D_wrap.cpp:14865:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,613 14865 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,613 | ^~~~~~~~ 2025-09-08T14:56:10,619 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2ContactFilter(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,619 Box2D/Box2D_wrap.cpp:14902:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,619 14902 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactFilter", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,619 | ^~ 2025-09-08T14:56:10,619 Box2D/Box2D_wrap.cpp:14902:103: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,619 14902 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactFilter", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,620 | ^~~~ 2025-09-08T14:56:10,628 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactImpulse(PyObject*, PyObject*)’: 2025-09-08T14:56:10,629 Box2D/Box2D_wrap.cpp:14976:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,629 14976 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,629 | ^~ 2025-09-08T14:56:10,629 Box2D/Box2D_wrap.cpp:14976:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,629 14976 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,629 | ^~~~~~~~ 2025-09-08T14:56:10,630 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactListener(PyObject*, PyObject*)’: 2025-09-08T14:56:10,631 Box2D/Box2D_wrap.cpp:14994:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,631 14994 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,631 | ^~ 2025-09-08T14:56:10,631 Box2D/Box2D_wrap.cpp:14994:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,631 14994 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,631 | ^~~~~~~~ 2025-09-08T14:56:10,643 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2ContactListener(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,643 Box2D/Box2D_wrap.cpp:15085:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,643 15085 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,643 | ^~ 2025-09-08T14:56:10,643 Box2D/Box2D_wrap.cpp:15085:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,644 15085 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2ContactListener", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,644 | ^~~~ 2025-09-08T14:56:10,647 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2QueryCallback(PyObject*, PyObject*)’: 2025-09-08T14:56:10,647 Box2D/Box2D_wrap.cpp:15112:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,647 15112 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,647 | ^~ 2025-09-08T14:56:10,647 Box2D/Box2D_wrap.cpp:15112:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,647 15112 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,647 | ^~~~~~~~ 2025-09-08T14:56:10,652 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2QueryCallback(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,652 Box2D/Box2D_wrap.cpp:15144:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,652 15144 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2QueryCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,653 | ^~ 2025-09-08T14:56:10,653 Box2D/Box2D_wrap.cpp:15144:103: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,653 15144 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2QueryCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,653 | ^~~~ 2025-09-08T14:56:10,656 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RayCastCallback(PyObject*, PyObject*)’: 2025-09-08T14:56:10,656 Box2D/Box2D_wrap.cpp:15171:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,657 15171 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,657 | ^~ 2025-09-08T14:56:10,657 Box2D/Box2D_wrap.cpp:15171:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,657 15171 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,657 | ^~~~~~~~ 2025-09-08T14:56:10,665 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2RayCastCallback(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,665 Box2D/Box2D_wrap.cpp:15225:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,666 15225 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2RayCastCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,666 | ^~ 2025-09-08T14:56:10,666 Box2D/Box2D_wrap.cpp:15225:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,666 15225 | if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O:new_b2RayCastCallback", kwnames, &obj0)) SWIG_fail; arg1 = obj0; { try { 2025-09-08T14:56:10,666 | ^~~~ 2025-09-08T14:56:10,670 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_step_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,670 Box2D/Box2D_wrap.cpp:15261:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,670 15261 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,670 | ^~ 2025-09-08T14:56:10,670 Box2D/Box2D_wrap.cpp:15261:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,670 15261 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,670 | ^~~~~~~~ 2025-09-08T14:56:10,672 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_collide_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,672 Box2D/Box2D_wrap.cpp:15277:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,673 15277 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,673 | ^~ 2025-09-08T14:56:10,673 Box2D/Box2D_wrap.cpp:15277:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,673 15277 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,673 | ^~~~~~~~ 2025-09-08T14:56:10,680 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solve_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,680 Box2D/Box2D_wrap.cpp:15293:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,680 15293 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,681 | ^~ 2025-09-08T14:56:10,681 Box2D/Box2D_wrap.cpp:15293:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,681 15293 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,681 | ^~~~~~~~ 2025-09-08T14:56:10,683 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveInit_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,683 Box2D/Box2D_wrap.cpp:15309:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,683 15309 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,683 | ^~ 2025-09-08T14:56:10,683 Box2D/Box2D_wrap.cpp:15309:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,684 15309 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,684 | ^~~~~~~~ 2025-09-08T14:56:10,686 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveVelocity_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,686 Box2D/Box2D_wrap.cpp:15326:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,686 15326 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,686 | ^~ 2025-09-08T14:56:10,686 Box2D/Box2D_wrap.cpp:15326:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,686 15326 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,687 | ^~~~~~~~ 2025-09-08T14:56:10,689 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solvePosition_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,689 Box2D/Box2D_wrap.cpp:15343:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,689 15343 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,689 | ^~ 2025-09-08T14:56:10,689 Box2D/Box2D_wrap.cpp:15343:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,690 15343 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,690 | ^~~~~~~~ 2025-09-08T14:56:10,692 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_broadphase_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,692 Box2D/Box2D_wrap.cpp:15359:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,692 15359 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,692 | ^~ 2025-09-08T14:56:10,692 Box2D/Box2D_wrap.cpp:15359:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,693 15359 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,693 | ^~~~~~~~ 2025-09-08T14:56:10,695 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Profile_solveTOI_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,695 Box2D/Box2D_wrap.cpp:15375:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,695 15375 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,695 | ^~ 2025-09-08T14:56:10,696 Box2D/Box2D_wrap.cpp:15375:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,696 15375 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Profile, 0 | 0 ); 2025-09-08T14:56:10,696 | ^~~~~~~~ 2025-09-08T14:56:10,707 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2SolverData(PyObject*, PyObject*)’: 2025-09-08T14:56:10,708 Box2D/Box2D_wrap.cpp:15464:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,708 15464 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,708 | ^~ 2025-09-08T14:56:10,708 Box2D/Box2D_wrap.cpp:15464:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,708 15464 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,708 | ^~~~~~~~ 2025-09-08T14:56:10,713 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager_FindNewContacts(PyObject*, PyObject*)’: 2025-09-08T14:56:10,713 Box2D/Box2D_wrap.cpp:15506:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,713 15506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2025-09-08T14:56:10,713 | ^~ 2025-09-08T14:56:10,714 Box2D/Box2D_wrap.cpp:15506:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,714 15506 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2025-09-08T14:56:10,714 | ^~~~~~~~ 2025-09-08T14:56:10,716 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactManager_Collide(PyObject*, PyObject*)’: 2025-09-08T14:56:10,716 Box2D/Box2D_wrap.cpp:15525:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,716 15525 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2025-09-08T14:56:10,716 | ^~ 2025-09-08T14:56:10,717 Box2D/Box2D_wrap.cpp:15525:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,717 15525 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactManager, 0 | 0 ); 2025-09-08T14:56:10,717 | ^~~~~~~~ 2025-09-08T14:56:10,733 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactManager(PyObject*, PyObject*)’: 2025-09-08T14:56:10,733 Box2D/Box2D_wrap.cpp:15653:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,733 15653 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,733 | ^~ 2025-09-08T14:56:10,733 Box2D/Box2D_wrap.cpp:15653:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,733 15653 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,733 | ^~~~~~~~ 2025-09-08T14:56:10,748 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_Step(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,749 Box2D/Box2D_wrap.cpp:15755:92: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2025-09-08T14:56:10,749 15755 | arg4 = static_cast< int32 >(val4); { try { (arg1)->Step(arg2,arg3,arg4); } catch (Swig::DirectorException) { SWIG_fail; } 2025-09-08T14:56:10,749 | ^~~~~~~~~~~~~~~~~ 2025-09-08T14:56:10,751 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DrawDebugData(PyObject*, PyObject*)’: 2025-09-08T14:56:10,751 Box2D/Box2D_wrap.cpp:15767:98: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2025-09-08T14:56:10,752 15767 | arg1 = reinterpret_cast< b2World * >(argp1); { try { (arg1)->DrawDebugData(); } catch (Swig::DirectorException) { 2025-09-08T14:56:10,752 | ^~~~~~~~~~~~~~~~~ 2025-09-08T14:56:10,754 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_QueryAABB(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,754 Box2D/Box2D_wrap.cpp:15786:18: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2025-09-08T14:56:10,754 15786 | catch (Swig::DirectorException) { SWIG_fail; } catch (b2AssertException) { SWIG_fail; } } resultobj = SWIG_Py_Void(); 2025-09-08T14:56:10,754 | ^~~~~~~~~~~~~~~~~ 2025-09-08T14:56:10,759 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_RayCast(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,759 Box2D/Box2D_wrap.cpp:15816:107: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2025-09-08T14:56:10,759 15816 | ((b2World const *)arg1)->RayCast(arg2,(b2Vec2 const &)*arg3,(b2Vec2 const &)*arg4); } catch (Swig::DirectorException) { 2025-09-08T14:56:10,759 | ^~~~~~~~~~~~~~~~~ 2025-09-08T14:56:10,760 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,760 Box2D/Box2D_wrap.cpp:15821:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,761 15821 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,761 | ^~ 2025-09-08T14:56:10,761 Box2D/Box2D_wrap.cpp:15821:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,761 15821 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,761 | ^~~~ 2025-09-08T14:56:10,762 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,762 Box2D/Box2D_wrap.cpp:15829:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,762 15829 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,763 | ^~ 2025-09-08T14:56:10,763 Box2D/Box2D_wrap.cpp:15829:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,763 15829 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,763 | ^~~~ 2025-09-08T14:56:10,764 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyList_internal(PyObject*, PyObject*)’: 2025-09-08T14:56:10,764 Box2D/Box2D_wrap.cpp:15837:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,764 15837 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetBodyList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,765 | ^~ 2025-09-08T14:56:10,765 Box2D/Box2D_wrap.cpp:15837:105: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,765 15837 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetBodyList_internal", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,765 | ^~ 2025-09-08T14:56:10,765 Box2D/Box2D_wrap.cpp:15839:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,765 15839 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,765 | ^~ 2025-09-08T14:56:10,768 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,768 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,769 | ^~~~ 2025-09-08T14:56:10,769 Box2D/Box2D_wrap.cpp:15839:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,769 15839 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,769 | ^~~~~~~~~ 2025-09-08T14:56:10,769 Box2D/Box2D_wrap.cpp:15841:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,769 15841 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,769 | ^~ 2025-09-08T14:56:10,772 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,772 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,772 | ^~~~ 2025-09-08T14:56:10,772 Box2D/Box2D_wrap.cpp:15841:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,773 15841 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,773 | ^~~~~~~~~ 2025-09-08T14:56:10,773 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,773 Box2D/Box2D_wrap.cpp:15846:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,773 15846 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,773 | ^~ 2025-09-08T14:56:10,773 Box2D/Box2D_wrap.cpp:15846:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,774 15846 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,774 | ^~~~ 2025-09-08T14:56:10,776 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,777 Box2D/Box2D_wrap.cpp:15867:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,777 15867 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,777 | ^~ 2025-09-08T14:56:10,777 Box2D/Box2D_wrap.cpp:15867:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,777 15867 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,777 | ^~~~ 2025-09-08T14:56:10,780 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointList_internal(PyObject*, PyObject*)’: 2025-09-08T14:56:10,780 Box2D/Box2D_wrap.cpp:15888:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,780 15888 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,780 | ^~ 2025-09-08T14:56:10,780 Box2D/Box2D_wrap.cpp:15888:106: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,780 15888 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetJointList_internal", 0, 1, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,780 | ^~ 2025-09-08T14:56:10,781 Box2D/Box2D_wrap.cpp:15890:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,781 15890 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,781 | ^~ 2025-09-08T14:56:10,784 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,784 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,784 | ^~~~ 2025-09-08T14:56:10,785 Box2D/Box2D_wrap.cpp:15890:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,785 15890 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,785 | ^~~~~~~~~ 2025-09-08T14:56:10,785 Box2D/Box2D_wrap.cpp:15892:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,785 15892 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,785 | ^~ 2025-09-08T14:56:10,788 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,788 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,789 | ^~~~ 2025-09-08T14:56:10,789 Box2D/Box2D_wrap.cpp:15892:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,789 15892 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,789 | ^~~~~~~~~ 2025-09-08T14:56:10,789 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,790 Box2D/Box2D_wrap.cpp:15897:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,790 15897 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,790 | ^~ 2025-09-08T14:56:10,790 Box2D/Box2D_wrap.cpp:15897:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,790 15897 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,790 | ^~~~ 2025-09-08T14:56:10,792 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:10,792 Box2D/Box2D_wrap.cpp:15905:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,792 15905 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,792 | ^~ 2025-09-08T14:56:10,792 Box2D/Box2D_wrap.cpp:15905:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,792 15905 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,792 | ^~~~ 2025-09-08T14:56:10,794 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactList_internal(PyObject*, PyObject*)’: 2025-09-08T14:56:10,794 Box2D/Box2D_wrap.cpp:15913:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,794 15913 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,794 | ^~ 2025-09-08T14:56:10,794 Box2D/Box2D_wrap.cpp:15913:108: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,794 15913 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2World___GetContactList_internal", 0, 1, argv))) SWIG_fail; --argc; 2025-09-08T14:56:10,795 | ^~ 2025-09-08T14:56:10,795 Box2D/Box2D_wrap.cpp:15915:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,795 15915 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,795 | ^~ 2025-09-08T14:56:10,798 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,799 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,799 | ^~~~ 2025-09-08T14:56:10,799 Box2D/Box2D_wrap.cpp:15915:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,799 15915 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,799 | ^~~~~~~~~ 2025-09-08T14:56:10,799 Box2D/Box2D_wrap.cpp:15917:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,799 15917 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,799 | ^~ 2025-09-08T14:56:10,803 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,803 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,803 | ^~~~ 2025-09-08T14:56:10,803 Box2D/Box2D_wrap.cpp:15917:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,803 15917 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,803 | ^~~~~~~~~ 2025-09-08T14:56:10,806 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_GetAllowSleeping(PyObject*, PyObject*)’: 2025-09-08T14:56:10,806 Box2D/Box2D_wrap.cpp:15932:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,806 15932 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,806 | ^~ 2025-09-08T14:56:10,806 Box2D/Box2D_wrap.cpp:15932:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,806 15932 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,806 | ^~~~~~~~ 2025-09-08T14:56:10,809 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetWarmStarting(PyObject*, PyObject*)’: 2025-09-08T14:56:10,810 Box2D/Box2D_wrap.cpp:15950:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,810 15950 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,810 | ^~ 2025-09-08T14:56:10,810 Box2D/Box2D_wrap.cpp:15950:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,810 15950 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,810 | ^~~~~~~~ 2025-09-08T14:56:10,813 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContinuousPhysics(PyObject*, PyObject*)’: 2025-09-08T14:56:10,814 Box2D/Box2D_wrap.cpp:15969:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,814 15969 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,814 | ^~ 2025-09-08T14:56:10,814 Box2D/Box2D_wrap.cpp:15969:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,814 15969 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,814 | ^~~~~~~~ 2025-09-08T14:56:10,817 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetSubStepping(PyObject*, PyObject*)’: 2025-09-08T14:56:10,818 Box2D/Box2D_wrap.cpp:15987:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,818 15987 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,818 | ^~ 2025-09-08T14:56:10,818 Box2D/Box2D_wrap.cpp:15987:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,818 15987 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,818 | ^~~~~~~~ 2025-09-08T14:56:10,820 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetProxyCount(PyObject*, PyObject*)’: 2025-09-08T14:56:10,820 Box2D/Box2D_wrap.cpp:15995:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,820 15995 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,820 | ^~ 2025-09-08T14:56:10,821 Box2D/Box2D_wrap.cpp:15995:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,821 15995 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,821 | ^~~~~~~~ 2025-09-08T14:56:10,823 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetBodyCount(PyObject*, PyObject*)’: 2025-09-08T14:56:10,823 Box2D/Box2D_wrap.cpp:16003:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,823 16003 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,823 | ^~ 2025-09-08T14:56:10,823 Box2D/Box2D_wrap.cpp:16003:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,823 16003 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,823 | ^~~~~~~~ 2025-09-08T14:56:10,825 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetJointCount(PyObject*, PyObject*)’: 2025-09-08T14:56:10,825 Box2D/Box2D_wrap.cpp:16011:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,825 16011 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,825 | ^~ 2025-09-08T14:56:10,826 Box2D/Box2D_wrap.cpp:16011:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,826 16011 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,826 | ^~~~~~~~ 2025-09-08T14:56:10,827 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetContactCount(PyObject*, PyObject*)’: 2025-09-08T14:56:10,827 Box2D/Box2D_wrap.cpp:16019:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,827 16019 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,827 | ^~ 2025-09-08T14:56:10,828 Box2D/Box2D_wrap.cpp:16019:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,828 16019 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,828 | ^~~~~~~~ 2025-09-08T14:56:10,828 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_GetTreeHeight(PyObject*, PyObject*)’: 2025-09-08T14:56:10,829 Box2D/Box2D_wrap.cpp:16027:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,829 16027 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,829 | ^~ 2025-09-08T14:56:10,829 Box2D/Box2D_wrap.cpp:16027:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,829 16027 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,829 | ^~~~~~~~ 2025-09-08T14:56:10,830 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_GetTreeBalance(PyObject*, PyObject*)’: 2025-09-08T14:56:10,830 Box2D/Box2D_wrap.cpp:16035:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,830 16035 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,830 | ^~ 2025-09-08T14:56:10,830 Box2D/Box2D_wrap.cpp:16035:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,831 16035 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,831 | ^~~~~~~~ 2025-09-08T14:56:10,831 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_GetTreeQuality(PyObject*, PyObject*)’: 2025-09-08T14:56:10,832 Box2D/Box2D_wrap.cpp:16043:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,832 16043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,832 | ^~ 2025-09-08T14:56:10,832 Box2D/Box2D_wrap.cpp:16043:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,832 16043 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,832 | ^~~~~~~~ 2025-09-08T14:56:10,838 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___IsLocked(PyObject*, PyObject*)’: 2025-09-08T14:56:10,838 Box2D/Box2D_wrap.cpp:16077:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,838 16077 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,838 | ^~ 2025-09-08T14:56:10,838 Box2D/Box2D_wrap.cpp:16077:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,838 16077 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,838 | ^~~~~~~~ 2025-09-08T14:56:10,841 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___GetAutoClearForces(PyObject*, PyObject*)’: 2025-09-08T14:56:10,841 Box2D/Box2D_wrap.cpp:16096:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,841 16096 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,841 | ^~ 2025-09-08T14:56:10,841 Box2D/Box2D_wrap.cpp:16096:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,842 16096 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,842 | ^~~~~~~~ 2025-09-08T14:56:10,847 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_GetProfile(PyObject*, PyObject*)’: 2025-09-08T14:56:10,847 Box2D/Box2D_wrap.cpp:16131:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,847 16131 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,847 | ^~ 2025-09-08T14:56:10,847 Box2D/Box2D_wrap.cpp:16131:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,847 16131 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,847 | ^~~~~~~~ 2025-09-08T14:56:10,850 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,850 Box2D/Box2D_wrap.cpp:16145:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,850 16145 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,850 | ^~ 2025-09-08T14:56:10,850 Box2D/Box2D_wrap.cpp:16145:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,850 16145 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2World, 0 | 0 ); 2025-09-08T14:56:10,850 | ^~~~~~~~ 2025-09-08T14:56:10,858 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DestroyBody(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,858 Box2D/Box2D_wrap.cpp:16199:104: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2025-09-08T14:56:10,858 16199 | arg2 = reinterpret_cast< b2Body * >(argp2); { try { b2World_DestroyBody(arg1,arg2); } catch (Swig::DirectorException) { 2025-09-08T14:56:10,858 | ^~~~~~~~~~~~~~~~~ 2025-09-08T14:56:10,860 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2World_DestroyJoint(PyObject*, PyObject*, PyObject*)’: 2025-09-08T14:56:10,861 Box2D/Box2D_wrap.cpp:16211:106: warning: catching polymorphic type ‘class Swig::DirectorException’ by value [-Wcatch-value=] 2025-09-08T14:56:10,861 16211 | arg2 = reinterpret_cast< b2Joint * >(argp2); { try { b2World_DestroyJoint(arg1,arg2); } catch (Swig::DirectorException) { 2025-09-08T14:56:10,861 | ^~~~~~~~~~~~~~~~~ 2025-09-08T14:56:10,874 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2ContactEdge___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,874 Box2D/Box2D_wrap.cpp:16323:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,874 16323 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2025-09-08T14:56:10,874 | ^~ 2025-09-08T14:56:10,875 Box2D/Box2D_wrap.cpp:16323:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,875 16323 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2ContactEdge, 0 | 0 ); 2025-09-08T14:56:10,875 | ^~~~~~~~ 2025-09-08T14:56:10,876 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2ContactEdge(PyObject*, PyObject*)’: 2025-09-08T14:56:10,877 Box2D/Box2D_wrap.cpp:16337:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,877 16337 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,877 | ^~ 2025-09-08T14:56:10,877 Box2D/Box2D_wrap.cpp:16337:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,877 16337 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,877 | ^~~~~~~~ 2025-09-08T14:56:10,881 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetManifold(PyObject*, PyObject*)’: 2025-09-08T14:56:10,881 Box2D/Box2D_wrap.cpp:16370:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,881 16370 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetManifold", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,881 | ^~ 2025-09-08T14:56:10,881 Box2D/Box2D_wrap.cpp:16370:98: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,881 16370 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetManifold", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,882 | ^~ 2025-09-08T14:56:10,882 Box2D/Box2D_wrap.cpp:16372:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,882 16372 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,882 | ^~ 2025-09-08T14:56:10,885 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,885 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,885 | ^~~~ 2025-09-08T14:56:10,885 Box2D/Box2D_wrap.cpp:16372:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,885 16372 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,886 | ^~~~~~~~~ 2025-09-08T14:56:10,886 Box2D/Box2D_wrap.cpp:16374:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,886 16374 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,886 | ^~ 2025-09-08T14:56:10,889 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,889 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,889 | ^~~~ 2025-09-08T14:56:10,889 Box2D/Box2D_wrap.cpp:16374:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,889 16374 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,890 | ^~~~~~~~~ 2025-09-08T14:56:10,892 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___IsTouching(PyObject*, PyObject*)’: 2025-09-08T14:56:10,892 Box2D/Box2D_wrap.cpp:16392:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,892 16392 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,892 | ^~ 2025-09-08T14:56:10,892 Box2D/Box2D_wrap.cpp:16392:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,892 16392 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,893 | ^~~~~~~~ 2025-09-08T14:56:10,895 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___IsEnabled(PyObject*, PyObject*)’: 2025-09-08T14:56:10,895 Box2D/Box2D_wrap.cpp:16410:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,896 16410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,896 | ^~ 2025-09-08T14:56:10,896 Box2D/Box2D_wrap.cpp:16410:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,896 16410 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,896 | ^~~~~~~~ 2025-09-08T14:56:10,900 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetNext(PyObject*, PyObject*)’: 2025-09-08T14:56:10,900 Box2D/Box2D_wrap.cpp:16433:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,900 16433 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,900 | ^~ 2025-09-08T14:56:10,900 Box2D/Box2D_wrap.cpp:16433:94: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,900 16433 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,900 | ^~ 2025-09-08T14:56:10,901 Box2D/Box2D_wrap.cpp:16435:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,901 16435 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,901 | ^~ 2025-09-08T14:56:10,904 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,905 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,905 | ^~~~ 2025-09-08T14:56:10,905 Box2D/Box2D_wrap.cpp:16435:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,905 16435 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,905 | ^~~~~~~~~ 2025-09-08T14:56:10,905 Box2D/Box2D_wrap.cpp:16437:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,905 16437 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,905 | ^~ 2025-09-08T14:56:10,909 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,909 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,909 | ^~~~ 2025-09-08T14:56:10,909 Box2D/Box2D_wrap.cpp:16437:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,909 16437 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,909 | ^~~~~~~~~ 2025-09-08T14:56:10,912 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureA(PyObject*, PyObject*)’: 2025-09-08T14:56:10,913 Box2D/Box2D_wrap.cpp:16457:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,913 16457 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureA", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,913 | ^~ 2025-09-08T14:56:10,913 Box2D/Box2D_wrap.cpp:16457:98: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,913 16457 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureA", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,913 | ^~ 2025-09-08T14:56:10,914 Box2D/Box2D_wrap.cpp:16459:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,914 16459 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,914 | ^~ 2025-09-08T14:56:10,917 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,917 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,918 | ^~~~ 2025-09-08T14:56:10,918 Box2D/Box2D_wrap.cpp:16459:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,918 16459 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,918 | ^~~~~~~~~ 2025-09-08T14:56:10,918 Box2D/Box2D_wrap.cpp:16461:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,918 16461 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,918 | ^~ 2025-09-08T14:56:10,922 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,922 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,922 | ^~~~ 2025-09-08T14:56:10,922 Box2D/Box2D_wrap.cpp:16461:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,922 16461 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,922 | ^~~~~~~~~ 2025-09-08T14:56:10,923 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetChildIndexA(PyObject*, PyObject*)’: 2025-09-08T14:56:10,923 Box2D/Box2D_wrap.cpp:16466:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,923 16466 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,923 | ^~ 2025-09-08T14:56:10,923 Box2D/Box2D_wrap.cpp:16466:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,923 16466 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,923 | ^~~~~~~~ 2025-09-08T14:56:10,927 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFixtureB(PyObject*, PyObject*)’: 2025-09-08T14:56:10,928 Box2D/Box2D_wrap.cpp:16489:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,928 16489 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureB", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,928 | ^~ 2025-09-08T14:56:10,928 Box2D/Box2D_wrap.cpp:16489:98: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,928 16489 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Contact___GetFixtureB", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:10,928 | ^~ 2025-09-08T14:56:10,929 Box2D/Box2D_wrap.cpp:16491:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,929 16491 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,929 | ^~ 2025-09-08T14:56:10,933 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,933 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,933 | ^~~~ 2025-09-08T14:56:10,933 Box2D/Box2D_wrap.cpp:16491:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,933 16491 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:10,933 | ^~~~~~~~~ 2025-09-08T14:56:10,933 Box2D/Box2D_wrap.cpp:16493:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,933 16493 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,934 | ^~ 2025-09-08T14:56:10,937 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,937 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:10,937 | ^~~~ 2025-09-08T14:56:10,937 Box2D/Box2D_wrap.cpp:16493:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:10,938 16493 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:10,938 | ^~~~~~~~~ 2025-09-08T14:56:10,938 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetChildIndexB(PyObject*, PyObject*)’: 2025-09-08T14:56:10,938 Box2D/Box2D_wrap.cpp:16498:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,939 16498 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,939 | ^~ 2025-09-08T14:56:10,939 Box2D/Box2D_wrap.cpp:16498:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,939 16498 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,939 | ^~~~~~~~ 2025-09-08T14:56:10,943 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetFriction(PyObject*, PyObject*)’: 2025-09-08T14:56:10,943 Box2D/Box2D_wrap.cpp:16516:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,943 16516 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,943 | ^~ 2025-09-08T14:56:10,943 Box2D/Box2D_wrap.cpp:16516:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,943 16516 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,943 | ^~~~~~~~ 2025-09-08T14:56:10,948 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetRestitution(PyObject*, PyObject*)’: 2025-09-08T14:56:10,948 Box2D/Box2D_wrap.cpp:16541:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,948 16541 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,948 | ^~ 2025-09-08T14:56:10,948 Box2D/Box2D_wrap.cpp:16541:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,949 16541 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,949 | ^~~~~~~~ 2025-09-08T14:56:10,952 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___GetTangentSpeed(PyObject*, PyObject*)’: 2025-09-08T14:56:10,953 Box2D/Box2D_wrap.cpp:16566:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,953 16566 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,953 | ^~ 2025-09-08T14:56:10,953 Box2D/Box2D_wrap.cpp:16566:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,953 16566 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,953 | ^~~~~~~~ 2025-09-08T14:56:10,957 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Contact___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,957 Box2D/Box2D_wrap.cpp:16598:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,957 16598 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,957 | ^~ 2025-09-08T14:56:10,957 Box2D/Box2D_wrap.cpp:16598:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,958 16598 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Contact, 0 | 0 ); 2025-09-08T14:56:10,958 | ^~~~~~~~ 2025-09-08T14:56:10,964 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian_angularA_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,964 Box2D/Box2D_wrap.cpp:16645:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,964 16645 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2025-09-08T14:56:10,964 | ^~ 2025-09-08T14:56:10,964 Box2D/Box2D_wrap.cpp:16645:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,964 16645 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2025-09-08T14:56:10,964 | ^~~~~~~~ 2025-09-08T14:56:10,967 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian_angularB_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,967 Box2D/Box2D_wrap.cpp:16661:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,967 16661 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2025-09-08T14:56:10,967 | ^~ 2025-09-08T14:56:10,967 Box2D/Box2D_wrap.cpp:16661:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,967 16661 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2025-09-08T14:56:10,967 | ^~~~~~~~ 2025-09-08T14:56:10,968 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Jacobian___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,969 Box2D/Box2D_wrap.cpp:16668:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,969 16668 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2025-09-08T14:56:10,969 | ^~ 2025-09-08T14:56:10,969 Box2D/Box2D_wrap.cpp:16668:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,969 16668 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Jacobian, 0 | 0 ); 2025-09-08T14:56:10,969 | ^~~~~~~~ 2025-09-08T14:56:10,971 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2Jacobian(PyObject*, PyObject*)’: 2025-09-08T14:56:10,972 Box2D/Box2D_wrap.cpp:16681:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,972 16681 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,972 | ^~ 2025-09-08T14:56:10,972 Box2D/Box2D_wrap.cpp:16681:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,972 16681 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,972 | ^~~~~~~~ 2025-09-08T14:56:10,985 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointEdge___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:10,985 Box2D/Box2D_wrap.cpp:16786:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,985 16786 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2025-09-08T14:56:10,985 | ^~ 2025-09-08T14:56:10,985 Box2D/Box2D_wrap.cpp:16786:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,985 16786 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointEdge, 0 | 0 ); 2025-09-08T14:56:10,985 | ^~~~~~~~ 2025-09-08T14:56:10,988 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2JointEdge(PyObject*, PyObject*)’: 2025-09-08T14:56:10,988 Box2D/Box2D_wrap.cpp:16799:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,988 16799 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,988 | ^~ 2025-09-08T14:56:10,988 Box2D/Box2D_wrap.cpp:16799:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,988 16799 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:10,989 | ^~~~~~~~ 2025-09-08T14:56:10,992 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_type_get(PyObject*, PyObject*)’: 2025-09-08T14:56:10,993 Box2D/Box2D_wrap.cpp:16831:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:10,993 16831 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2025-09-08T14:56:10,993 | ^~ 2025-09-08T14:56:10,993 Box2D/Box2D_wrap.cpp:16831:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:10,993 16831 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2025-09-08T14:56:10,993 | ^~~~~~~~ 2025-09-08T14:56:10,999 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_collideConnected_get(PyObject*, PyObject*)’: 2025-09-08T14:56:11,000 Box2D/Box2D_wrap.cpp:16884:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,000 16884 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2025-09-08T14:56:11,000 | ^~ 2025-09-08T14:56:11,000 Box2D/Box2D_wrap.cpp:16884:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,000 16884 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2025-09-08T14:56:11,000 | ^~~~~~~~ 2025-09-08T14:56:11,001 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:11,001 Box2D/Box2D_wrap.cpp:16891:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,001 16891 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2025-09-08T14:56:11,001 | ^~ 2025-09-08T14:56:11,001 Box2D/Box2D_wrap.cpp:16891:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,001 16891 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2025-09-08T14:56:11,002 | ^~~~~~~~ 2025-09-08T14:56:11,005 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2JointDef_ClearUserData(PyObject*, PyObject*)’: 2025-09-08T14:56:11,005 Box2D/Box2D_wrap.cpp:16916:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,005 16916 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2025-09-08T14:56:11,005 | ^~ 2025-09-08T14:56:11,005 Box2D/Box2D_wrap.cpp:16916:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,005 16916 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2JointDef, 0 | 0 ); 2025-09-08T14:56:11,006 | ^~~~~~~~ 2025-09-08T14:56:11,007 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2JointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,007 Box2D/Box2D_wrap.cpp:16923:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,007 16923 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,007 | ^~ 2025-09-08T14:56:11,007 Box2D/Box2D_wrap.cpp:16923:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,007 16923 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,007 | ^~~~~~~~ 2025-09-08T14:56:11,009 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetType(PyObject*, PyObject*)’: 2025-09-08T14:56:11,009 Box2D/Box2D_wrap.cpp:16941:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,009 16941 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,009 | ^~ 2025-09-08T14:56:11,010 Box2D/Box2D_wrap.cpp:16941:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,010 16941 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,010 | ^~~~~~~~ 2025-09-08T14:56:11,011 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetBodyA(PyObject*, PyObject*)’: 2025-09-08T14:56:11,011 Box2D/Box2D_wrap.cpp:16949:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,011 16949 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,011 | ^~ 2025-09-08T14:56:11,011 Box2D/Box2D_wrap.cpp:16949:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,012 16949 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,012 | ^~~~~~~~ 2025-09-08T14:56:11,013 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetBodyB(PyObject*, PyObject*)’: 2025-09-08T14:56:11,013 Box2D/Box2D_wrap.cpp:16957:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,013 16957 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,013 | ^~ 2025-09-08T14:56:11,013 Box2D/Box2D_wrap.cpp:16957:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,014 16957 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,014 | ^~~~~~~~ 2025-09-08T14:56:11,022 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext__SWIG_0(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:11,022 Box2D/Box2D_wrap.cpp:17008:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,022 17008 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,022 | ^~ 2025-09-08T14:56:11,022 Box2D/Box2D_wrap.cpp:17008:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,023 17008 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,023 | ^~~~ 2025-09-08T14:56:11,026 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext__SWIG_1(PyObject*, Py_ssize_t, PyObject**)’: 2025-09-08T14:56:11,026 Box2D/Box2D_wrap.cpp:17028:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,026 17028 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,026 | ^~ 2025-09-08T14:56:11,026 Box2D/Box2D_wrap.cpp:17028:46: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,026 17028 | if ((nobjs < 1) || (nobjs > 1)) SWIG_fail; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,026 | ^~~~ 2025-09-08T14:56:11,029 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetNext(PyObject*, PyObject*)’: 2025-09-08T14:56:11,029 Box2D/Box2D_wrap.cpp:17048:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,029 17048 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Joint___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:11,030 | ^~ 2025-09-08T14:56:11,030 Box2D/Box2D_wrap.cpp:17048:92: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,030 17048 | if (!(argc = SWIG_Python_UnpackTuple(args, "b2Joint___GetNext", 0, 1, argv))) SWIG_fail; --argc; if (argc == 1) { 2025-09-08T14:56:11,030 | ^~ 2025-09-08T14:56:11,031 Box2D/Box2D_wrap.cpp:17050:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,031 17050 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:11,031 | ^~ 2025-09-08T14:56:11,035 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,035 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:11,035 | ^~~~ 2025-09-08T14:56:11,035 Box2D/Box2D_wrap.cpp:17050:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:11,035 17050 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} if (argc == 1) { 2025-09-08T14:56:11,035 | ^~~~~~~~~ 2025-09-08T14:56:11,035 Box2D/Box2D_wrap.cpp:17052:5: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,035 17052 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:11,036 | ^~ 2025-09-08T14:56:11,039 Box2D/Box2D_wrap.cpp:1205:57: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,039 1205 | #define SWIG_fail goto fail 2025-09-08T14:56:11,040 | ^~~~ 2025-09-08T14:56:11,040 Box2D/Box2D_wrap.cpp:17052:64: note: in expansion of macro ‘SWIG_fail’ 2025-09-08T14:56:11,040 17052 | if (!SWIG_Python_TypeErrorOccurred(retobj)) return retobj; SWIG_fail;} fail: 2025-09-08T14:56:11,040 | ^~~~~~~~~ 2025-09-08T14:56:11,041 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___IsActive(PyObject*, PyObject*)’: 2025-09-08T14:56:11,041 Box2D/Box2D_wrap.cpp:17057:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,041 17057 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,041 | ^~ 2025-09-08T14:56:11,041 Box2D/Box2D_wrap.cpp:17057:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,041 17057 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,041 | ^~~~~~~~ 2025-09-08T14:56:11,043 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetCollideConnected(PyObject*, PyObject*)’: 2025-09-08T14:56:11,043 Box2D/Box2D_wrap.cpp:17065:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,043 17065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,043 | ^~ 2025-09-08T14:56:11,044 Box2D/Box2D_wrap.cpp:17065:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,044 17065 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,044 | ^~~~~~~~ 2025-09-08T14:56:11,049 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:11,049 Box2D/Box2D_wrap.cpp:17096:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,049 17096 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,049 | ^~ 2025-09-08T14:56:11,050 Box2D/Box2D_wrap.cpp:17096:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,050 17096 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,050 | ^~~~~~~~ 2025-09-08T14:56:11,050 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2Joint___GetUserData(PyObject*, PyObject*)’: 2025-09-08T14:56:11,051 Box2D/Box2D_wrap.cpp:17104:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,051 17104 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,051 | ^~ 2025-09-08T14:56:11,051 Box2D/Box2D_wrap.cpp:17104:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,051 17104 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2Joint, 0 | 0 ); 2025-09-08T14:56:11,051 | ^~~~~~~~ 2025-09-08T14:56:11,075 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,075 Box2D/Box2D_wrap.cpp:17284:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,076 17284 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,076 | ^~ 2025-09-08T14:56:11,076 Box2D/Box2D_wrap.cpp:17284:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,076 17284 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,076 | ^~~~~~~~ 2025-09-08T14:56:11,089 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2DistanceJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,089 Box2D/Box2D_wrap.cpp:17387:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,089 17387 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,089 | ^~ 2025-09-08T14:56:11,089 Box2D/Box2D_wrap.cpp:17387:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,089 17387 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,089 | ^~~~~~~~ 2025-09-08T14:56:11,108 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2FrictionJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,108 Box2D/Box2D_wrap.cpp:17525:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,108 17525 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,108 | ^~ 2025-09-08T14:56:11,108 Box2D/Box2D_wrap.cpp:17525:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,109 17525 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,109 | ^~~~~~~~ 2025-09-08T14:56:11,119 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2FrictionJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,119 Box2D/Box2D_wrap.cpp:17609:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,120 17609 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,120 | ^~ 2025-09-08T14:56:11,120 Box2D/Box2D_wrap.cpp:17609:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,120 17609 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,120 | ^~~~~~~~ 2025-09-08T14:56:11,133 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2GearJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,133 Box2D/Box2D_wrap.cpp:17715:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,133 17715 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,134 | ^~ 2025-09-08T14:56:11,134 Box2D/Box2D_wrap.cpp:17715:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,134 17715 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,134 | ^~~~~~~~ 2025-09-08T14:56:11,142 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint___GetRatio(PyObject*, PyObject*)’: 2025-09-08T14:56:11,142 Box2D/Box2D_wrap.cpp:17785:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,142 17785 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2025-09-08T14:56:11,142 | ^~ 2025-09-08T14:56:11,143 Box2D/Box2D_wrap.cpp:17785:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,143 17785 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2025-09-08T14:56:11,143 | ^~~~~~~~ 2025-09-08T14:56:11,144 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2GearJoint___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:11,144 Box2D/Box2D_wrap.cpp:17793:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,144 17793 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2025-09-08T14:56:11,145 | ^~ 2025-09-08T14:56:11,145 Box2D/Box2D_wrap.cpp:17793:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,145 17793 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2GearJoint, 0 | 0 ); 2025-09-08T14:56:11,145 | ^~~~~~~~ 2025-09-08T14:56:11,146 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2GearJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,146 Box2D/Box2D_wrap.cpp:17801:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,147 17801 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,147 | ^~ 2025-09-08T14:56:11,147 Box2D/Box2D_wrap.cpp:17801:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,147 17801 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,147 | ^~~~~~~~ 2025-09-08T14:56:11,164 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2MotorJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,164 Box2D/Box2D_wrap.cpp:17929:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,164 17929 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,164 | ^~ 2025-09-08T14:56:11,164 Box2D/Box2D_wrap.cpp:17929:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,165 17929 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,165 | ^~~~~~~~ 2025-09-08T14:56:11,172 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetAngularOffset(PyObject*, PyObject*)’: 2025-09-08T14:56:11,172 Box2D/Box2D_wrap.cpp:17985:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,172 17985 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2025-09-08T14:56:11,172 | ^~ 2025-09-08T14:56:11,172 Box2D/Box2D_wrap.cpp:17985:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,172 17985 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2025-09-08T14:56:11,172 | ^~~~~~~~ 2025-09-08T14:56:11,175 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetMaxForce(PyObject*, PyObject*)’: 2025-09-08T14:56:11,175 Box2D/Box2D_wrap.cpp:18005:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,175 18005 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2025-09-08T14:56:11,175 | ^~ 2025-09-08T14:56:11,176 Box2D/Box2D_wrap.cpp:18005:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,176 18005 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2025-09-08T14:56:11,176 | ^~~~~~~~ 2025-09-08T14:56:11,179 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MotorJoint___GetMaxTorque(PyObject*, PyObject*)’: 2025-09-08T14:56:11,179 Box2D/Box2D_wrap.cpp:18024:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,179 18024 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2025-09-08T14:56:11,179 | ^~ 2025-09-08T14:56:11,179 Box2D/Box2D_wrap.cpp:18024:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,179 18024 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MotorJoint, 0 | 0 ); 2025-09-08T14:56:11,179 | ^~~~~~~~ 2025-09-08T14:56:11,181 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2MotorJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,181 Box2D/Box2D_wrap.cpp:18032:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,181 18032 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,181 | ^~ 2025-09-08T14:56:11,181 Box2D/Box2D_wrap.cpp:18032:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,181 18032 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,181 | ^~~~~~~~ 2025-09-08T14:56:11,195 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2MouseJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,196 Box2D/Box2D_wrap.cpp:18135:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,196 18135 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,196 | ^~ 2025-09-08T14:56:11,196 Box2D/Box2D_wrap.cpp:18135:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,196 18135 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,196 | ^~~~~~~~ 2025-09-08T14:56:11,203 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetMaxForce(PyObject*, PyObject*)’: 2025-09-08T14:56:11,204 Box2D/Box2D_wrap.cpp:18189:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,204 18189 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2025-09-08T14:56:11,204 | ^~ 2025-09-08T14:56:11,204 Box2D/Box2D_wrap.cpp:18189:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,204 18189 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2025-09-08T14:56:11,204 | ^~~~~~~~ 2025-09-08T14:56:11,207 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetFrequency(PyObject*, PyObject*)’: 2025-09-08T14:56:11,207 Box2D/Box2D_wrap.cpp:18208:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,207 18208 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2025-09-08T14:56:11,207 | ^~ 2025-09-08T14:56:11,207 Box2D/Box2D_wrap.cpp:18208:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,207 18208 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2025-09-08T14:56:11,207 | ^~~~~~~~ 2025-09-08T14:56:11,216 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___GetDampingRatio(PyObject*, PyObject*)’: 2025-09-08T14:56:11,216 Box2D/Box2D_wrap.cpp:18227:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,216 18227 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2025-09-08T14:56:11,216 | ^~ 2025-09-08T14:56:11,217 Box2D/Box2D_wrap.cpp:18227:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,217 18227 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2025-09-08T14:56:11,217 | ^~~~~~~~ 2025-09-08T14:56:11,217 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2MouseJoint___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:11,217 Box2D/Box2D_wrap.cpp:18235:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,217 18235 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2025-09-08T14:56:11,217 | ^~ 2025-09-08T14:56:11,217 Box2D/Box2D_wrap.cpp:18235:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,217 18235 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2MouseJoint, 0 | 0 ); 2025-09-08T14:56:11,217 | ^~~~~~~~ 2025-09-08T14:56:11,218 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2MouseJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,218 Box2D/Box2D_wrap.cpp:18243:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,218 18243 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,218 | ^~ 2025-09-08T14:56:11,218 Box2D/Box2D_wrap.cpp:18243:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,218 18243 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,218 | ^~~~~~~~ 2025-09-08T14:56:11,218 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_new_b2PrismaticJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,218 Box2D/Box2D_wrap.cpp:18257:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,218 18257 | if (!SWIG_Python_UnpackTuple(args, "new_b2PrismaticJointDef", 0, 0, 0)) SWIG_fail; { try { 2025-09-08T14:56:11,218 | ^~ 2025-09-08T14:56:11,219 Box2D/Box2D_wrap.cpp:18257:86: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,219 18257 | if (!SWIG_Python_UnpackTuple(args, "new_b2PrismaticJointDef", 0, 0, 0)) SWIG_fail; { try { 2025-09-08T14:56:11,219 | ^ 2025-09-08T14:56:11,249 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PrismaticJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,250 Box2D/Box2D_wrap.cpp:18504:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,250 18504 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,250 | ^~ 2025-09-08T14:56:11,250 Box2D/Box2D_wrap.cpp:18504:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,250 18504 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,250 | ^~~~~~~~ 2025-09-08T14:56:11,275 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PrismaticJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,275 Box2D/Box2D_wrap.cpp:18707:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,275 18707 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,275 | ^~ 2025-09-08T14:56:11,275 Box2D/Box2D_wrap.cpp:18707:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,275 18707 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,275 | ^~~~~~~~ 2025-09-08T14:56:11,310 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PulleyJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,310 Box2D/Box2D_wrap.cpp:18945:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,310 18945 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,310 | ^~ 2025-09-08T14:56:11,311 Box2D/Box2D_wrap.cpp:18945:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,311 18945 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,311 | ^~~~~~~~ 2025-09-08T14:56:11,321 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2PulleyJoint___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:11,321 Box2D/Box2D_wrap.cpp:19023:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,321 19023 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2025-09-08T14:56:11,321 | ^~ 2025-09-08T14:56:11,322 Box2D/Box2D_wrap.cpp:19023:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,322 19023 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2PulleyJoint, 0 | 0 ); 2025-09-08T14:56:11,322 | ^~~~~~~~ 2025-09-08T14:56:11,324 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2PulleyJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,324 Box2D/Box2D_wrap.cpp:19031:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,324 19031 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,324 | ^~ 2025-09-08T14:56:11,324 Box2D/Box2D_wrap.cpp:19031:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,324 19031 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,325 | ^~~~~~~~ 2025-09-08T14:56:11,354 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RevoluteJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,355 Box2D/Box2D_wrap.cpp:19259:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,355 19259 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,355 | ^~ 2025-09-08T14:56:11,355 Box2D/Box2D_wrap.cpp:19259:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,355 19259 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,355 | ^~~~~~~~ 2025-09-08T14:56:11,380 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RevoluteJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,380 Box2D/Box2D_wrap.cpp:19453:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,380 19453 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,380 | ^~ 2025-09-08T14:56:11,381 Box2D/Box2D_wrap.cpp:19453:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,381 19453 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,381 | ^~~~~~~~ 2025-09-08T14:56:11,395 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RopeJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,395 Box2D/Box2D_wrap.cpp:19546:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,395 19546 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,395 | ^~ 2025-09-08T14:56:11,395 Box2D/Box2D_wrap.cpp:19546:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,396 19546 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,396 | ^~~~~~~~ 2025-09-08T14:56:11,402 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint___GetMaxLength(PyObject*, PyObject*)’: 2025-09-08T14:56:11,402 Box2D/Box2D_wrap.cpp:19592:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,402 19592 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2025-09-08T14:56:11,402 | ^~ 2025-09-08T14:56:11,403 Box2D/Box2D_wrap.cpp:19592:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,403 19592 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2025-09-08T14:56:11,403 | ^~~~~~~~ 2025-09-08T14:56:11,406 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2RopeJoint___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:11,406 Box2D/Box2D_wrap.cpp:19609:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,406 19609 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2025-09-08T14:56:11,406 | ^~ 2025-09-08T14:56:11,406 Box2D/Box2D_wrap.cpp:19609:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,407 19609 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2RopeJoint, 0 | 0 ); 2025-09-08T14:56:11,407 | ^~~~~~~~ 2025-09-08T14:56:11,408 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2RopeJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,409 Box2D/Box2D_wrap.cpp:19617:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,409 19617 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,409 | ^~ 2025-09-08T14:56:11,409 Box2D/Box2D_wrap.cpp:19617:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,409 19617 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,410 | ^~~~~~~~ 2025-09-08T14:56:11,431 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2WeldJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,431 Box2D/Box2D_wrap.cpp:19770:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,432 19770 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,432 | ^~ 2025-09-08T14:56:11,432 Box2D/Box2D_wrap.cpp:19770:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,432 19770 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,432 | ^~~~~~~~ 2025-09-08T14:56:11,436 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetReferenceAngle(PyObject*, PyObject*)’: 2025-09-08T14:56:11,437 Box2D/Box2D_wrap.cpp:19806:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,437 19806 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2025-09-08T14:56:11,437 | ^~ 2025-09-08T14:56:11,437 Box2D/Box2D_wrap.cpp:19806:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,437 19806 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2025-09-08T14:56:11,437 | ^~~~~~~~ 2025-09-08T14:56:11,441 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetFrequency(PyObject*, PyObject*)’: 2025-09-08T14:56:11,441 Box2D/Box2D_wrap.cpp:19824:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,441 19824 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2025-09-08T14:56:11,441 | ^~ 2025-09-08T14:56:11,441 Box2D/Box2D_wrap.cpp:19824:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,441 19824 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2025-09-08T14:56:11,442 | ^~~~~~~~ 2025-09-08T14:56:11,445 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint_GetDampingRatio(PyObject*, PyObject*)’: 2025-09-08T14:56:11,445 Box2D/Box2D_wrap.cpp:19843:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,445 19843 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2025-09-08T14:56:11,445 | ^~ 2025-09-08T14:56:11,446 Box2D/Box2D_wrap.cpp:19843:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,446 19843 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2025-09-08T14:56:11,446 | ^~~~~~~~ 2025-09-08T14:56:11,447 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WeldJoint___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:11,448 Box2D/Box2D_wrap.cpp:19851:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,448 19851 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2025-09-08T14:56:11,448 | ^~ 2025-09-08T14:56:11,448 Box2D/Box2D_wrap.cpp:19851:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,448 19851 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WeldJoint, 0 | 0 ); 2025-09-08T14:56:11,448 | ^~~~~~~~ 2025-09-08T14:56:11,450 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2WeldJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,450 Box2D/Box2D_wrap.cpp:19859:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,450 19859 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,451 | ^~ 2025-09-08T14:56:11,451 Box2D/Box2D_wrap.cpp:19859:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,451 19859 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,451 | ^~~~~~~~ 2025-09-08T14:56:11,482 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2WheelJointDef(PyObject*, PyObject*)’: 2025-09-08T14:56:11,482 Box2D/Box2D_wrap.cpp:20078:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,482 20078 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,482 | ^~ 2025-09-08T14:56:11,483 Box2D/Box2D_wrap.cpp:20078:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,483 20078 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,483 | ^~~~~~~~ 2025-09-08T14:56:11,489 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetJointTranslation(PyObject*, PyObject*)’: 2025-09-08T14:56:11,489 Box2D/Box2D_wrap.cpp:20123:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,489 20123 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,489 | ^~ 2025-09-08T14:56:11,489 Box2D/Box2D_wrap.cpp:20123:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,490 20123 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,490 | ^~~~~~~~ 2025-09-08T14:56:11,491 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetJointSpeed(PyObject*, PyObject*)’: 2025-09-08T14:56:11,492 Box2D/Box2D_wrap.cpp:20132:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,492 20132 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,492 | ^~ 2025-09-08T14:56:11,492 Box2D/Box2D_wrap.cpp:20132:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,492 20132 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,492 | ^~~~~~~~ 2025-09-08T14:56:11,494 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___IsMotorEnabled(PyObject*, PyObject*)’: 2025-09-08T14:56:11,494 Box2D/Box2D_wrap.cpp:20140:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,494 20140 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,495 | ^~ 2025-09-08T14:56:11,495 Box2D/Box2D_wrap.cpp:20140:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,495 20140 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,495 | ^~~~~~~~ 2025-09-08T14:56:11,500 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetMotorSpeed(PyObject*, PyObject*)’: 2025-09-08T14:56:11,500 Box2D/Box2D_wrap.cpp:20169:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,501 20169 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,501 | ^~ 2025-09-08T14:56:11,501 Box2D/Box2D_wrap.cpp:20169:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,501 20169 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,501 | ^~~~~~~~ 2025-09-08T14:56:11,505 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetMaxMotorTorque(PyObject*, PyObject*)’: 2025-09-08T14:56:11,505 Box2D/Box2D_wrap.cpp:20188:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,505 20188 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,505 | ^~ 2025-09-08T14:56:11,506 Box2D/Box2D_wrap.cpp:20188:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,506 20188 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,506 | ^~~~~~~~ 2025-09-08T14:56:11,511 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetSpringFrequencyHz(PyObject*, PyObject*)’: 2025-09-08T14:56:11,512 Box2D/Box2D_wrap.cpp:20220:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,512 20220 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,512 | ^~ 2025-09-08T14:56:11,512 Box2D/Box2D_wrap.cpp:20220:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,513 20220 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,513 | ^~~~~~~~ 2025-09-08T14:56:11,516 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___GetSpringDampingRatio(PyObject*, PyObject*)’: 2025-09-08T14:56:11,516 Box2D/Box2D_wrap.cpp:20240:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,517 20240 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,517 | ^~ 2025-09-08T14:56:11,517 Box2D/Box2D_wrap.cpp:20240:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,518 20240 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,518 | ^~~~~~~~ 2025-09-08T14:56:11,520 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_b2WheelJoint___hash__(PyObject*, PyObject*)’: 2025-09-08T14:56:11,520 Box2D/Box2D_wrap.cpp:20249:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,520 20249 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,520 | ^~ 2025-09-08T14:56:11,521 Box2D/Box2D_wrap.cpp:20249:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,521 20249 | if (!args) SWIG_fail; swig_obj[0] = args; res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_b2WheelJoint, 0 | 0 ); 2025-09-08T14:56:11,521 | ^~~~~~~~ 2025-09-08T14:56:11,523 Box2D/Box2D_wrap.cpp: In function ‘PyObject* _wrap_delete_b2WheelJoint(PyObject*, PyObject*)’: 2025-09-08T14:56:11,523 Box2D/Box2D_wrap.cpp:20257:3: warning: this ‘if’ clause does not guard... [-Wmisleading-indentation] 2025-09-08T14:56:11,523 20257 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,523 | ^~ 2025-09-08T14:56:11,524 Box2D/Box2D_wrap.cpp:20257:25: note: ...this statement, but the latter is misleadingly indented as if it were guarded by the ‘if’ 2025-09-08T14:56:11,524 20257 | if (!args) SWIG_fail; swig_obj[0] = args; 2025-09-08T14:56:11,524 | ^~~~~~~~ 2025-09-08T14:57:16,050 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/Shapes/b2ChainShape.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes/b2ChainShape.o -I. -Wno-unused 2025-09-08T14:57:17,429 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/Shapes/b2CircleShape.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes/b2CircleShape.o -I. -Wno-unused 2025-09-08T14:57:18,649 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/Shapes/b2EdgeShape.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes/b2EdgeShape.o -I. -Wno-unused 2025-09-08T14:57:19,896 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/Shapes/b2PolygonShape.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes/b2PolygonShape.o -I. -Wno-unused 2025-09-08T14:57:21,568 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/b2BroadPhase.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2BroadPhase.o -I. -Wno-unused 2025-09-08T14:57:22,870 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/b2CollideCircle.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2CollideCircle.o -I. -Wno-unused 2025-09-08T14:57:24,114 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/b2CollideEdge.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2CollideEdge.o -I. -Wno-unused 2025-09-08T14:57:25,943 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/b2CollidePolygon.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2CollidePolygon.o -I. -Wno-unused 2025-09-08T14:57:27,378 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/b2Collision.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2Collision.o -I. -Wno-unused 2025-09-08T14:57:28,801 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/b2Distance.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2Distance.o -I. -Wno-unused 2025-09-08T14:57:30,600 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/b2DynamicTree.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2DynamicTree.o -I. -Wno-unused 2025-09-08T14:57:31,492 Box2D/Collision/b2DynamicTree.cpp: In constructor ‘b2DynamicTree::b2DynamicTree()’: 2025-09-08T14:57:31,492 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] 2025-09-08T14:57:31,492 32 | memset(m_nodes, 0, m_nodeCapacity * sizeof(b2TreeNode)); 2025-09-08T14:57:31,492 | ~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 2025-09-08T14:57:31,492 In file included from Box2D/Collision/b2DynamicTree.cpp:19: 2025-09-08T14:57:31,492 ./Box2D/Collision/b2DynamicTree.h:28:8: note: ‘struct b2TreeNode’ declared here 2025-09-08T14:57:31,492 28 | struct b2TreeNode 2025-09-08T14:57:31,493 | ^~~~~~~~~~ 2025-09-08T14:57:32,792 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Collision/b2TimeOfImpact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2TimeOfImpact.o -I. -Wno-unused 2025-09-08T14:57:35,187 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Common/b2BlockAllocator.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2BlockAllocator.o -I. -Wno-unused 2025-09-08T14:57:36,757 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Common/b2Draw.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2Draw.o -I. -Wno-unused 2025-09-08T14:57:37,820 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Common/b2Math.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2Math.o -I. -Wno-unused 2025-09-08T14:57:38,963 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Common/b2Settings.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2Settings.o -I. -Wno-unused 2025-09-08T14:57:39,989 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Common/b2StackAllocator.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2StackAllocator.o -I. -Wno-unused 2025-09-08T14:57:40,850 In file included from ./Box2D/Common/b2StackAllocator.h:22, 2025-09-08T14:57:40,850 from Box2D/Common/b2StackAllocator.cpp:19: 2025-09-08T14:57:40,850 Box2D/Common/b2StackAllocator.cpp: In destructor ‘b2StackAllocator::~b2StackAllocator()’: 2025-09-08T14:57:40,850 ./Box2D/Common/b2Settings.h:31:76: warning: ‘throw’ will always call ‘terminate’ [-Wterminate] 2025-09-08T14:57:40,850 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2025-09-08T14:57:40,850 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2025-09-08T14:57:40,851 Box2D/Common/b2StackAllocator.cpp:32:9: note: in expansion of macro ‘b2Assert’ 2025-09-08T14:57:40,851 32 | b2Assert(m_index == 0); 2025-09-08T14:57:40,851 | ^~~~~~~~ 2025-09-08T14:57:40,851 ./Box2D/Common/b2Settings.h:31:76: note: in C++11 destructors default to ‘noexcept’ 2025-09-08T14:57:40,851 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2025-09-08T14:57:40,851 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2025-09-08T14:57:40,851 Box2D/Common/b2StackAllocator.cpp:32:9: note: in expansion of macro ‘b2Assert’ 2025-09-08T14:57:40,851 32 | b2Assert(m_index == 0); 2025-09-08T14:57:40,851 | ^~~~~~~~ 2025-09-08T14:57:40,852 ./Box2D/Common/b2Settings.h:31:76: warning: ‘throw’ will always call ‘terminate’ [-Wterminate] 2025-09-08T14:57:40,852 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2025-09-08T14:57:40,852 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2025-09-08T14:57:40,852 Box2D/Common/b2StackAllocator.cpp:33:9: note: in expansion of macro ‘b2Assert’ 2025-09-08T14:57:40,852 33 | b2Assert(m_entryCount == 0); 2025-09-08T14:57:40,852 | ^~~~~~~~ 2025-09-08T14:57:40,852 ./Box2D/Common/b2Settings.h:31:76: note: in C++11 destructors default to ‘noexcept’ 2025-09-08T14:57:40,853 31 | #define b2Assert(A) if (!(A)) { PyErr_SetString(PyExc_AssertionError, #A); throw b2AssertException(); } 2025-09-08T14:57:40,853 | ^~~~~~~~~~~~~~~~~~~~~~~~~ 2025-09-08T14:57:40,853 Box2D/Common/b2StackAllocator.cpp:33:9: note: in expansion of macro ‘b2Assert’ 2025-09-08T14:57:40,853 33 | b2Assert(m_entryCount == 0); 2025-09-08T14:57:40,853 | ^~~~~~~~ 2025-09-08T14:57:41,120 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Common/b2Timer.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2Timer.o -I. -Wno-unused 2025-09-08T14:57:42,148 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2ChainAndCircleContact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.o -I. -Wno-unused 2025-09-08T14:57:43,718 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.o -I. -Wno-unused 2025-09-08T14:57:45,300 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2CircleContact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2CircleContact.o -I. -Wno-unused 2025-09-08T14:57:46,866 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2Contact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2Contact.o -I. -Wno-unused 2025-09-08T14:57:48,785 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2ContactSolver.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2ContactSolver.o -I. -Wno-unused 2025-09-08T14:57:51,488 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.o -I. -Wno-unused 2025-09-08T14:57:53,045 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.o -I. -Wno-unused 2025-09-08T14:57:54,602 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.o -I. -Wno-unused 2025-09-08T14:57:56,156 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Contacts/b2PolygonContact.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2PolygonContact.o -I. -Wno-unused 2025-09-08T14:57:57,719 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2DistanceJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2DistanceJoint.o -I. -Wno-unused 2025-09-08T14:57:59,572 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2FrictionJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2FrictionJoint.o -I. -Wno-unused 2025-09-08T14:58:01,381 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2GearJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2GearJoint.o -I. -Wno-unused 2025-09-08T14:58:03,472 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2Joint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2Joint.o -I. -Wno-unused 2025-09-08T14:58:05,208 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2MotorJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2MotorJoint.o -I. -Wno-unused 2025-09-08T14:58:07,075 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2MouseJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2MouseJoint.o -I. -Wno-unused 2025-09-08T14:58:08,879 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2PrismaticJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2PrismaticJoint.o -I. -Wno-unused 2025-09-08T14:58:11,199 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2PulleyJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2PulleyJoint.o -I. -Wno-unused 2025-09-08T14:58:13,186 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2RevoluteJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2RevoluteJoint.o -I. -Wno-unused 2025-09-08T14:58:15,346 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2RopeJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2RopeJoint.o -I. -Wno-unused 2025-09-08T14:58:17,160 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2WeldJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2WeldJoint.o -I. -Wno-unused 2025-09-08T14:58:19,127 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/Joints/b2WheelJoint.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2WheelJoint.o -I. -Wno-unused 2025-09-08T14:58:21,141 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/b2Body.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2Body.o -I. -Wno-unused 2025-09-08T14:58:23,386 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/b2ContactManager.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2ContactManager.o -I. -Wno-unused 2025-09-08T14:58:25,776 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/b2Fixture.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2Fixture.o -I. -Wno-unused 2025-09-08T14:58:27,735 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/b2Island.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2Island.o -I. -Wno-unused 2025-09-08T14:58:29,871 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/b2World.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2World.o -I. -Wno-unused 2025-09-08T14:58:33,504 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -fPIC -I/usr/include/python3.13 -c Box2D/Dynamics/b2WorldCallbacks.cpp -o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2WorldCallbacks.o -I. -Wno-unused 2025-09-08T14:58:34,996 arm-linux-gnueabihf-g++ -fno-strict-overflow -Wsign-compare -DNDEBUG -g -O2 -Wall -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fwrapv -O2 build/temp.linux-armv7l-cpython-313/Box2D/Box2D_wrap.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes/b2ChainShape.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes/b2CircleShape.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes/b2EdgeShape.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/Shapes/b2PolygonShape.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2BroadPhase.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2CollideCircle.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2CollideEdge.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2CollidePolygon.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2Collision.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2Distance.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2DynamicTree.o build/temp.linux-armv7l-cpython-313/Box2D/Collision/b2TimeOfImpact.o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2BlockAllocator.o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2Draw.o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2Math.o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2Settings.o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2StackAllocator.o build/temp.linux-armv7l-cpython-313/Box2D/Common/b2Timer.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2ChainAndCircleContact.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2ChainAndPolygonContact.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2CircleContact.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2Contact.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2ContactSolver.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2EdgeAndCircleContact.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2EdgeAndPolygonContact.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2PolygonAndCircleContact.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Contacts/b2PolygonContact.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2DistanceJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2FrictionJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2GearJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2Joint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2MotorJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2MouseJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2PrismaticJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2PulleyJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2RevoluteJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2RopeJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2WeldJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/Joints/b2WheelJoint.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2Body.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2ContactManager.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2Fixture.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2Island.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2World.o build/temp.linux-armv7l-cpython-313/Box2D/Dynamics/b2WorldCallbacks.o -L/usr/lib/arm-linux-gnueabihf -o build/lib.linux-armv7l-cpython-313/Box2D/_Box2D.cpython-313-arm-linux-gnueabihf.so 2025-09-08T14:58:35,623 /usr/local/lib/python3.13/dist-packages/setuptools/_distutils/cmd.py:90: SetuptoolsDeprecationWarning: setup.py install is deprecated. 2025-09-08T14:58:35,623 !! 2025-09-08T14:58:35,624 ******************************************************************************** 2025-09-08T14:58:35,624 Please avoid running ``setup.py`` directly. 2025-09-08T14:58:35,624 Instead, use pypa/build, pypa/installer or other 2025-09-08T14:58:35,624 standards-based tools. 2025-09-08T14:58:35,624 By 2025-Oct-31, you need to update your project and remove deprecated calls 2025-09-08T14:58:35,624 or your builds will no longer be supported. 2025-09-08T14:58:35,624 See https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html for details. 2025-09-08T14:58:35,624 ******************************************************************************** 2025-09-08T14:58:35,624 !! 2025-09-08T14:58:35,625 self.initialize_options() 2025-09-08T14:58:35,755 installing to build/bdist.linux-armv7l/wheel 2025-09-08T14:58:35,755 running install 2025-09-08T14:58:35,779 running install_lib 2025-09-08T14:58:35,851 creating build/bdist.linux-armv7l/wheel 2025-09-08T14:58:35,852 creating build/bdist.linux-armv7l/wheel/Box2D 2025-09-08T14:58:35,853 copying build/lib.linux-armv7l-cpython-313/Box2D/_Box2D.cpython-313-arm-linux-gnueabihf.so -> build/bdist.linux-armv7l/wheel/./Box2D 2025-09-08T14:58:35,875 creating build/bdist.linux-armv7l/wheel/Box2D/b2 2025-09-08T14:58:35,876 copying build/lib.linux-armv7l-cpython-313/Box2D/b2/__init__.py -> build/bdist.linux-armv7l/wheel/./Box2D/b2 2025-09-08T14:58:35,877 copying build/lib.linux-armv7l-cpython-313/Box2D/__init__.py -> build/bdist.linux-armv7l/wheel/./Box2D 2025-09-08T14:58:35,877 copying build/lib.linux-armv7l-cpython-313/Box2D/Box2D.py -> build/bdist.linux-armv7l/wheel/./Box2D 2025-09-08T14:58:35,878 running install_egg_info 2025-09-08T14:58:35,955 running egg_info 2025-09-08T14:58:36,029 writing library/box2d_py.egg-info/PKG-INFO 2025-09-08T14:58:36,031 writing dependency_links to library/box2d_py.egg-info/dependency_links.txt 2025-09-08T14:58:36,031 writing top-level names to library/box2d_py.egg-info/top_level.txt 2025-09-08T14:58:36,111 reading manifest file 'library/box2d_py.egg-info/SOURCES.txt' 2025-09-08T14:58:36,130 reading manifest template 'MANIFEST.in' 2025-09-08T14:58:36,130 warning: no files found matching 'INSTALL' 2025-09-08T14:58:36,131 warning: no files found matching 'MANIFEST' 2025-09-08T14:58:36,131 warning: no files found matching 'README' 2025-09-08T14:58:36,131 warning: no files found matching 'distribute_setup.py' 2025-09-08T14:58:36,182 warning: no files found matching '*.py' under directory 'Box2D' 2025-09-08T14:58:36,206 warning: no files found matching '*.c' under directory 'Box2D' 2025-09-08T14:58:36,211 adding license file 'LICENSE' 2025-09-08T14:58:36,227 writing manifest file 'library/box2d_py.egg-info/SOURCES.txt' 2025-09-08T14:58:36,228 Copying library/box2d_py.egg-info to build/bdist.linux-armv7l/wheel/./box2d_py-2.3.8-py3.13.egg-info 2025-09-08T14:58:36,230 running install_scripts 2025-09-08T14:58:36,230 Re-copying /tmp/pip-wheel-rr9v2e0l/box2d-py_a9dbc856dab44f5bad24cdb56cb54f91/library/Box2D/Box2D.py --> build/bdist.linux-armv7l/wheel/./Box2D/Box2D.py 2025-09-08T14:58:36,231 Re-copying /tmp/pip-wheel-rr9v2e0l/box2d-py_a9dbc856dab44f5bad24cdb56cb54f91/library/Box2D/__init__.py --> build/bdist.linux-armv7l/wheel/./Box2D/__init__.py 2025-09-08T14:58:36,281 creating build/bdist.linux-armv7l/wheel/box2d_py-2.3.8.dist-info/WHEEL 2025-09-08T14:58:36,282 creating '/tmp/pip-wheel-r_3t0tx0/box2d_py-2.3.8-cp313-cp313-linux_armv7l.whl' and adding 'build/bdist.linux-armv7l/wheel' to it 2025-09-08T14:58:36,301 adding 'Box2D/Box2D.py' 2025-09-08T14:58:37,327 adding 'Box2D/_Box2D.cpython-313-arm-linux-gnueabihf.so' 2025-09-08T14:58:37,368 adding 'Box2D/__init__.py' 2025-09-08T14:58:37,369 adding 'Box2D/b2/__init__.py' 2025-09-08T14:58:37,370 adding 'box2d_py-2.3.8.dist-info/licenses/LICENSE' 2025-09-08T14:58:37,371 adding 'box2d_py-2.3.8.dist-info/METADATA' 2025-09-08T14:58:37,371 adding 'box2d_py-2.3.8.dist-info/WHEEL' 2025-09-08T14:58:37,371 adding 'box2d_py-2.3.8.dist-info/top_level.txt' 2025-09-08T14:58:37,372 adding 'box2d_py-2.3.8.dist-info/RECORD' 2025-09-08T14:58:37,372 removing build/bdist.linux-armv7l/wheel 2025-09-08T14:58:37,528 Building wheel for box2d-py (setup.py): finished with status 'done' 2025-09-08T14:58:37,554 Created wheel for box2d-py: filename=box2d_py-2.3.8-cp313-cp313-linux_armv7l.whl size=2217025 sha256=ca359058e880af85b211b2ba3d65237d2ecbbac1d77adeffdb5a14c1b51bf0c4 2025-09-08T14:58:37,555 Stored in directory: /tmp/pip-ephem-wheel-cache-_what2is/wheels/3d/23/99/d64e482977bd5bdc1fec036e03cb33f9eb4a71c41bf4d49859 2025-09-08T14:58:37,563 Successfully built box2d-py 2025-09-08T14:58:37,569 Removed build tracker: '/tmp/pip-build-tracker-__r1wjiv'